Skip to content

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

Beamer 1.5.2

Toby Kalkman8220f556b13a
diff --git a/README.md b/README.md
index b952201..ddcd890 100644
--- a/README.md
+++ b/README.md
@@ -16,13 +16,53 @@ still work, and what you type never leaves your network.
## Download
-Free, with no account. Mac and Windows downloads, and an experimental Linux Flatpak, are on the [releases page](https://github.com/kalkman-code/beamer/releases/latest).
+Free, with no account. Mac, Windows and Linux downloads are on the [releases page](https://github.com/kalkman-code/beamer/releases/latest). Linux uses Flatpak; there is no AppImage.
| Platform | Get it | Notes |
|---|---|---|
| macOS 13 or later, Apple silicon or Intel | `Beamer-<version>.dmg` | One universal app, signed and notarised by Apple |
| Windows 10 and 11 | `Beamer-Setup-<version>.exe` | Not code-signed; see step 1 below |
-| Linux, through Flatpak (experimental) | `Beamer-<version>-x86_64.flatpak`, or build it with [the Linux instructions](docs/flatpak-build.md) | GNOME on Wayland, or X11; tested on one GNOME Wayland desktop |
+| Linux, 64-bit x86 (Flatpak) | [Install from the Kalkman Code repository](https://flatpak.kalkmancode.co.uk/beamer.flatpakref); `Beamer-<version>-x86_64.flatpak` is available as an offline alternative | Tested on Fedora 44 GNOME under Wayland; KDE Plasma is experimental and not yet tested on real hardware; X11 is not yet verified |
+
+### Install on Linux
+
+Beamer for Linux is a Flatpak for 64-bit x86. There is no AppImage. Fedora, Linux
+Mint, Pop!_OS and other distributions with Flatpak can install it with one command:
+
+```sh
+flatpak install --user https://flatpak.kalkmancode.co.uk/beamer.flatpakref
+```
+
+Flatpak asks to add the Kalkman Code repository and fetches the KDE runtime from Flathub. The
+runtime download is a few hundred megabytes the first time only.
+
+On Ubuntu 24.04 or later and Debian 13 or later, install Flatpak first, then log out and back in
+or restart, then run the install command:
+
+```sh
+sudo apt install flatpak
+```
+
+```sh
+flatpak install --user https://flatpak.kalkmancode.co.uk/beamer.flatpakref
+```
+
+Older Ubuntu and Debian releases cannot send input out under Wayland because they lack the
+InputCapture portal; use an X11 session there. On Wayland, allow both desktop prompts: the first
+lets Beamer send input and the second lets it receive input. Start Beamer from the app menu; the
+Flatpak cannot start at sign-in yet. Update with `flatpak update` or your software centre's update
+tool, like any Flatpak.
+
+If you installed an earlier downloaded bundle, remove it first; your settings are kept:
+
+```sh
+flatpak uninstall --user uk.co.kalkman.beamer
+flatpak install --user https://flatpak.kalkmancode.co.uk/beamer.flatpakref
+```
+
+The downloadable `Beamer-<version>-x86_64.flatpak` bundle remains available from the [releases
+page](https://github.com/kalkman-code/beamer/releases/latest) as an offline alternative. To build
+for arm64, follow [the Linux instructions](docs/flatpak-build.md).
## Quick start
@@ -33,8 +73,7 @@ Free, with no account. Mac and Windows downloads, and an experimental Linux Flat
run the installer. It is not code-signed, because a certificate costs money and Beamer is free,
so Windows says "Windows protected your PC" the first time: choose More info, then Run anyway.
Beamer on Windows runs as administrator, so expect one UAC prompt when you open it. On Linux,
- install the Flatpak with `flatpak install --user Beamer-<version>-x86_64.flatpak`, or build it with
- [the Flatpak instructions](docs/flatpak-build.md).
+ follow [Install on Linux](#install-on-linux) to install Beamer from the Kalkman Code repository.
2. **Pair them.** On one machine, choose Pair a machine to show a six-digit code. On the other,
choose that machine from the list and enter the code. It lasts a minute and works once. If it
does not appear in the list, enter the address shown with its code on the other machine.
@@ -51,9 +90,9 @@ In your own appearance: light if your GitHub is light, dark if it is dark.
<table>
<tr><th>Mac</th><th>Windows</th></tr>
-<tr><td><picture><source media="(prefers-color-scheme: light)" srcset="assets/mac-overview-light.png"><img src="assets/mac-overview-dark.png" width="400" alt="Beamer's Overview page on the Mac: where input is, whether the link is up, Send input and Pause crossing, and a switch for each direction"></picture></td><td><picture><source media="(prefers-color-scheme: light)" srcset="assets/windows-overview-light.png"><img src="assets/windows-overview-dark.png" width="400" alt="Beamer's Overview page on Windows: where input is, Send input and Pause crossing, and a switch for each direction"></picture></td></tr>
-<tr><td><picture><source media="(prefers-color-scheme: light)" srcset="assets/mac-crossing-light.png"><img src="assets/mac-crossing-dark.png" width="400" alt="Beamer's Crossing page on the Mac: a drawing of the Mac and the PC side by side with the crossing edge lit, and the ways in"></picture></td><td><picture><source media="(prefers-color-scheme: light)" srcset="assets/windows-crossing-light.png"><img src="assets/windows-crossing-dark.png" width="400" alt="Beamer's Crossing page on Windows: a drawing of the Mac and the PC with the crossing edge lit, the ways in and where the Mac sits"></picture></td></tr>
-<tr><td><picture><source media="(prefers-color-scheme: light)" srcset="assets/mac-design-light.png"><img src="assets/mac-design-dark.png" width="400" alt="Beamer's Design page on the Mac: a tile for each crossing style, shown at the edge, a corner or the notch, and the colours"></picture></td><td><picture><source media="(prefers-color-scheme: light)" srcset="assets/windows-design-light.png"><img src="assets/windows-design-dark.png" width="400" alt="Beamer's Design page on Windows: a tile for each crossing style, shown at the edge, a corner or the notch, and the colours"></picture></td></tr>
+<tr><td><picture><source media="(prefers-color-scheme: light)" srcset="assets/mac-overview-light.png"><img src="assets/mac-overview-dark.png" width="400" alt="Beamer's Overview page on the Mac: a Pair a machine button and a card for each paired machine, a desktop PC, a laptop and a Linux box, each showing it is linked, with an In use switch and Rename, Leave out, Directions and Remove buttons"></picture></td><td><picture><source media="(prefers-color-scheme: light)" srcset="assets/windows-overview-light.png"><img src="assets/windows-overview-dark.png" width="400" alt="Beamer's Overview page on Windows: a Pair a machine button and a card for each paired machine, a Mac, a laptop and a Linux box, each showing it is linked, with an In use switch and Rename, Directions, Leave out and Remove buttons"></picture></td></tr>
+<tr><td><picture><source media="(prefers-color-scheme: light)" srcset="assets/mac-crossing-light.png"><img src="assets/mac-crossing-dark.png" width="400" alt="Beamer's Crossing page on the Mac: a map with this Mac in the middle, a laptop to its left, a desktop PC to its right and a Linux box below, each edge lit where the pointer crosses, and a ledger of how each machine is reached"></picture></td><td><picture><source media="(prefers-color-scheme: light)" srcset="assets/windows-crossing-light.png"><img src="assets/windows-crossing-dark.png" width="400" alt="Beamer's Crossing page on Windows: a map with this PC in the middle, a Mac to its left, a laptop to its right and a Linux box below, each edge lit where the pointer crosses, and a ledger of how each machine is reached"></picture></td></tr>
+<tr><td><picture><source media="(prefers-color-scheme: light)" srcset="assets/mac-design-light.png"><img src="assets/mac-design-dark.png" width="400" alt="Beamer's Design page on the Mac: switches to animate crossings on this Mac and show where the pointer lands, a choice of style for crossing or for the shortcut and menu, shown at the edge, a corner or the notch, and a Light section of preview tiles"></picture></td><td><picture><source media="(prefers-color-scheme: light)" srcset="assets/windows-design-light.png"><img src="assets/windows-design-dark.png" width="400" alt="Beamer's Design page on Windows: switches to animate crossings on this PC and show where the pointer lands, a choice of style for crossing or for the shortcut and menu, shown at the edge or a corner, and a Light section of preview tiles"></picture></td></tr>
</table>
## What it does
@@ -81,7 +120,8 @@ In your own appearance: light if your GitHub is light, dark if it is dark.
arrives as the same physical key. On Windows, you can also choose a Mac keyboard layout, where
Alt acts as Command and the Windows key acts as Option.
- **Media keys follow you.** Play, pause, skip, mute and volume cross between supported machines.
- Brightness and keyboard-backlight keys stay on the Mac.
+ While input is on a Windows laptop, the Mac's brightness keys change that laptop's built-in
+ screen; the keyboard-backlight keys stay on the Mac.
- **Keys and buttons that stay put.** Each machine keeps a list of keys and mouse buttons that keep
working where they were pressed while its input is on the other one: a mouse's back button for
this machine's browser, a volume key for its speakers. Add one by pressing it. The back and
@@ -122,7 +162,7 @@ About Beamer.
|---|---|---|
| Overview | Paired machines, where input is, the links and their round trips, Send input and Pause crossing, a switch per direction, Same on all machines, start at login, the update check | Paired machines, where input is, the links and their round trips, Send input and Pause crossing, a switch per direction, Same on all machines, start at sign-in, the update check |
| Permissions | Accessibility and Input Monitoring, with Relaunch Beamer | None; the firewall check is on Connection |
-| Crossing | A drawing of the arrangement, the ways in for each machine (edge, part of the edge, corner, notch), the full-screen hold, resistance, the shortcut and jump keys | A drawing of the arrangement, the ways in for each machine (edge, part of the edge, corner), the full-screen hold, resistance, the shortcut and jump keys |
+| Crossing | A map of the arrangement and a ledger of how each machine is reached (edge or its thirds, corner, notch) with its jump key, the full-screen hold, resistance, the shortcut | A map of the arrangement and a ledger of how each machine is reached (edge or its thirds, corner) with its jump key, the full-screen hold, resistance, the shortcut |
| Keyboard | Key mapping, what stays on this Mac, each peer's pointer and scroll speed | Key mapping, including a Mac layout, what stays on this PC, each peer's pointer and scroll speed |
| Design | Crossing and switch styles, colours, Size and Length, landing animation, Match design, notch and trackpad controls, window appearance (System, Light or Dark) | Crossing and switch styles, colours, Size and Length, landing animation, Match design, window appearance (System, Light or Dark) |
| Connection | Hide addresses, a peer's address, port and pairing details | Whether Windows Firewall lets a peer in, with a one-button fix; hide addresses; this PC's address, port and pairing details |
@@ -179,12 +219,11 @@ time you overshoot a close button. The default is 120 points; zero switches on c
| Way in | Where it triggers | Mac | Windows |
|---|---|---|---|
| Shortcut | Double-tap the trigger key, or hold it | Yes | Yes |
-| Edge | The whole of one outer edge | Yes | Yes |
-| Part of the edge | Only the thirds of that edge you pick (start, middle, end), measured on the display under the pointer | Yes | Yes |
+| Edge | The whole of one outer edge, or the thirds of it you pick in the ledger's Edge cell, measured on the display under the pointer | Yes | Yes |
| Corner | An 8pt box in one corner, needing a diagonal push | Yes | Yes |
| Notch | The top edge, only within the notch's width | Yes | No |
-Any combination can be on, except Edge and Part of the edge, which exclude each other. On the Mac,
+Edge, corner and notch can all be on at once; with all three thirds lit, the whole edge crosses. On the Mac,
Shortcut and the right-hand edge are on to start with. On Linux under Wayland, the shortcut only
brings input back; the desktop only lets it go to another machine at an edge.
@@ -247,7 +286,8 @@ trigger key cannot be added.
The Mac's F7–F12 media row and volume keys cross as play/pause, next, previous, mute and volume.
On the Mac they arrive as system events rather than key events and are captured separately
-(`mac_app/media_keys.py`). Brightness and keyboard-backlight keys stay with macOS.
+(`mac_app/media_keys.py`). The keyboard-backlight keys stay with macOS; the brightness keys reach a
+Windows laptop's built-in screen.
Ctrl+Alt+Del is the Secure Attention Sequence, trapped by the kernel before any app sees it.
`SendInput` cannot produce it, and `SendSAS()` needs a Windows service or a signed `uiAccess` app
@@ -361,13 +401,15 @@ password. Without it, the Mac reports `Windows is locked — unlock it at the PC
<details>
<summary><strong>Linux</strong></summary>
-Linux support is experimental. Install the x86_64 Flatpak from the release page with
-`flatpak install --user Beamer-<version>-x86_64.flatpak`, or build it with
-[the Flatpak instructions](docs/flatpak-build.md). On one Fedora 44 GNOME desktop under Wayland,
-paired with a Mac and with a Windows PC, the window and tray, pairing, crossing both ways, typing and the clipboard work;
-there, crossings show no edge animation on the Linux machine and the selected option in settings is
-not filled in. X11 on real hardware has not been tested. Flatpak needs Flathub to install the KDE runtime
-if it is not already present. The same package is built for GNOME under Wayland and for X11.
+Linux support has been tested on GNOME; KDE Plasma support is experimental. There is no AppImage. Install the 64-bit x86 Flatpak from the Kalkman
+Code repository using [Install on Linux](#install-on-linux), or build for arm64 with [the Flatpak
+instructions](docs/flatpak-build.md). On one Fedora 44 GNOME desktop under Wayland, paired with a
+Mac and a Windows PC, the window and tray, pairing, crossing both ways, typing and the clipboard
+work, and crossings show their effect through XWayland. X11 runs with Beamer's keyboard, pointer, pairing and clipboard features, but has not
+been tested on real hardware. Flatpak fetches the KDE runtime from Flathub if it is not already
+present. Beamer targets GNOME and KDE Plasma under Wayland and X11. KDE Plasma support is
+experimental and has not been tested on real hardware: KDE Wayland needs Plasma 6.1.1 or later
+with the matching host portal, and the clipboard needs Plasma 6.6 or later.
On Wayland, the desktop limits what Beamer can do:
@@ -376,10 +418,14 @@ On Wayland, the desktop limits what Beamer can do:
while input is away.”
- “On Wayland Beamer cannot see a full-screen app, or a mouse button held before the pointer reaches
an edge, so the edges are never held for one and a drag can cross.”
-- “On Wayland the desktop does not let Beamer draw at the edges of the screen, so crossings show no
- effect on this machine. The other machines still show theirs.”
+- Without XWayland, or if drawing through it fails, Beamer says: “On Wayland the desktop does not let
+ Beamer draw at the edges of the screen, so crossings show no effect on this machine. The other
+ machines still show theirs.”
-Linux does not offer gestures. KDE Plasma has not been tested.
+Older Ubuntu and Debian releases lack the InputCapture portal, so they cannot send input out under
+Wayland; use an X11 session there. Linux does not offer gestures. KDE Plasma awaits hardware
+testing. On KDE Wayland, partly exposed sides in staggered monitor layouts are unavailable;
+use a completely exposed monitor edge. The Flatpak's start-at-sign-in toggle remains unavailable.
</details>
@@ -406,7 +452,7 @@ shared token typed by hand, and they must match on both machines.
From `mac_app`:
```sh
-.venv/bin/python3 -m unittest discover -s tests -v
+.venv/bin/python3 -m unittest discover -s tests -t .. -v
./build_dmg.sh
```
diff --git a/VERSION b/VERSION
index 26ca594..4cda8f1 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-1.5.1
+1.5.2
diff --git a/WIRE.md b/WIRE.md
index 662378f..4468a42 100644
--- a/WIRE.md
+++ b/WIRE.md
@@ -97,6 +97,8 @@ Beside the machine's other settings, which keep the names 1.4.x gave them, it ho
| `shortcut` | whether the switch shortcut is one of this machine's ways across |
| `peers` | a list of peer entries, below, at most 32 |
| `zones` | this machine's zones, section 8 |
+| `layout` | this machine's remembered tiles, keyed by machine id; each tile has integer `x`, `y`, `w` and `h` canvas units |
+| `layout_set_at`, `layout_by` | the last shared tile picture's independent stamp |
| `migrated_token_sha256` | lower-case hex SHA-256 of the UTF-8 of the last 1.4.x `auth_token` migrated, or `""` |
A peer entry:
@@ -105,6 +107,7 @@ A peer entry:
|---|---|---|
| `id` | `b64` or `""` | the peer's machine id; `""` only for the entry migrated from 1.4.x |
| `name` | string | the peer's name, from pairing, then from every `hello` or `welcome` |
+| `label` | string, optional | this machine's local display name for the peer; trimmed, at most 64 code points; empty clears it |
| `platform` | string | the peer's platform, from pairing, then from every `hello` or `welcome` |
| `token` | string | the shared token from pairing, never reused for another peer |
| `host` | string | the IPv4 address to open a link to the peer at; `""` for a phone |
@@ -121,6 +124,11 @@ A peer entry:
| `from_1_4` | boolean | this entry was migrated from a 1.4.x pairing, and never links |
| `way_back` | boolean, optional | what the peer last said in `arrangement`'s `way_back` (section 8): whether one of its zones leads here; absent until it says |
| `way_back_by` | `b64`, optional | what the peer last said in `arrangement`'s `way_back_by` (section 8): the machine whose zone holds the side it has for this one; absent when it named none |
+| `shortcut_cycle` | boolean, local only | whether this machine is included when `shortcut_goes_to` is `ticked`; absent means ticked |
+| `left_out` | boolean, local | whether this peer is left out of this machine's layout; never sent |
+| `left_out_ways` | list of strings, local | the zone kinds to restore when this peer is put back; never sent |
+| `dormant` | boolean, optional, local | whether conclusive link evidence says this peer no longer has the pairing; absent means false; never sent |
+| `dormant_reason` | string, optional, local | `wrong_id` or `forgotten`, the evidence that set `dormant`; absent when `dormant` is false; never sent |
Rules:
@@ -473,6 +481,9 @@ Capabilities say what a machine does with a message it receives:
| `text` | it types `text` |
| `settings` | it receives Same on all machines (`settings`) |
| `design_sync` | with `settings`, it sends and receives direct Design states (`settings.data.design_sync`) and can be followed |
+| `layout` | with `settings`, it sends and receives the shared tile picture (`settings.data.layout`) |
+| `displays` | with `layout`, it sends and receives each machine's logical display rectangles and display-targeted edges |
+| `ping_rtt` | it sends and answers response-time probes on `ping` in both directions |
A sender does not send a message its peer's capabilities do not cover. A receiver that gets one
anyway drops it, and still acknowledges it when it carries a `seq`.
@@ -505,7 +516,7 @@ Initiator to responder:
| `type` | `data` | Carries `seq` |
|---|---|---|
| `hello` | section 2 | no |
-| `ping` | `{}` | no |
+| `ping` | `{}`, or `probe` or `echo` (one positive integer identifier, at most 2^31 - 1) | no |
| `focus` | section 5 | no |
| `keydown`, `keyup` | `key`, optional `us` (section 7) | yes |
| `mousemove` | `dx`, `dy` | yes |
@@ -572,11 +583,20 @@ Either way:
- **Liveness.** An initiator sends `ping` when it has sent nothing for a second; a responder's
`ack` heartbeat does the same the other way (section 9). A side that receives no byte at all for
2.5 seconds (a responder) or 2 seconds (an initiator) ends the link. Any byte counts, so a large
- clipboard frame arriving slowly keeps the link alive while it comes.
-- **`paired`** lists the ids of every peer the sender has, less the receiver's. A machine sends
- it only to peers it may send input to (`send` true), since those are the ones whose Crossing
- page needs it: after the handshake and again whenever its list changes. The receiver stores it
- in `paired_with` (section 5, the Crossing page).
+ clipboard frame arriving slowly keeps the link alive while it comes. An initiator also ends a
+ link when its oldest unacknowledged input is older than 1.5 seconds, even if heartbeat `ack`s
+ continue to arrive; phone ports must keep this input-acknowledgement rule in parity.
+- **Response time.** Only when both identities announce `ping_rtt`, each end sends a `ping` with a
+ fresh `probe` about once a second, including during input, and answers a `probe` with one `ping`
+ carrying its `echo`. A ping has at most one of these fields; an echo is never echoed. Empty pings
+ remain valid and compatible with older peers. The sender starts its local monotonic timer when
+ the writer begins sending the probe and accepts only the matching echo on that link. The most
+ recent round trip is available for three seconds; no peer clock is used. This measurement does
+ not change the input `ack` samples or watchdog.
+- **`paired`** lists the ids of every desktop peer the sender has in use and not dormant, less the
+ receiver's. A machine sends it only to peers it may send input to (`send` true), since those are
+ the ones whose Crossing page needs it: after the handshake and again whenever its list changes.
+ The receiver stores it in `paired_with` (section 5, the Crossing page).
- **Announcements.** After the handshake each end sends `paired` when the rule above allows,
`arrangement` when this pair has a side, and `settings` when the other's capabilities list
`settings`, except for a zero-port phone: phones never take part in shared settings or Match design.
@@ -670,6 +690,7 @@ and both stay at home, and the next try works.
| `route` | integer, 1 to 2^53 - 1 |
| `target` | `b64`: where input is going. The responder's own id means here; any other id means the responder is being let go |
| `edge`, `offset` | where to land the pointer: `left`, `right`, `top` or `bottom`, and how far along that edge of the responder, any number, which the receiver clamps to 0.0 to 1.0 (never malformed for its range) |
+| `display`, `side` | optional pair naming the responder's display key and the side to land on; an unknown display falls back to `edge` and `offset` |
| `resistance_px` | integer 0 to 1000: how far the owner's hand must push through a zone on the responder |
| `reach` | list of `b64`, at most 32, no repeats: the peers the owner can send input to now, less the owner and the responder |
| `stay` | `true`: re-arm in place; land nothing, play nothing |
@@ -687,6 +708,8 @@ A take without `resistance_px` uses 120, and a phone, which has no hand at an ed
out. A take or re-arm without `reach` has an empty one. A `reach` that names the owner or the
responder has those ignored. `edge` without `offset`, `offset` without `edge`, or `stay` with
anything but `true`, is malformed; on a re-arm `edge` and `offset` do not belong and are ignored.
+`display` and `side` must appear together; `display` is 1 to 64 ASCII letters, digits, `_`, `.`, `:`
+or `-`, and `side` is one of the four edge names. Older peers ignore both optional members.
`accept`, responder to the initiator whose taking `focus` it accepted: `route`.
@@ -711,6 +734,7 @@ unknown key (Encodings).
| `route` | the last `route` the responder accepted from this owner |
| `next` | `b64`: where input should go. The owner's own id means home |
| `edge`, `offset` | where to arrive on `next`, both or neither, as in `focus` (`offset` clamped, never malformed for its range) |
+| `display`, `side` | optional pair naming `next`'s display key and the side to arrive at; an unknown display falls back to `edge` and `offset` |
### The route
@@ -1078,8 +1102,9 @@ A key travels as `key`, a name, in `keydown` and `keyup`:
| Modifiers | `shift`, `shift_r`, `ctrl`, `ctrl_r`, `alt`, `alt_r`, `cmd`, `cmd_r`, `caps_lock` |
| Editing and movement | `backspace`, `tab`, `enter`, `esc`, `space`, `delete`, `insert`, `home`, `end`, `page_up`, `page_down`, `left`, `right`, `up`, `down` |
| Function | `f1` to `f24` |
- | Windows keys | `menu`, `print_screen`, `pause`, `num_lock`, `scroll_lock`, `browser_back`, `browser_forward` |
- | Media (`media_keys`) | `volume_mute`, `volume_down`, `volume_up`, `media_next`, `media_prev`, `media_stop`, `media_play_pause` |
+ | Windows keys | `menu`, `print_screen`, `pause`, `num_lock`, `scroll_lock`, `browser_back`, `browser_forward`, `browser_refresh`, `browser_stop`, `browser_search`, `browser_favourites`, `browser_home`, `mail`, `media_select`, `launch_app1`, `launch_app2` |
+ | Media (`media_keys`) | `volume_mute`, `volume_down`, `volume_up`, `media_next`, `media_prev`, `media_stop`, `media_play_pause`, `brightness_up`, `brightness_down`, `mic_mute` |
+ | System actions | `search`, `spotlight`, `dictation` |
The numpad's Enter is `enter`.
- **`keyup`** carries the same `key` and `us` as the `keydown` it releases, even if Shift changed
@@ -1175,7 +1200,14 @@ only for the entry migrated from 1.4.x, which never links. A zone never names a
in use, unless another zone in use covers that stretch, when it stays `off` like any other clash.
Only a machine whose link reports that it no longer has this pairing (section 2, initiator step
3) keeps its zones `off` for good, and the app says so in its window, not only in its log. Any
- edit of the zone by the user clears `aside`. A zone's stretch is its peer's `side` for an `edge` zone, the
+ edit of the zone by the user clears `aside`. An edge, part or corner zone that the Crossing page turns off
+ also carries `"page_off": true`, scoped or unscoped; layout compilation keeps the contact off until the
+ page turns that way back on, including when display metadata is absent. The mark leaves with a contact
+ the tile has left. Thirds picked on the page are kept as `"page_parts"` on the peer's unscoped
+ `part` zone, and each contact layout compilation writes keeps the thirds it touches as
+ `"contact_parts"`; a contact crosses only by the picked thirds it touches, all three being the whole
+ edge. Both are local marks: no new message, capability or protocol version.
+ A zone's stretch is its peer's `side` for an `edge` zone, the
chosen thirds of it for a `part` zone, and the corner for a `corner` zone; the `notch` is a
stretch of its own, which only another `notch` zone covers: it fires on a dwell and 1.4.x let
it stand beside the edge, but a Mac has one notch, so it leads to one machine. 1.4.x let the
@@ -1283,9 +1315,13 @@ every peer.
{"type": "settings", "data": {
"on": true, "set_at": 1790000000, "by": "<b64>",
"crossing": {"resistance_px": 120, "block_while_dragging": true, "shortcut": true,
- "trigger_key": "alt_r", "trigger_style": "double_tap", "double_tap_ms": 300},
+ "trigger_key": "alt_r", "shortcut_goes_to": "last", "trigger_style": "double_tap", "double_tap_ms": 300},
"design": {"glow_style": "glow", "glow_colour": "colourful", "effect_length": "normal",
- "shortcut_arrival": true, "shortcut_arrival_style": "match"}}}
+ "effect_size": "medium", "effect_pace": 1.0, "effect_size_fraction": 0.045,
+ "shortcut_arrival": true, "shortcut_arrival_style": "match"},
+ "groups": ["crossing", "design", "shortcut", "names"],
+ "stamps": {"trigger_style": [1789990000, "<b64>"], "glow_colour": [1790000000, "<b64>"]},
+ "names": {"<id>": {"label": "Studio", "set_at": 1790000000, "by": "<b64>"}}}}
```
- `on` is a boolean, `set_at` an integer of unix seconds, `by` the `b64` id of the machine that
@@ -1296,11 +1332,32 @@ every peer.
so a malformed outer field drops the optional Design state with the rest of the message.
`crossing` and `design` are objects, present only when `on` is
true; one that is absent or is not an object brings no values, and the message stands.
+- `groups` is an optional array of `"crossing"`, `"design"`, `"shortcut"` and `"names"`.
+ Its order is Crossing, Design, Shortcut, Names. A local group-picker change sets `on` true
+ exactly when at least one group is selected. A legacy 1.5.0–1.5.1 state may change `on` while
+ preserving this machine's group selection; that on/off state is forwarded unchanged. Crossing carries resistance and drag protection; Design carries
+ design values; Shortcut carries the switch, trigger and destination; Names carries `names`.
+ Values for unselected groups are ignored. Without `groups`, a 1.5.0–1.5.1 state keeps its old
+ on/off behaviour and applies values only to groups selected locally. It never changes a local
+ group selection; with none selected, its `on` true selects every group, as turning it on locally
+ does. Older peers ignore `groups` and continue applying their known Crossing and
+ Design keys. `layout` is independent of groups and always travels to peers advertising `layout`.
+- `names` is an optional object, present only when `on` is true and Names is selected when `groups`
+ is present. Each key is a machine id and each
+ value is `{label, set_at, by}`: `label` is a trimmed string of at most 64 code points, including
+ the empty string; `set_at` is an integer of unix seconds and `by` is the `b64` id of the machine
+ that changed it. An invalid entry is ignored without dropping other names or settings. Each id's
+ entry is accepted independently when its stamp is newer than the one held for that id: a higher
+ `set_at`, or the same `set_at` and the larger `by` as bytes. The clock bounds above apply to each
+ entry. A receiver writes a name for its own id to its local `name`; another known id updates that
+ peer's optional `label`. Unknown ids are ignored. With `on` false, `names` is ignored. Older peers
+ ignore this optional member.
- **Each value stands alone.** Unlike every other message, a value in `crossing` or `design`
outside the table below, or one this receiver cannot hold (an effect it does not have), is
left out and the rest still applied, and the message is not malformed for it; an unknown key
- is ignored. Whether a message is newer, and whether it is sent on, is decided by `set_at` and
- `by` alone: one with values left out still wins, takes its stamp, and is sent on as it came.
+ is ignored. Whether a message's state is newer is decided by `set_at` and `by` alone, and each
+ value's by its own stamp: one with values left out still wins, takes its stamps, and is sent on
+ as it came.
- The values:
| Key | Allowed |
@@ -1308,26 +1365,69 @@ every peer.
| `resistance_px` | integer 0 to 500 |
| `block_while_dragging`, `shortcut`, `shortcut_arrival` | boolean |
| `trigger_key` | a key name from section 7 that is not a character, a media key, `browser_back`, `browser_forward`, `backspace`, `tab`, `enter`, `esc`, `space` or `print_screen` |
+ | `shortcut_goes_to` | `"last"`, `"next"` or `"ticked"`; absent means `"last"` |
| `trigger_style` | `"double_tap"` or `"hold"` |
| `double_tap_ms` | integer 50 to 2000 |
| `glow_style` | `"glow"`, `"beam"`, or an effect id from `effects.py` |
| `glow_colour` | `"signal"`, `"colourful"`, `"ocean"`, `"sunset"`, `"mono"`, or a colour pack id from `effects.py` |
| `effect_length` | `"short"`, `"normal"` or `"long"` |
+ | `effect_size` | `"small"`, `"medium"` or `"large"` |
+ | `effect_pace` | number 0.25 to 2.5; when valid it takes precedence over `effect_length` |
+ | `effect_size_fraction` | number 0.02 to 0.08; when valid it takes precedence over `effect_size` |
| `shortcut_arrival_style` | `"match"`, `"locator"`, or an effect id from `effects.py` |
-- Shared: the crossing's feel (resistance, the drag guard, the shortcut and its key) and the
+ The optional numeric fields are also sent in `design_sync.values`. If absent or invalid, a new
+ peer converts the legacy preset to its corresponding slider stop: Short 0.5, Normal 1.0, Long
+ 2.0; Small 0.03, Medium 0.045, Large 0.06. The legacy preset fields always contain the nearest
+ preset for the numeric value, so 1.5.0–1.5.2 peers ignore the new keys and keep a usable setting.
+
+- Shared: the crossing's feel (resistance, the drag guard, the shortcut, its key and where it goes) and the
Design page. Never shared: zones, `side`, the direction switches, the Mac's notch look and
haptics, and appearance. Version 5's `methods`, `edge_parts` and `corner` are zones now and
leave the message, and with them goes 1.5.0's mirroring of the corner.
+- `shortcut_goes_to` is optional. Beamer 1.5.0 to 1.5.2 ignore it and keep Last machine.
- **Newer wins**: a higher `set_at`, or the same `set_at` and the larger `by` as bytes. This
replaces the Mac winning a tie, since there may be no Mac. A `set_at` more than a day ahead of
- the receiver's clock, or above 2^53 - 2, is ignored.
+ the receiver's clock, or above 2^53 - 2, is ignored. The outer stamp decides `on` and `groups`.
+- **Each value has its own stamp** (1.5.2). `stamps` is an optional object, present only when
+ `on` is true, with one `[set_at, by]` per value sent, stamped when a person changed that value
+ on that machine, whether Same was on or off. A receiver takes a value only when its stamp is
+ newer than the one it holds for that key, by the rule above, and keeps that stamp with it. So
+ an edit carries only what was changed, and a value the sender missed or never set cannot
+ overwrite a real choice elsewhere. Before 1.5.2 the whole state travelled under the outer stamp:
+ rc14 (10-10-2026) showed one machine's edit rewriting seven of another's values. A value held
+ without a stamp of its own counts as stamped with the state it came in. That is every value of
+ a peer that sends no `stamps`, so a 1.5.0 or 1.5.1 peer behaves as it did against its own kind.
+ A fresh machine's values hold `[0, ""]`, so it adopts the group's and never sends its defaults
+ over anyone's. A stamp for a key not sent is ignored; one may be later than the outer `set_at`, since a value
+ changed while its group was off is stamped then, and is bounded by the same day-ahead rule. The
+ receiver seeds its own unstamped values once, from its outer stamp, and stores them; later
+ changes to the outer stamp (on, off, the groups) never restamp a value.
+- **Answering.** A receiver that holds a newer value than one in the message sends its own state
+ to its peers, or the sender, having taken nothing from its own message, would never learn it.
+ A receiver that holds no newer value sends nothing back, so the exchange stops. A peer from
+ before 1.5.2 takes only a whole state newer than its own, so it ignores an answer whose outer
+ stamp equals the state it just sent; it learns the newer value at the next change made on a
+ 1.5.2 machine with Same on. A value kept back over a trigger clash is not taken, so a message
+ carrying only that is not sent on.
- **From and to whom.** A machine takes `settings` only from a peer whose capabilities list
`settings`, and sends its state to every such peer after each handshake and on every change. One
- that takes a newer state sends it on, unchanged, to every other such peer it has a link to. An
- older or equal one is not sent on, so it stops. Turning it off travels the same way.
+ that takes a newer state, or any newer value, sends the message on, unchanged, to every other
+ such peer it has a link to. One that takes nothing does not send it on, so it stops. Turning it
+ off travels the same way.
- A change made here is stamped with the current time, and never lower than the stamp held plus
one, so a change on a machine whose clock is behind still wins.
+- Each settings file keeps its group selection and one local `same_before_sync` snapshot. Before
+ an accepted incoming update changes local shared values or the selection, save the previous
+ selection and affected values. The snapshot expires after 30 days, is replaced by the next
+ accepted change, and is never sent. Name entries follow the accepted group policy even when an
+ older outer stamp carries newer per-entry names. Updates that change only stamps do not replace
+ the snapshot. Revert restores saved values, clears the snapshot, stamps the restoration as a new
+ local change and announces it under the current group selection, keeping sync on. A
+ selection-only update records `selection_only` in the local snapshot: Revert restores the
+ previous selection while keeping the current values. Restored names and direct Design
+ advertisements receive fresh stamps too. Group selection and snapshots are never key-mapping
+ policy; each system keeps its own mapping.
**Follow a machine's design.** Each machine's Design page has **Match design with**: None, or one
paired machine advertising both `settings` and `design_sync`. The selection is local; there is no
@@ -1344,13 +1444,15 @@ even while Same on all machines is off. The state is:
{"type":"settings","data":{"on":false,"set_at":1790000000,"by":"<b64>",
"design_sync":{"set_at":1790000001,"by":"<b64>","values":{
"glow_style":"glow","glow_colour":"colourful","effect_length":"normal",
- "effect_size":"medium","shortcut_arrival":true,"shortcut_arrival_style":"match"}}}}
+ "effect_size":"medium","effect_pace":1.0,"effect_size_fraction":0.045,
+ "shortcut_arrival":true,"shortcut_arrival_style":"match"}}}}
```
`design_sync` is a complete independently stamped Design state. Its `set_at` and `by` use the
newer-wins ordering and clock bounds above. Values are validated individually; unsupported keys or
values are ignored. Missing `effect_size` means `"medium"`; its wire type is string and allowed
-values are `"small"`, `"medium"` and `"large"`. Same on all machines has precedence: the follow
+values are `"small"`, `"medium"` and `"large"`. `effect_pace` and `effect_size_fraction` are
+optional numbers with the bounds and preset fallback described above. Same on all machines has precedence: the follow
selection stays set but does not apply while Same is on. A newer state from the selected machine
applies to this machine's Design only when its stamp is newer than this machine's own Design stamp.
The follower keeps the leader's `set_at` and `by`, so an announcement carries the same stamp through
@@ -1367,6 +1469,38 @@ or unpairing the selected machine resets the selection to None. An offline follo
the last look in place; the next link-up sends its current state and catches the follower up.
Older peers ignore the optional field. A peer that does not send it cannot be followed.
+**Shared tile picture.** The optional `layout` member is independent of `on` and carries the
+complete machine-id-to-tile map. Its `set_at` and `by` use the newer-wins ordering and clock bounds
+above; a receiver keeps the newest valid state, compiles its own zones from the picture, and sends
+the state on unchanged to other linked peers advertising both `settings` and `layout`. Zones and
+sides remain local, and `arrangement` continues to settle sides with peers that do not advertise
+`layout`.
+
+```json
+{"type":"settings","data":{"on":false,"set_at":1790000000,"by":"<b64>",
+ "layout":{"set_at":1790000001,"by":"<b64>","tiles":{
+ "<machine id>":{"x":0,"y":0,"w":160,"h":100,
+ "displays":{"0":{"x":-1280,"y":0,"w":1280,"h":800},
+ "1":{"x":0,"y":0,"w":1920,"h":1080}}}}}}}
+```
+
+`tiles` has at most 33 entries, keyed by machine id. Each tile has integer `x`, `y`, `w` and `h`
+canvas units, with positive `w` and `h`. A tile may also carry `name`, the machine's advertised
+name (up to 64 characters). A map may show this machine, any desktop peer it holds, and a third-party
+machine only when an in-use, non-dormant, not-left-out desktop peer lists that id in `paired_with`
+and the third-party tile has a valid name. A phone, dormant, left-out or not-in-use peer cannot
+admit a third-party tile. Unnamed third-party tiles and ids outside these rules are dropped.
+A tile may also carry `displays`, a map of 1 to 16 display
+keys to `{x, y, w, h}` logical rectangles in that machine's own display arrangement; `x` and `y`
+may be negative, and widths and heights are positive. The display rectangles are fitted into the
+machine's canvas tile while preserving their arrangement. A tile may also carry `display_offsets`, a
+map from display key to integer `{x, y}` translations in canvas units. A present offset marks that
+display as split from its group; the reported logical rectangle remains unchanged. Omitted offsets
+keep the display grouped, and dragging the machine moves the group together. A receiver ignores
+malformed `layout` as a whole. Peers without `displays` receive the same machine tiles without the
+nested display map or its offsets.
+Beamer 1.5.0 to 1.5.2 ignore this unknown optional member and keep their existing Crossing page.
+
## Versions
- **Wire version 6** is in Beamer 1.5.0 and later. It refuses versions 5 and below, and they refuse
@@ -1405,6 +1539,10 @@ one against the code and against the primitives written out by hand.
- New messages: `accept`, `accepts`, `refuse`, `paired`, `text`.
- `settings` gains the optional `design_sync` member for per-machine Design matches; older betas
ignore it, while 1.5 keeps it separate from the existing `on` switch.
+- `settings` gains the optional independently stamped `layout` member for the shared tile picture;
+ peers without the `layout` capability do not receive it.
+- `focus` and `switch` may carry the optional `display` and `side` pair for landing on a named
+ display edge; peers without the `displays` capability receive neither field.
## Changes from the first design
diff --git a/assets/linux-crossing.png b/assets/linux-crossing.png
new file mode 100644
index 0000000..f867247
Binary files /dev/null and b/assets/linux-crossing.png differ
diff --git a/assets/linux-design.png b/assets/linux-design.png
new file mode 100644
index 0000000..aca1324
Binary files /dev/null and b/assets/linux-design.png differ
diff --git a/assets/linux-overview.png b/assets/linux-overview.png
new file mode 100644
index 0000000..1c76b28
Binary files /dev/null and b/assets/linux-overview.png differ
diff --git a/assets/mac-crossing-dark.png b/assets/mac-crossing-dark.png
index afc1b16..86a60ea 100644
Binary files a/assets/mac-crossing-dark.png and b/assets/mac-crossing-dark.png differ
diff --git a/assets/mac-crossing-light.png b/assets/mac-crossing-light.png
index 7976f78..2789906 100644
Binary files a/assets/mac-crossing-light.png and b/assets/mac-crossing-light.png differ
diff --git a/assets/mac-design-dark.png b/assets/mac-design-dark.png
index b799add..c72246f 100644
Binary files a/assets/mac-design-dark.png and b/assets/mac-design-dark.png differ
diff --git a/assets/mac-design-light.png b/assets/mac-design-light.png
index 79800a7..d1e9088 100644
Binary files a/assets/mac-design-light.png and b/assets/mac-design-light.png differ
diff --git a/assets/mac-overview-dark.png b/assets/mac-overview-dark.png
index 95e2397..01e639f 100644
Binary files a/assets/mac-overview-dark.png and b/assets/mac-overview-dark.png differ
diff --git a/assets/mac-overview-light.png b/assets/mac-overview-light.png
index 13a73f3..4eec6c2 100644
Binary files a/assets/mac-overview-light.png and b/assets/mac-overview-light.png differ
diff --git a/assets/social-preview.png b/assets/social-preview.png
index 1048d75..306e443 100644
Binary files a/assets/social-preview.png and b/assets/social-preview.png differ
diff --git a/assets/windows-crossing-dark.png b/assets/windows-crossing-dark.png
index bf94a8e..9deead5 100644
Binary files a/assets/windows-crossing-dark.png and b/assets/windows-crossing-dark.png differ
diff --git a/assets/windows-crossing-light.png b/assets/windows-crossing-light.png
index 29ae858..3ce5728 100644
Binary files a/assets/windows-crossing-light.png and b/assets/windows-crossing-light.png differ
diff --git a/assets/windows-design-dark.png b/assets/windows-design-dark.png
index eaadd96..5f9f1a6 100644
Binary files a/assets/windows-design-dark.png and b/assets/windows-design-dark.png differ
diff --git a/assets/windows-design-light.png b/assets/windows-design-light.png
index 996cd3e..ca1a7fa 100644
Binary files a/assets/windows-design-light.png and b/assets/windows-design-light.png differ
diff --git a/assets/windows-overview-dark.png b/assets/windows-overview-dark.png
index 609ce39..88ad0b4 100644
Binary files a/assets/windows-overview-dark.png and b/assets/windows-overview-dark.png differ
diff --git a/assets/windows-overview-light.png b/assets/windows-overview-light.png
index ad7de00..0dee126 100644
Binary files a/assets/windows-overview-light.png and b/assets/windows-overview-light.png differ
diff --git a/core/capture_types.py b/core/capture_types.py
new file mode 100644
index 0000000..23fcd72
--- /dev/null
+++ b/core/capture_types.py
@@ -0,0 +1,11 @@
+"""Key results shared by capture backends and their consumers."""
+
+
+class DeadKey:
+ def __init__(self, character: str) -> None:
+ self.character = character
+
+
+class TextInput:
+ def __init__(self, text: str) -> None:
+ self.text = text
diff --git a/core/crossing_state.py b/core/crossing_state.py
new file mode 100644
index 0000000..b9316dd
--- /dev/null
+++ b/core/crossing_state.py
@@ -0,0 +1,302 @@
+"""Pure crossing events shared by both desktop apps and their headless shells.
+
+The picture owns positions, each peer owns local intent, and zones are compiled output.
+Callers save the Outcome and carry out its messages before re-arming their responder.
+"""
+
+import copy
+import math
+import time
+from typing import TypedDict
+
+from core import protocol, return_edge, settings_sync, ways
+
+
+class Outcome(TypedDict):
+ settings: dict
+ changed: bool
+ accepted: bool
+ snap: dict
+ tiles: dict
+ tell: list
+ send_picture: bool
+ forward_picture: bool
+
+
+def _outcome(before, saved=None, result=None, *, accepted=True, tell=(),
+ send_picture=False, forward_picture=False):
+ saved = copy.deepcopy(before if saved is None else saved)
+ return Outcome(settings=saved, changed=saved != before, accepted=accepted,
+ snap=copy.deepcopy((result or {}).get("snap", {})),
+ tiles=copy.deepcopy((result or {}).get("tiles", {})),
+ tell=list(dict.fromkeys(tell)), send_picture=send_picture,
+ forward_picture=forward_picture)
+
+
+def _initial(settings, capable=(), fill=True):
+ saved = copy.deepcopy(settings)
+ for entry in saved.get("peers", []):
+ if ways._zoned(entry):
+ entry["ways"] = ways._read_intent(settings, entry["id"])
+ entry.pop("left_out_ways", None)
+ if not saved.get("layout"):
+ saved["layout"] = ways.derive_layout(saved, gap=0)
+ elif fill:
+ # A peer paired after the layout existed gets its tile here, or compile clears its side for
+ # want of a contact and every render invents a new place for it (rc13, the AC laptop). Not
+ # stamped: a machine back from offline must not outrank the picture the others moved since.
+ # Only a machine whose side is known: an unplaced one is never given a side it did not choose.
+ # Only a picture machine: an old peer keeps its side without a tile, and a tile would make the
+ # Mac count it as one until its link says otherwise, so every link-up re-armed the zones.
+ picture = ways.picture_capable(saved, capable)
+ derived = ways.derive_layout(saved, gap=0)
+ for entry in saved.get("peers", []):
+ if (ways._zoned(entry) and entry["id"] in picture and entry.get("side") in ways.EDGES
+ and entry["id"] not in saved["layout"] and entry["id"] in derived):
+ saved["layout"][entry["id"]] = derived[entry["id"]]
+ return saved
+
+
+def _compile(saved, platform, *, capable=(), live=None, gone=None, now=None):
+ return ways.compile_layout(saved, saved["layout"], platform=platform, capable=capable,
+ live=live, gone=gone, now=now)
+
+
+def _tells(before, saved, *, sides=False):
+ old = ways.way_back_state(before)
+ told = [peer for peer, value in ways.way_back_state(saved).items() if old.get(peer) != value]
+ if sides:
+ held = {p.get("id"): p.get("side", "") for p in before.get("peers", [])}
+ told += [p["id"] for p in saved.get("peers", [])
+ if ways._zoned(p) and held.get(p["id"], "") != p.get("side", "")]
+ return list(dict.fromkeys(told))
+
+
+def _stamp(saved, now):
+ saved["layout_set_at"] = settings_sync.next_stamp(saved.get("layout_set_at"), now)
+ saved["layout_by"] = saved.get("machine_id", "")
+
+
+def _shelf(settings, gone=None):
+ return {p.get("id") for p in settings.get("peers", [])
+ if p.get("left_out") is True or p.get("in_use", True) is False
+ or ways.peerlist.dormant_reason(p) is not None or gone is not None and gone(p.get("id"))}
+
+
+def drop(settings, tiles, moved, *, platform, capable, live, gone, now, snap_radius):
+ """Validate and snap a map drop, keeping shelved tiles aside."""
+ saved = _initial(settings, capable)
+ shelf = _shelf(saved, gone)
+ if moved in shelf or not isinstance(tiles, dict):
+ return _outcome(settings, accepted=False)
+ held = saved["layout"]
+ active = copy.deepcopy({peer: tile for peer, tile in tiles.items() if peer not in shelf})
+ result = ways.compile_layout(saved, active, moved=moved, platform=platform,
+ capable=capable, live=live, gone=gone, now=now)
+ if not result["accepted"]:
+ snap = result.get("snap", {}).get(moved)
+ if snap is None or snap == active.get(moved):
+ return _outcome(settings, result=result, accepted=False)
+ active[moved] = {**active[moved], **snap}
+ result = ways.compile_layout(saved, active, moved=moved, platform=platform,
+ capable=capable, live=live, gone=gone, now=now)
+ if not result["accepted"]:
+ return _outcome(settings, result=result, accepted=False)
+ if moved in active and moved != saved.get("machine_id"):
+ original = active[moved]
+ others = {peer: tile for peer, tile in active.items() if peer != moved}
+ snap = ways.snap_position(original, saved["machine_id"], others, radius=snap_radius)
+ if ways.within_snap_radius(original, snap, saved["machine_id"], others, snap_radius):
+ candidate = {**active, moved: {**original, **snap}}
+ retry = ways.compile_layout(saved, candidate, moved=moved, platform=platform,
+ capable=capable, live=live, gone=gone, now=now)
+ if retry["accepted"]:
+ active, result = candidate, retry
+ saved["layout"] = {**{peer: copy.deepcopy(tile) for peer, tile in held.items() if peer in shelf},
+ **active}
+ _stamp(saved, now)
+ entry = ways._entry(saved, moved)
+ own = saved["layout"].get(saved.get("machine_id"))
+ if entry is not None and moved not in capable and own is not None and moved in saved["layout"]:
+ # An old peer (no `layout`) crosses by its side, not the picture: a drop is how the map sets it,
+ # and the side check below sends it the arrangement.
+ contact = ways._rect_contact(own, saved["layout"][moved])
+ if contact and contact[0] in ways.EDGES and contact[0] != entry.get("side"):
+ entry.update(side=contact[0], side_set_at=settings_sync.next_stamp(entry.get("side_set_at"), now),
+ side_by=saved.get("machine_id", ""))
+ result = _compile(saved, platform, capable=capable, live=live, gone=gone, now=now)
+ saved = result["settings"]
+ return _outcome(settings, saved, result, tell=_tells(settings, saved, sides=True), send_picture=True)
+
+
+def edit_ways(settings, peer, *, platform, edge=None, thirds=None, corner=None,
+ corner_at=None, notch=None, live, gone, now, capable=()):
+ """Update only specified choices; an empty third selection keeps the last choice."""
+ saved = _initial(settings, capable)
+ entry = ways._entry(saved, peer)
+ if entry is None:
+ raise KeyError(peer)
+ if not ways._zoned(entry):
+ raise ValueError("a phone cannot have ways")
+ intent = entry["ways"]
+ for key, value in (("edge", edge), ("corner", corner), ("notch", notch)):
+ if value is not None and (key != "notch" or platform == "mac"):
+ intent[key] = bool(value)
+ if thirds is not None:
+ picked = [part for part in ways.PARTS if part in thirds]
+ if picked:
+ intent["thirds"] = picked
+ if corner_at in ways.CORNERS:
+ intent["corner_at"] = corner_at
+ result = _compile(saved, platform, capable=capable, live=live, gone=gone, now=now)
+ saved = result["settings"]
+ return _outcome(settings, saved, result, tell=_tells(settings, saved))
+
+
+def receive_picture(settings, state, *, source, platform, capable, live, gone, own_displays, now):
+ """Take newer positions, retaining omitted displays and correcting only this owner's geometry."""
+ if not settings_sync.layout_arrived(state, settings.get("layout_set_at"), settings.get("layout_by", "")):
+ return _outcome(settings)
+ # A missing tile is placed against the arriving picture (retain_held_peer_tiles), not this one.
+ saved = _initial(settings, fill=False)
+ layout = ways.retain_held_peer_tiles(saved, state["tiles"], saved["layout"])
+ for peer, tile in layout.items():
+ held = saved["layout"].get(peer, {})
+ if "displays" in held and "displays" not in tile:
+ tile["displays"] = copy.deepcopy(held["displays"])
+ if "display_offsets" in tile:
+ tile["display_offsets"] = {key: offset for key, offset in tile["display_offsets"].items()
+ if key in tile["displays"]}
+ own = saved.get("machine_id")
+ saved.update(layout=layout, layout_set_at=state["set_at"], layout_by=state["by"])
+ corrected = ways.refresh_displays(saved, own_displays, now=now)
+ if (own_displays and not corrected
+ and state["tiles"].get(own, {}).get("displays") != saved["layout"][own].get("displays")):
+ _stamp(saved, now)
+ corrected = True
+ result = _compile(saved, platform, capable=capable, live=live, gone=gone, now=now)
+ if not result["accepted"]:
+ return _outcome(settings)
+ saved = result["settings"]
+ return _outcome(settings, saved, result, tell=_tells(settings, saved),
+ send_picture=corrected, forward_picture=True)
+
+
+def receive_arrangement(settings, peer, read, *, platform, capable, live, gone, now):
+ """Picture peers supply return-way status only; old peers settle a side by its stamp."""
+ saved = copy.deepcopy(settings)
+ entry = ways._entry(saved, peer)
+ author = read.get("by")
+ edge = read.get("edge")
+ stamp = read.get("set_at")
+ if (entry is None or not ways._zoned(entry) or edge not in ways.EDGES
+ or not isinstance(author, bytes) or len(author) != 16 or not any(author)
+ or type(stamp) is not int or not 0 <= stamp <= settings_sync.MAX_STAMP
+ or stamp > now + settings_sync.DAY):
+ return _outcome(settings)
+ back = read.get("way_back")
+ if isinstance(back, bool):
+ entry["way_back"] = back
+ holder = read.get("way_back_by")
+ if (back is False and isinstance(holder, bytes) and len(holder) == 16 and any(holder)
+ and holder != protocol.read_id(settings.get("machine_id"))):
+ entry["way_back_by"] = protocol.id_text(holder)
+ else:
+ entry.pop("way_back_by", None)
+ if peer in capable:
+ return _outcome(settings, saved)
+ held = (int(entry.get("side_set_at") or 0), protocol.read_id(entry.get("side_by")) or b"")
+ newer = (stamp, author) > held
+ if newer:
+ entry.update(side=return_edge.OPPOSITE[edge], side_set_at=stamp, side_by=protocol.id_text(author))
+ saved = _initial(saved, capable)
+ saved["layout"].setdefault(peer, dict(x=0, y=0, w=160, h=100))
+ own_id = saved["machine_id"]
+ placed = ways.place_beside(saved["layout"], own_id, peer, entry["side"])
+ contact = ways._rect_contact(saved["layout"][own_id], placed)
+ # A side another machine already holds is shared, as derive_layout shares it, not cornered.
+ shared = {} if contact and contact[0] == entry["side"] else ways.share_side(
+ saved["layout"], own_id, peer, entry["side"], _shelf(saved, gone))
+ saved["layout"].update(shared or {peer: placed})
+ if saved["layout"] != settings.get("layout"):
+ _stamp(saved, now)
+ result = _compile(saved, platform, capable=capable, live=live, gone=gone, now=now)
+ saved = result["settings"]
+ else:
+ result = None
+ changed = saved != settings
+ return _outcome(settings, saved, result, tell=[*_tells(settings, saved), peer] if changed else [],
+ send_picture=newer and saved.get("layout") != settings.get("layout"))
+
+
+def link_up(settings, peer, *, platform, own_displays, now, capable=()):
+ saved = _initial(settings, capable)
+ ways.refresh_displays(saved, own_displays, now=now)
+ result = _compile(saved, platform, capable=capable, now=now)
+ saved = result["settings"]
+ entry = ways._entry(saved, peer) or {}
+ return _outcome(settings, saved, result, tell=[peer] if entry.get("side") in ways.EDGES else [],
+ send_picture=True)
+
+
+def leave_out(settings, peer, *, platform, live=None, gone=None, now=None, capable=()):
+ saved = _initial(settings, capable)
+ entry = ways._entry(saved, peer)
+ if entry is None:
+ raise KeyError(peer)
+ entry["left_out"] = True
+ result = _compile(saved, platform, capable=capable, live=live, gone=gone, now=now)
+ saved = result["settings"]
+ return _outcome(settings, saved, result, tell=_tells(settings, saved))
+
+
+def put_back(settings, peer, *, platform, live=None, gone=None, now=None, capable=()):
+ saved = _initial(settings, capable)
+ entry = ways._entry(saved, peer)
+ if entry is None:
+ raise KeyError(peer)
+ entry.pop("left_out", None)
+ # Its kept tile may sit where an active machine was placed while it was shelved: it moves, not them.
+ tile, own = saved["layout"].get(peer), saved.get("machine_id")
+ shelf = _shelf(saved, gone)
+ others = {key: value for key, value in saved["layout"].items() if key != peer and key not in shelf}
+ moved = False
+ if (isinstance(tile, dict) and peer not in shelf and own in others
+ and any(ways._overlaps(tile, other) for other in others.values())):
+ side = entry.get("side") if entry.get("side") in ways.EDGES else ""
+ shared = ways.share_side(saved["layout"], own, peer, side, shelf) if side else {}
+ saved["layout"].update(shared or {peer: {**tile, **ways.snap_position(tile, own, others, radius=math.inf)}})
+ moved = saved["layout"] != settings.get("layout")
+ if moved:
+ # Sent, or the next picture from another machine puts it back on top of the active one.
+ _stamp(saved, time.time() if now is None else now)
+ result = _compile(saved, platform, capable=capable, live=live, gone=gone, now=now)
+ saved = result["settings"]
+ return _outcome(settings, saved, result, tell=_tells(settings, saved), send_picture=moved)
+
+
+def displays_changed(settings, *, platform, own_displays, now, capable=()):
+ saved = _initial(settings, capable)
+ changed = ways.refresh_displays(saved, own_displays, now=now)
+ result = _compile(saved, platform, capable=capable, now=now)
+ saved = result["settings"]
+ return _outcome(settings, saved, result, tell=_tells(settings, saved), send_picture=changed)
+
+
+def paired(settings, *, platform, own_displays, now, capable=()):
+ saved = _initial(settings, capable)
+ desktops = [p for p in saved.get("peers", []) if ways._zoned(p)]
+ if platform == "mac" and len(desktops) == 1 and not settings.get("layout"):
+ peer = desktops[0]["id"]
+ saved["layout"][peer] = ways.place_beside(saved["layout"], saved["machine_id"], peer, "right")
+ ways.refresh_displays(saved, own_displays, now=now)
+ result = _compile(saved, platform, capable=capable, now=now)
+ saved = result["settings"]
+ return _outcome(settings, saved, result, tell=_tells(settings, saved, sides=True), send_picture=True)
+
+
+def migrate(settings, platform, *, capable=()):
+ """Read legacy zone choices once, then discard their historical marks by compiling."""
+ saved = _initial(settings, capable)
+ result = _compile(saved, platform, capable=capable)
+ return _outcome(settings, result["settings"], result)
diff --git a/core/effects.py b/core/effects.py
index 2f6ea8a..488dc58 100644
--- a/core/effects.py
+++ b/core/effects.py
@@ -95,6 +95,8 @@ def legible(palette, dark, fx=None):
lighter than LIGHT_CEILING brought down to it, as Mono, Pearl and Contrast all but vanished."""
if not dark and tuple(palette) in NEW_LIGHT_PACKS:
return list(NEW_LIGHT_PACKS[tuple(palette)])
+ if dark and tuple(palette) in NEW_DARK_PACKS:
+ return list(NEW_DARK_PACKS[tuple(palette)])
if dark:
low, high = DARK_FLOOR, 1.0
elif getattr(fx, "id", None) in LIGHT_AS_GIVEN:
@@ -360,14 +362,14 @@ def point(x, y):
def state(screen_w, screen_h, os_name, method, palette, *, reduced=False, dark=True, notch=None,
- effect_size="medium", **fields):
+ effect_size="medium", effect_size_fraction=None, **fields):
"""The `s` an effect reads, with the harness's field names. Departure passes region, point,
along (the fraction along the edge), pressure, tick (the last quarter tick, or None) and since
(seconds since breakthrough); arrival passes point, edge and since (seconds since landing)."""
s = SimpleNamespace(
screen=SimpleNamespace(w=float(screen_w), h=float(screen_h), os=os_name),
method=method, palette=list(palette), reduced=bool(reduced), scale=1.0, dark=bool(dark),
- effect_size=effect_size, hash=hash_n, memo={},
+ effect_size=effect_size, effect_size_fraction=effect_size_fraction, hash=hash_n, memo={},
)
if notch is not None:
s.notch = SimpleNamespace(**notch)
@@ -473,6 +475,13 @@ NEW_LIGHT_PACKS = {
tuple(BRIGHT_PACKS['fuchsia'][1]): ('#f00079', '#f00078', '#f00077'),
tuple(BRIGHT_PACKS['ultraviolet'][1]): ('#a449ff', '#a24bff', '#a648ff'),
}
+# Packs drawn in their own colours on a dark wallpaper rather than lifted to DARK_FLOOR. Lifted, Ink's
+# near-blacks kept their low saturation and became a steel grey lighter than lifted Graphite, which
+# the effects then add as light: the owner saw white (06-10 and 10-10). A deep blue-black reads as ink and
+# still shows on a dark desktop.
+NEW_DARK_PACKS = {
+ tuple(MONO_PACKS['mono_ink'][1]): ('#2c3e66', '#1f2d4d', '#3b5287'),
+}
PACK_IDS = tuple(pack for _module, _name, _effects, packs in DIRECTIONS for pack in packs) + tuple(BRIGHT_PACKS) + tuple(MONO_PACKS)
@@ -755,8 +764,47 @@ PUSH_FADE = 0.1
PREVIEW_SCREEN = (800.0, 450.0)
PREVIEW_GAP = 40.0
PREVIEW_NOTCH = {"x": 307.5, "y": 0.0, "w": 185.0, "h": 32.0, "r": 10.0}
+PREVIEW_POINTER = ((0.0, 0.0), (0.0, 1.0), (0.26, 0.76), (0.44, 1.12),
+ (0.56, 1.06), (0.39, 0.7), (0.72, 0.7))
PREVIEW_LOOP_S = 4.4
_P_GLIDE, _P_PUSH, _P_CROSS, _P_REST = 0.4, 0.6, 2.2, 3.4
+# Where still_time looks for a tile's fullest frame, in preview_still_scene's points: the crossing
+# with the screens joined at their seam, and the pointer a switch plays round.
+PREVIEW_TILE_CROPS = {
+ "edge": (680.0, 142.0, 240.0, 120.0),
+ "corner": (680.0, -20.0, 240.0, 120.0),
+ "notch": (220.0, 400.0, 360.0, 180.0),
+ "switch": (248.0, 138.0, 240.0, 120.0),
+}
+PREVIEW_TILE_GROUND = "#0e0f0d"
+# A tile's view is zoomed until its marks fill it, within these many points across: tighter and a
+# spark's burst crowds its tile. A crossing's marks stand along an upright edge in a landscape tile,
+# so shown whole the tall ones shrink to slivers; past its limit their ends fade off instead. A
+# switch's marks sit round a point, and the notch's along the tile's long side, so they stay whole.
+PREVIEW_TILE_VIEW = {"edge": (150.0, 340.0), "corner": (150.0, 340.0), "notch": (150.0, 540.0),
+ "switch": (150.0, 540.0)}
+PREVIEW_TILE_ROOM = 2.5
+# A still's marks against the live loop's: a still is read at a glance at thumbnail size, a frame
+# of the loop is gone in 16 ms.
+PREVIEW_STILL_ALPHA = 2.2
+PREVIEW_LIGHT_CASING = 0.3
+# The most relative luminance a mark keeps on the Light card (#f1f0ea, 0.86): 3.4:1 against it.
+PREVIEW_LIGHT_MARK = 0.22
+PREVIEW_STILL_WIDTH = 1.3
+
+# Fixed cameras leave room for both legs of the pointer journey, including the arrow's body.
+PREVIEW_CROSSING_VIEWS = {
+ "edge": (500.0, 52.5, 600.0, 300.0),
+ "corner": (500.0, -20.0, 600.0, 300.0),
+ "notch": (-40.0, 300.0, 880.0, 440.0),
+}
+
+
+def preview_time(still_at, elapsed=None, reduced=False, switch=False):
+ """Hold through hover intent; a crossing starts at approach, a switch resumes its still."""
+ if elapsed is None or elapsed < 0.0 or reduced:
+ return still_at
+ return still_at + elapsed if switch else elapsed
def preview_size(method):
@@ -768,7 +816,8 @@ def preview_size(method):
return (w, h * 2 + PREVIEW_GAP) if method == "notch" else (w * 2 + PREVIEW_GAP, h)
-def preview_scene(fx, t, method, palette, reduced=False, dark=True, pace=1.0, effect_size="medium"):
+def preview_scene(fx, t, method, palette, reduced=False, dark=True, pace=1.0, effect_size="medium",
+ effect_size_fraction=None, notch_geometry=None, pointer_t=None):
"""The Design pages' loop, identical on both apps: the pointer glides to the Mac's boundary,
pushes through with three ticks, lands on the PC, and rests. Returns dict(screens=[(x, y, w,
h, os)], notch=(x, y, w, h, r) or None, pointer=(x, y, os) or None, pens=[Pen]) for time `t`
@@ -777,10 +826,13 @@ def preview_scene(fx, t, method, palette, reduced=False, dark=True, pace=1.0, ef
w, h = PREVIEW_SCREEN
if method == "notch":
pc_origin, mac_origin = (0.0, 0.0), (0.0, h + PREVIEW_GAP)
- region = {"kind": "notch", "edge": "top", "x": PREVIEW_NOTCH["x"], "y": 0.0, "w": PREVIEW_NOTCH["w"], "h": 1.0}
+ notch = dict(PREVIEW_NOTCH)
+ if notch_geometry is not None:
+ notch["w"], notch["h"] = notch_geometry
+ notch["x"] = (w - notch["w"]) / 2.0
+ region = {"kind": "notch", "edge": "top", "x": notch["x"], "y": 0.0, "w": notch["w"], "h": 1.0}
at, start = (w / 2.0, 0.0), (w / 2.0 - 90.0, 220.0)
land, land_edge, inside = (w / 2.0 + 10.0, h - 2.0), "bottom", (w / 2.0 + 40.0, h - 140.0)
- notch = PREVIEW_NOTCH
else:
mac_origin, pc_origin = (0.0, 0.0), (w + PREVIEW_GAP, 0.0)
if method == "corner":
@@ -799,12 +851,16 @@ def preview_scene(fx, t, method, palette, reduced=False, dark=True, pace=1.0, ef
common = dict(reduced=reduced, dark=dark)
palette = legible(palette, dark, fx)
mac_notch = notch if method == "notch" else None
+ # At the notch the hardware covers a pointer pinned at y=0. Show the approach just below
+ # that cutout and the arrival just inside B; effect states still use the real boundary points.
+ pointer_at = (at[0], notch["h"] + 8.0) if method == "notch" else at
+ pointer_land = (land[0], land[1] - 24.0) if method == "notch" else land
if t < _P_CROSS:
if t < _P_GLIDE:
u = ease_in_out(t / _P_GLIDE)
- p = (lerp(start[0], at[0], u), lerp(start[1], at[1], u))
+ p = (lerp(start[0], pointer_at[0], u), lerp(start[1], pointer_at[1], u))
else:
- p = at
+ p = pointer_at
scene["pointer"] = (mac_origin[0] + p[0], mac_origin[1] + p[1], "mac")
if t >= _P_PUSH:
u = (t - _P_PUSH) / (_P_CROSS - _P_PUSH)
@@ -816,24 +872,27 @@ def preview_scene(fx, t, method, palette, reduced=False, dark=True, pace=1.0, ef
tick = SimpleNamespace(index=index, age=t - crossed_at)
s = state(w, h, "mac", method, palette, notch=mac_notch, region=SimpleNamespace(**region),
point=point(*at), along=at[1] / h if region["edge"] == "right" else at[0] / w,
- pressure=pressure, tick=tick, since=None, effect_size=effect_size, **common)
+ pressure=pressure, tick=tick, since=None, pace=pace, effect_size=effect_size,
+ effect_size_fraction=effect_size_fraction, **common)
pen = draw(fx, "depart", s, mac_origin)
if pen is not None:
scene["pens"].append(pen)
return scene
since = (t - _P_CROSS) / pace
s = state(w, h, "mac", method, palette, notch=mac_notch, region=SimpleNamespace(**region), point=point(*at),
- along=0.5, pressure=0.0, tick=None, since=since, effect_size=effect_size, **common)
+ along=0.5, pressure=0.0, tick=None, since=since, pace=pace, effect_size=effect_size,
+ effect_size_fraction=effect_size_fraction, **common)
pen = draw(fx, "depart", s, mac_origin)
if pen is not None:
scene["pens"].append(pen)
- s = state(w, h, "windows", method, palette, point=point(*land), edge=land_edge, since=since,
- effect_size=effect_size, **common)
+ s = state(w, h, "windows", method, palette, point=point(*land), edge=land_edge, since=since, pace=pace,
+ effect_size=effect_size, effect_size_fraction=effect_size_fraction, **common)
pen = draw(fx, "arrive", s, pc_origin)
if pen is not None:
scene["pens"].append(pen)
- u = ease_in_out(clamp((t - _P_CROSS - 0.1) / (_P_REST - _P_CROSS - 0.1)))
- p = (lerp(land[0], inside[0], u), lerp(land[1], inside[1], u))
+ # `pointer_t` places the landed pointer at another moment than the effect, as a still does.
+ u = ease_in_out(clamp(((t if pointer_t is None else pointer_t) - _P_CROSS - 0.1) / (_P_REST - _P_CROSS - 0.1)))
+ p = (lerp(pointer_land[0], inside[0], u), lerp(pointer_land[1], inside[1], u))
scene["pointer"] = (pc_origin[0] + p[0], pc_origin[1] + p[1], "windows")
return scene
@@ -847,7 +906,8 @@ SWITCH_LOOP_S = 2.0
_S_START = 0.35
-def preview_switch_scene(fx, t, palette, os_name="mac", reduced=False, dark=True, pace=1.0, effect_size="medium"):
+def preview_switch_scene(fx, t, palette, os_name="mac", reduced=False, dark=True, pace=1.0, effect_size="medium",
+ effect_size_fraction=None):
"""The Design pages' loop for what a switch plays, in preview_scene's shape: one screen, the
pointer still near its middle, and `fx`'s switch arrival round it every SWITCH_LOOP_S."""
t = t % SWITCH_LOOP_S
@@ -857,40 +917,401 @@ def preview_switch_scene(fx, t, palette, os_name="mac", reduced=False, dark=True
since = (t - _S_START) / pace
if since >= 0.0:
s = state(w, h, os_name, "switch", legible(palette, dark, fx), reduced=reduced, dark=dark,
- effect_size=effect_size, point=point(*at),
- edge=nearest_edge(at[0], at[1], w, h), since=since)
+ effect_size=effect_size, effect_size_fraction=effect_size_fraction, point=point(*at),
+ edge=nearest_edge(at[0], at[1], w, h), since=since, pace=pace)
pen = draw(fx, "arrive", s)
if pen is not None:
scene["pens"].append(pen)
return scene
+def _moved(pen, dx, dy):
+ """`pen` with everything it draws, its bounds and its clip moved by (dx, dy)."""
+ def moved_path(path):
+ return [(segment[0],) + tuple(v + (dx if i % 2 == 0 else dy) for i, v in enumerate(segment[1:]))
+ for segment in path]
+ gradients = {}
+
+ def moved_paint(paint):
+ if not isinstance(paint, Gradient):
+ return paint
+ if id(paint) not in gradients:
+ g = paint.geometry
+ if paint.kind == "linear":
+ geometry = (g[0] + dx, g[1] + dy, g[2] + dx, g[3] + dy)
+ elif paint.kind == "radial":
+ geometry = (g[0] + dx, g[1] + dy, g[2], g[3] + dx, g[4] + dy, g[5])
+ else:
+ geometry = (g[0], g[1] + dx, g[2] + dy)
+ gradients[id(paint)] = Gradient(paint.kind, geometry)
+ gradients[id(paint)].stops = list(paint.stops)
+ return gradients[id(paint)]
+
+ pen.ops = [(op[0], moved_path(op[1]), moved_paint(op[2])) + op[3:] for op in pen.ops]
+ for name in ("bounds", "clip"):
+ box = getattr(pen, name)
+ if box is not None:
+ setattr(pen, name, (box[0] + dx, box[1] + dy, box[2] + dx, box[3] + dy))
+ return pen
+
+
[email protected]_cache(maxsize=1024)
+def _deepened(rgb):
+ """`rgb` darkened, hue and saturation kept, until its relative luminance is at most
+ PREVIEW_LIGHT_MARK: light oranges, greens and pinks drawn for a desktop sit near 2:1 on the
+ Light card."""
+ def luminance(colour):
+ return sum(w * (c / 12.92 if c <= .04045 else ((c + .055) / 1.055) ** 2.4)
+ for c, w in zip(colour, (.2126, .7152, .0722)))
+ if luminance(rgb) <= PREVIEW_LIGHT_MARK:
+ return rgb
+ low, high = 0.0, 1.0
+ for _ in range(16):
+ middle = (low + high) / 2
+ low, high = (middle, high) if luminance(tuple(c * middle for c in rgb)) <= PREVIEW_LIGHT_MARK else (low, middle)
+ return tuple(c * low for c in rgb)
+
+
+def _stronger(pen, alpha, width, casing_alpha=1.0, deepen=False):
+ """`pen` with every stroke `width` times as wide and every coloured op `alpha` times as opaque,
+ gradient stops included, and with `deepen` its colours _deepened. The dark casing most effects
+ stroke under a mark is not strengthened but taken to `casing_alpha` of its own opacity: drawn
+ for a desktop, at a tile's zoom on a light card it outlines every mark in black."""
+ gradients = {}
+ tone = _deepened if deepen else (lambda rgb: rgb)
+
+ def stronger_paint(paint):
+ if not isinstance(paint, Gradient):
+ return tone(tuple(paint[:3])) + tuple(paint[3:])
+ if id(paint) not in gradients:
+ gradients[id(paint)] = Gradient(paint.kind, paint.geometry)
+ gradients[id(paint)].stops = [(offset, tone(tuple(rgba[:3])) + (min(1.0, rgba[3] * alpha),))
+ for offset, rgba in paint.stops]
+ return gradients[id(paint)]
+
+ ops = []
+ for op in pen.ops:
+ paint = op[2]
+ colours = [rgba for _offset, rgba in paint.stops] if isinstance(paint, Gradient) else [paint]
+ # Effects case their marks in pure black; a near-black mark (the Ink packs) is a mark.
+ casing = all(max(rgba[:3]) < 0.01 for rgba in colours)
+ if casing:
+ op = op[:3] + (op[3] * casing_alpha,) + op[4:]
+ else:
+ op = op[:2] + (stronger_paint(paint), min(1.0, op[3] * alpha)) + op[4:]
+ if op[0] == "stroke":
+ op = op[:5] + (op[5] * width,) + op[6:]
+ ops.append(op)
+ pen.ops = ops
+ return pen
+
+
+def preview_still_scene(fx, t, place, palette, reduced=False, dark=True, pace=1.0, effect_size="medium", live=False,
+ view_width=None, effect_size_fraction=None, notch_geometry=None):
+ """A Design tile's specimen of frame `t`: the Mac's and the PC's halves of the effect
+ each clipped to its own screen and joined at the seam the pointer crosses, `seam` that line in
+ scene points (None for a switch, which crosses nothing). Strokes are widened to look
+ PREVIEW_STILL_WIDTH times their weight whatever `view_width` (still_view's) zooms them to. A
+ crossing keeps both screen fragments and the pointer; a switch still remains a mark specimen.
+ A still strengthens the marks. Reduced motion freezes that same frame. On
+ the Light card both fade the casing and deepen the colours, so hovering never changes them."""
+ w, h = PREVIEW_SCREEN
+ if place != "switch" and reduced:
+ t = still_time(fx, place, effect_size, pace, effect_size_fraction)
+ live, reduced = False, False
+ if place == "switch":
+ scene = preview_switch_scene(fx, t, palette, reduced=reduced, dark=dark, pace=pace, effect_size=effect_size,
+ effect_size_fraction=effect_size_fraction)
+ scene["seam"] = None
+ else:
+ # A still is the same frame at every Length (still_time stretches it), the pointer included:
+ # the hand does not slow with the pace, so it stands where it does at Normal.
+ pointer_t = _P_CROSS + (t - _P_CROSS) / pace if not live and t > _P_CROSS else None
+ scene = preview_scene(fx, t, place, palette, reduced=reduced, dark=dark, pace=pace, effect_size=effect_size,
+ effect_size_fraction=effect_size_fraction, notch_geometry=notch_geometry,
+ pointer_t=pointer_t)
+ # The PC's half moves across the gap onto the Mac's edge. A pen is the PC's when its middle
+ # is past the middle of the gap: an arrival may reach back over the edge it lands at.
+ if place == "notch":
+ axis, middle, shift = 1, h + PREVIEW_GAP / 2.0, (0.0, PREVIEW_GAP)
+ scene["seam"] = (0.0, h + PREVIEW_GAP, w, h + PREVIEW_GAP)
+ else:
+ axis, middle, shift = 0, w + PREVIEW_GAP / 2.0, (-PREVIEW_GAP, 0.0)
+ scene["seam"] = (w, 0.0, w, h)
+ mac, pc = (screen[:4] for screen in scene["screens"])
+ for pen in scene["pens"]:
+ on_pc = (pen.bounds[axis] + pen.bounds[axis + 2]) / 2.0 > middle
+ if place == "notch":
+ on_pc = not on_pc
+ x, y, sw, sh = pc if on_pc else mac
+ pen.clip = (x, y, x + sw, y + sh)
+ if on_pc:
+ _moved(pen, *shift)
+ if scene["pointer"] is not None and scene["pointer"][2] == "windows":
+ px, py, os_name = scene["pointer"]
+ scene["pointer"] = (px + shift[0], py + shift[1], os_name)
+ scene["screens"] = [scene["screens"][0],
+ (pc[0] + shift[0], pc[1] + shift[1], pc[2], pc[3], "windows")]
+ if place == "switch":
+ scene["screens"] = []
+ reference = PREVIEW_TILE_CROPS[place][2]
+ width = PREVIEW_STILL_WIDTH * (view_width or reference) / reference
+ if place != "switch":
+ # The complete journey has a wider camera than the old specimen. Keep the quiet styles'
+ # thin marks legible at tile size on both native rasterisers.
+ width *= 1.8
+ for pen in scene["pens"]:
+ alpha = PREVIEW_STILL_ALPHA * (1.4 if place != "switch" else 1.0)
+ _stronger(pen, 1.0 if live else alpha, width, 1.0 if dark else PREVIEW_LIGHT_CASING, not dark)
+ if not live and place == "switch":
+ scene["pointer"] = None
+ return scene
+
+
+def _op_boxes(scene):
+ """(box, alpha) for every op in `scene`'s pens: the box round its points and its stroke, cut
+ to its pen's clip, and how opaque it is at most. Ops the clip leaves nothing of are skipped."""
+ for pen in scene["pens"]:
+ clip = pen.clip or (-math.inf, -math.inf, math.inf, math.inf)
+ for op in pen.ops:
+ points = [segment[i:i + 2] for segment in op[1] for i in range(1, len(segment) - 1, 2)]
+ if not points:
+ continue
+ pad = op[5] / 2 if op[0] == "stroke" else 0.0
+ x0, x1 = max(min(p[0] for p in points) - pad, clip[0]), min(max(p[0] for p in points) + pad, clip[2])
+ y0, y1 = max(min(p[1] for p in points) - pad, clip[1]), min(max(p[1] for p in points) + pad, clip[3])
+ if x1 <= x0 or y1 <= y0:
+ continue
+ paint = op[2]
+ paint_alpha = max((stop[1][3] for stop in paint.stops), default=1.0) if isinstance(paint, Gradient) else paint[3]
+ yield (x0, y0, x1, y1), op[3] * paint_alpha
+
+
[email protected]_cache(maxsize=256)
+def _still_view(effect, place, effect_size, pace, effect_size_fraction):
+ if place in PREVIEW_CROSSING_VIEWS:
+ return PREVIEW_CROSSING_VIEWS[place]
+ fx = effect if isinstance(effect, Effect) else preview_effect(effect)
+ scene = preview_still_scene(fx, still_time(effect, place, effect_size, pace, effect_size_fraction), place,
+ ("#ffffff",), pace=pace, effect_size=effect_size, live=True,
+ effect_size_fraction=effect_size_fraction)
+ return _fit(scene, place) or PREVIEW_TILE_CROPS[place]
+
+
+def _fit(scene, place):
+ """The 2:1 view still_view describes for `scene`, or None when it draws nothing."""
+ boxes = [box for box, _alpha in _op_boxes(scene)]
+ if not boxes:
+ return None
+ left, top = min(b[0] for b in boxes), min(b[1] for b in boxes)
+ right, bottom = max(b[2] for b in boxes), max(b[3] for b in boxes)
+ cx, cy = (left + right) / 2.0, (top + bottom) / 2.0
+ level = scene["seam"] is not None and scene["seam"][1] == scene["seam"][3]
+ if scene["seam"] is not None:
+ # Centred on the seam across it, so the crossing sits in the middle of every tile.
+ cx, cy = (cx, scene["seam"][1]) if level else (scene["seam"][0], cy)
+ half_w, half_h = max(cx - left, right - cx), max(cy - top, bottom - cy)
+ low, high = PREVIEW_TILE_VIEW[place]
+ width = 1.15 * max(2.0 * half_w, 4.0 * half_h)
+ w, h = PREVIEW_SCREEN
+ if scene["seam"] is not None and (right - left if level else bottom - top) >= 0.9 * (w if level else h):
+ # A style that runs the length of the edge has no ends to show, and whole it is a sliver: a
+ # close-up of the stretch the pointer crossed, PREVIEW_TILE_ROOM times as deep as its marks.
+ width = min(high, max(low, PREVIEW_TILE_ROOM * (4.0 * half_h if level else 2.0 * half_w)))
+ if scene["pointer"] is not None:
+ px, py = scene["pointer"][:2]
+ if level:
+ cx = min(max(px, left + width / 2.0), right - width / 2.0)
+ else:
+ cy = min(max(py, top + width / 4.0), bottom - width / 4.0)
+ width = min(high, max(low, width))
+ return (cx - width / 2.0, cy - width / 4.0, width, width / 2.0)
+
+
+def still_view(effect, place, effect_size="medium", pace=1.0, effect_size_fraction=None):
+ """The part of preview_still_scene a Design tile shows for `effect` at `place`, (x, y, w, h) in
+ scene points, 2:1: fixed round a crossing's complete pointer journey, or fitted round a switch's
+ marks. Idle, reduced motion and the hover loop share the camera."""
+ still_time(effect, place, effect_size, pace, effect_size_fraction)
+ return _still_view(_still_key(effect), place, effect_size, pace, effect_size_fraction)
+
+
+def _cells(low, high, origin, size, n):
+ """How many of n cell centres across `size` from `origin` fall within [low, high]."""
+ first = max(0, math.ceil((low - origin) * n / size - 0.5))
+ last = min(n - 1, math.floor((high - origin) * n / size - 0.5))
+ return max(0, last - first + 1)
+
+
+# Every Length and Size step used to search 60 frames per tile again, so the Design page froze for
+# a second at each slider step. The search is for Normal and Medium only, and Length only stretches
+# when the found frame comes.
+STILL_SEARCH_STEPS = 30
+
+
+# _search_still's answers for every effect at Edge, Corner, Notch and a switch, worked out once so the
+# page opens without building 2,000 scenes; test_style_previews holds them equal to the search.
+STILL_SEARCHED = {
+ "glow": (2.2103448275862068, 2.2103448275862068, 1.9000000000000001, 0.0),
+ "beam": (2.2103448275862068, 2.2103448275862068, 1.9000000000000001, 0.0),
+ "aperture": (2.3551724137931034, 2.2103448275862068, 2.396551724137931, 0.4),
+ "skin": (2.3551724137931034, 2.2103448275862068, 2.2517241379310344, 0.6),
+ "film": (2.2103448275862068, 2.2103448275862068, 2.2103448275862068, 0.6),
+ "rupture": (2.4586206896551723, 2.2103448275862068, 2.2517241379310344, 0.6666666666666666),
+ "flint": (2.2724137931034485, 2.2724137931034485, 2.2724137931034485, 0.4),
+ "filings": (2.293103448275862, 2.293103448275862, 2.293103448275862, 0.4666666666666667),
+ "discharge": (2.293103448275862, 2.293103448275862, 2.293103448275862, 0.4666666666666667),
+ "rule": (2.2103448275862068, 2.2103448275862068, 2.2103448275862068, 0.4),
+ "gauge": (2.2103448275862068, 2.2103448275862068, 2.2103448275862068, 0.4),
+ "rangefinder": (2.2103448275862068, 2.2103448275862068, 2.2103448275862068, 0.4),
+ "crease": (2.2724137931034485, 2.4586206896551723, 2.2517241379310344, 0.4),
+ "pleat": (2.2103448275862068, 2.4793103448275864, 2.2724137931034485, 0.4),
+ "concertina": (2.2103448275862068, 2.5, 2.2724137931034485, 0.4),
+ "thread": (2.2724137931034485, 2.2103448275862068, 2.231034482758621, 0.4),
+ "weave": (2.231034482758621, 2.2724137931034485, 2.2103448275862068, 0.4),
+ "jacquard": (2.2103448275862068, 2.231034482758621, 2.293103448275862, 0.4),
+}
+_PLACE_INDEX = {"edge": 0, "corner": 1, "notch": 2, "switch": 3}
+
+
+def _still_at(effect_id, place):
+ found = STILL_SEARCHED.get(effect_id) if isinstance(effect_id, str) else None
+ return found[_PLACE_INDEX[place]] if found is not None else _search_still(effect_id, place)
+
+
[email protected]_cache(maxsize=256)
+def _search_still(effect_id, place):
+ fx = effect_id if isinstance(effect_id, Effect) else preview_effect(effect_id)
+ crop = PREVIEW_CROSSING_VIEWS.get(place, PREVIEW_TILE_CROPS[place])
+ best_time, best_coverage = 0.0, -1
+ for step in range(STILL_SEARCH_STEPS):
+ if place == "switch":
+ at = SWITCH_LOOP_S * step / STILL_SEARCH_STEPS
+ else:
+ end = _P_CROSS + min(0.3, max(fx.depart_seconds, fx.arrive_seconds))
+ at = _P_CROSS - 0.3 + (end - _P_CROSS + 0.3) * step / (STILL_SEARCH_STEPS - 1)
+ scene = preview_still_scene(fx, at, place, ("#ffffff",), live=True)
+ coverage = 0.0
+ for (x0, y0, x1, y1), alpha in _op_boxes(scene):
+ coverage += (_cells(y0, y1, crop[1], crop[3], 24) * _cells(x0, x1, crop[0], crop[2], 48)) * alpha
+ if coverage > best_coverage:
+ best_time, best_coverage = at, coverage
+ return best_time
+
+
+def still_time(effect, place, effect_size="medium", pace=1.0, effect_size_fraction=None):
+ """The fullest real seam frame for a crossing, or arrival specimen for a switch."""
+ if not isinstance(effect, Effect) and effect not in CLASSIC and effect not in EFFECT_IDS:
+ raise ValueError(f"unknown preview effect: {effect}")
+ if place not in PREVIEW_TILE_CROPS:
+ raise ValueError(f"unknown preview place: {place}")
+ at = _still_at(_still_key(effect), place)
+ start = _S_START if place == "switch" else _P_CROSS
+ # The push follows the hand, so only what comes after the crossing or the arrival stretches.
+ return at if at < start else start + (at - start) * pace
+
+
+def _still_key(effect):
+ """The cache key for `effect`'s still: its id when the id names it, else the Effect itself."""
+ effect_id = effect.id if isinstance(effect, Effect) else effect
+ return effect_id if effect_id in CLASSIC or effect_id in EFFECT_IDS else effect
+
+
# The Design pages' Length: how long an effect takes to play through once the pointer crosses, and
# to land, as a multiple of its own timing. The push itself follows the hand, so it has no pace.
LENGTHS = (("short", "Short"), ("normal", "Normal"), ("long", "Long"))
SIZES = (("small", "Small"), ("medium", "Medium"), ("large", "Large"))
PACES = {"short": 0.5, "normal": 1.0, "long": 2.0}
_SIZE_FRACTIONS = {"small": 0.03, "medium": 0.045, "large": 0.06}
+DESIGN_READOUT_WIDTH = 58
+_PACE_STEPS = (0.5, 1.0, 2.0)
+_PACE_PRESETS = ("short", "normal", "long")
+_SIZE_STOPS = (0.03, 0.045, 0.06)
+_SIZE_PRESETS = ("small", "medium", "large")
+MIN_EFFECT_PACE = 0.25
+MAX_EFFECT_PACE = 2.5
+MIN_EFFECT_SIZE_FRACTION = 0.02
+MAX_EFFECT_SIZE_FRACTION = 0.08
_MIN_EDGE_DEPTH = 24.0
_MAX_EDGE_DEPTH = 144.0
_EFFECT_REFERENCE_DEPTH = 36.0
-def edge_depth(screen_w, screen_h, size="medium"):
+def _number(value, low, high):
+ return not isinstance(value, bool) and isinstance(value, (int, float)) and low <= value <= high
+
+
+def valid_effect_pace(value):
+ return _number(value, MIN_EFFECT_PACE, MAX_EFFECT_PACE)
+
+
+def valid_effect_size_fraction(value):
+ return _number(value, MIN_EFFECT_SIZE_FRACTION, MAX_EFFECT_SIZE_FRACTION)
+
+
+def length_preset(value):
+ return _PACE_PRESETS[min(range(len(_PACE_STEPS)), key=lambda i: abs(_PACE_STEPS[i] - value))]
+
+
+def size_preset(value):
+ return _SIZE_PRESETS[min(range(len(_SIZE_STOPS)), key=lambda i: abs(_SIZE_STOPS[i] - value))]
+
+
+def design_values(effect_pace=None, effect_size_fraction=None, length=None, size=None):
+ """Resolve optional slider values and their nearest legacy presets for storage and the wire.
+ A slider value wins only while its preset still agrees with it: a preset that disagrees was set
+ later by something that knows only presets (a 1.5.0 to 1.5.2 peer, or 1.5.2 run on this file
+ after 1.5.3), and the stale slider value would otherwise undo that change. None means not given."""
+ if length not in PACES:
+ length = None
+ if size not in _SIZE_FRACTIONS:
+ size = None
+ if valid_effect_pace(effect_pace) and length in (None, length_preset(float(effect_pace))):
+ pace_value = float(effect_pace)
+ else:
+ pace_value = PACES[length or "normal"]
+ if valid_effect_size_fraction(effect_size_fraction) and size in (None, size_preset(float(effect_size_fraction))):
+ fraction = float(effect_size_fraction)
+ else:
+ fraction = _SIZE_FRACTIONS[size or "medium"]
+ return pace_value, fraction, length_preset(pace_value), size_preset(fraction)
+
+
+def snap_detent(value, low, high, stops, track_fraction=0.02):
+ """Snap a pointer-drag value to a legacy stop within a fraction of the slider track."""
+ radius = (high - low) * track_fraction
+ stop = min(stops, key=lambda item: abs(item - value))
+ return stop if abs(stop - value) <= radius else value
+
+
+def edge_depth(screen_w, screen_h, size="medium", size_fraction=None):
"""The edge band's depth in screen units, scaled to the shorter side of its display."""
- fraction = _SIZE_FRACTIONS.get(size, _SIZE_FRACTIONS["medium"])
+ fraction = (float(size_fraction) if valid_effect_size_fraction(size_fraction)
+ else _SIZE_FRACTIONS.get(size, _SIZE_FRACTIONS["medium"]))
return max(_MIN_EDGE_DEPTH, min(_MAX_EDGE_DEPTH, min(float(screen_w), float(screen_h)) * fraction))
def effect_depth_scale(s):
"""Scale material depths from their 1200 by 800 reference canvas to this screen and Size."""
- return edge_depth(s.screen.w, s.screen.h, getattr(s, "effect_size", "medium")) / _EFFECT_REFERENCE_DEPTH
+ return edge_depth(s.screen.w, s.screen.h, getattr(s, "effect_size", "medium"),
+ getattr(s, "effect_size_fraction", None)) / _EFFECT_REFERENCE_DEPTH
def pace(length):
return PACES.get(length, 1.0)
+def play_through_seconds(style, effect_pace=1.0):
+ """The selected crossing style's playback time, before the hand-driven push, in seconds."""
+ fx = LOCATOR if style == "locator" else preview_effect(style) or preview_effect("glow")
+ return (fx.depart_seconds or fx.arrive_seconds) * effect_pace
+
+
+def design_slider_readouts(style, effect_pace, size_fraction, screen_width, screen_height):
+ return (f"{play_through_seconds(style, effect_pace):.1f} s",
+ f"{edge_depth(screen_width, screen_height, size_fraction=size_fraction):.0f} pt")
+
+
class Player:
"""The timeline of one machine's effects, fed the same events the glow is fed today.
@@ -911,6 +1332,7 @@ class Player:
# How long everything after the push takes, as a multiple of each effect's own timing.
self.pace = pace
self.effect_size = "medium"
+ self.effect_size_fraction = None
def push(self, now, method, region, at, pressure, tick_index=None, display=None):
"""`region` is dict(kind, edge, corner?, x, y, w, h); `at` is (x, y) of the pinned pointer.
@@ -979,8 +1401,10 @@ class Player:
if d["tick"] is not None and since is None:
tick = SimpleNamespace(index=d["tick"][0], age=now - d["tick"][1])
s = state(fw, fh, os_name, d["method"], legible(palette, dark, fx), reduced=reduced, dark=dark,
- notch=local_notch, effect_size=self.effect_size, region=SimpleNamespace(**region), point=point(x, y), along=along,
- pressure=d["pressure"], tick=tick, since=since)
+ notch=local_notch, effect_size=self.effect_size,
+ effect_size_fraction=self.effect_size_fraction,
+ region=SimpleNamespace(**region), point=point(x, y), along=along,
+ pressure=d["pressure"], tick=tick, since=since, pace=self.pace)
pen = _clipped(draw(fx, "depart", s, (ox, oy)), frame)
if pen is not None:
pens.append(pen)
@@ -997,7 +1421,9 @@ class Player:
# and effects that see a notch above the pointer draw round the notch.
s = state(fw, fh, os_name, a["method"], legible(palette, dark, arrival_fx), reduced=reduced,
dark=dark, notch=None if a["switch"] else local_notch, effect_size=self.effect_size,
- point=point(a["at"][0] - ox, a["at"][1] - oy), edge=a["edge"], since=since)
+ effect_size_fraction=self.effect_size_fraction,
+ point=point(a["at"][0] - ox, a["at"][1] - oy), edge=a["edge"], since=since,
+ pace=self.pace)
pen = _clipped(draw(arrival_fx, "arrive", s, (ox, oy)), frame)
if pen is not None:
pens.append(pen)
diff --git a/core/fx_instrument.py b/core/fx_instrument.py
index 5ea4691..2d20347 100644
--- a/core/fx_instrument.py
+++ b/core/fx_instrument.py
@@ -26,15 +26,24 @@ def roles(s):
# native canvas arc at the dial and reticle radii drawn here. Doubling the density (pi/4 a piece)
# is the best trade-off found by measurement: finer still fixes some states and reopens others
# elsewhere in the same sweep, so this is the port's fix, not a tuned-away symptom.
-def detent(u, n, slide=0.4):
- """n equal detents, each move taking the first `slide` of its slot and then holding."""
+def detent(u, n, slide=0.4, pace=1.0):
+ """n equal detents, each move taking the first `slide` of its slot and then holding.
+
+ A longer Length plays everything slower, `pace` times, and stretched with it the holds became
+ stills: 117ms at 2.5, read as a low frame rate. Past pace 1 every move after the first starts
+ early, into the hold before it, so a hold lasts as long in real time as at pace 1. Each move
+ still ends where it did, so the lock and flash each design times against its last move stay put."""
if u <= 0:
return 0.0
if u >= 1:
return 1.0
- k = math.floor(u * n)
- f = u * n - k
- return min(1.0, (k + clamp(f / slide)) / n)
+ x = u * n
+ k = math.floor(x)
+ lead = (1.0 - slide) * (1.0 - 1.0 / pace) if pace > 1.0 else 0.0
+ if k + 1 < n and x >= k + 1 - lead:
+ k += 1
+ early = lead if k else 0.0
+ return min(1.0, (k + clamp((x - k + early) / (slide + early))) / n)
def ink(ctx, s, colour, w, alpha, build):
@@ -215,9 +224,9 @@ def rule_depart(ctx, s):
return
p, done = 1, True
if s.reduced:
- alpha = 1 - detent(u, 4, 0.25)
+ alpha = 1 - detent(u, 4, 0.25, pace=getattr(s, "pace", 1.0))
else:
- reach = SP * N * (1 - detent(u, 4))
+ reach = SP * N * (1 - detent(u, 4, pace=getattr(s, "pace", 1.0)))
alpha = 1 - clamp((u - 0.75) / 0.25)
if alpha <= 0:
return
@@ -249,7 +258,7 @@ def rule_arrive(ctx, s):
if t >= 0.6:
return
C = roles(s)
- c = 1 if s.reduced else detent(t / 0.28, 3)
+ c = 1 if s.reduced else detent(t / 0.28, 3, pace=getattr(s, "pace", 1.0))
locked = t >= 0.26
flash = clamp(1 - (t - 0.26) / 0.12) if locked else 0
alpha = 1 if t < 0.38 else 1 - (t - 0.38) / 0.22
@@ -324,7 +333,7 @@ def gauge_notch(ctx, s, k, C):
if u >= 0.6:
return
fade = 1 if u < 0.4 else 1 - (u - 0.4) / 0.2
- shut = 1 if s.reduced else detent(u / 0.36, 4)
+ shut = 1 if s.reduced else detent(u / 0.36, 4, pace=getattr(s, "pace", 1.0))
a, b = k.tp * shut, L - (L - k.tp) * shut
def blades():
@@ -397,8 +406,8 @@ def gauge_depart(ctx, s):
u = s.since
if u >= 0.6:
return
- fade = (1 - detent(u / 0.6, 4, 0.25)) if s.reduced else (1 if u < 0.4 else 1 - (u - 0.4) / 0.2)
- shut = 1 if s.reduced else detent(u / 0.36, 4)
+ fade = (1 - detent(u / 0.6, 4, 0.25, pace=getattr(s, "pace", 1.0))) if s.reduced else (1 if u < 0.4 else 1 - (u - 0.4) / 0.2)
+ shut = 1 if s.reduced else detent(u / 0.36, 4, pace=getattr(s, "pace", 1.0))
a = R0 * (1 - shut)
rot = shut * PI / 6
@@ -431,7 +440,7 @@ def gauge_arrive(ctx, s):
if t >= 0.7:
return
C = roles(s)
- c = 1 if s.reduced else detent(t / 0.34, 4)
+ c = 1 if s.reduced else detent(t / 0.34, 4, pace=getattr(s, "pace", 1.0))
lock_at = 0.3
locked = t >= lock_at
flash = clamp(1 - (t - lock_at) / 0.14) if locked else 0
@@ -564,8 +573,8 @@ def rangefinder_depart(ctx, s):
if u >= 0.8:
return
fade = 1 if u < 0.55 else 1 - (u - 0.55) / 0.25
- A = 0 if s.reduced else SPAN * (1 - detent(u / 0.42, 4))
- slit = 70 if s.reduced else 70 * (1 - detent(u / 0.55, 5))
+ A = 0 if s.reduced else SPAN * (1 - detent(u / 0.42, 4, pace=getattr(s, "pace", 1.0)))
+ slit = 70 if s.reduced else 70 * (1 - detent(u / 0.55, 5, pace=getattr(s, "pace", 1.0)))
blades, on = [], []
for ray in k.rays:
lim = min(SPAN, ray.max)
@@ -601,7 +610,7 @@ def rangefinder_arrive(ctx, s):
if t >= 0.8:
return
C = roles(s)
- c = 1 if s.reduced else detent(t / 0.4, 4)
+ c = 1 if s.reduced else detent(t / 0.4, 4, pace=getattr(s, "pace", 1.0))
LOCK = 0.34
locked = t >= LOCK
flash = clamp(1 - (t - LOCK) / 0.18) if locked else 0
diff --git a/core/keytable.py b/core/keytable.py
index 1b3b93e..f48f9ea 100644
--- a/core/keytable.py
+++ b/core/keytable.py
@@ -65,8 +65,10 @@ EVDEV_NAMES = {
111: "delete", 110: "insert", 102: "home", 107: "end", 104: "page_up", 109: "page_down",
105: "left", 106: "right", 103: "up", 108: "down",
127: "menu", 99: "print_screen", 119: "pause", 69: "num_lock", 70: "scroll_lock",
- 158: "browser_back", 159: "browser_forward",
+ 128: "browser_stop", 140: "calculator", 150: "browser_home", 155: "mail",
+ 158: "browser_back", 159: "browser_forward", 173: "browser_refresh", 217: "search",
113: "volume_mute", 114: "volume_down", 115: "volume_up",
+ 224: "brightness_down", 225: "brightness_up", 248: "mic_mute",
163: "media_next", 165: "media_prev", 166: "media_stop", 164: "media_play_pause",
}
EVDEV_NAMES.update({59 + i: f"f{i + 1}" for i in range(10)})
@@ -85,7 +87,9 @@ SPEC_NAMES = frozenset(
{"shift", "shift_r", "ctrl", "ctrl_r", "alt", "alt_r", "cmd", "cmd_r", "caps_lock",
"backspace", "tab", "enter", "esc", "space", "delete", "insert", "home", "end", "page_up", "page_down",
"left", "right", "up", "down", "menu", "print_screen", "pause", "num_lock", "scroll_lock",
- "browser_back", "browser_forward",
+ "browser_back", "browser_forward", "browser_stop", "browser_home", "browser_refresh", "search",
+ "browser_search", "browser_favourites", "mail", "media_select", "launch_app1", "launch_app2",
+ "calculator", "mic_mute", "brightness_up", "brightness_down", "spotlight", "dictation",
"volume_mute", "volume_down", "volume_up", "media_next", "media_prev", "media_stop", "media_play_pause"}
| {f"f{i}" for i in range(1, 25)}
)
diff --git a/core/link.py b/core/link.py
index 4c9e830..61cad83 100644
--- a/core/link.py
+++ b/core/link.py
@@ -24,6 +24,7 @@ import time
from core import peerlist
from core import protocol
from core import receiver
+from core.response_time import ResponseTime
LOGGER = logging.getLogger("Beamer")
@@ -39,6 +40,7 @@ QUEUE_LIMIT = 2048
QUEUE_BYTES = 32 * 1024 * 1024
STALL_SECONDS = 2.0
SENT_RECORD_LIMIT = 20000
+ACK_STALL_SECONDS = 1.5
MEDIA_KEYS = frozenset({"volume_mute", "volume_down", "volume_up", "media_next", "media_prev", "media_stop", "media_play_pause"})
WINDOW_SECONDS = 30.0
LOG_SECONDS = 60.0
@@ -119,6 +121,9 @@ class OutboundLink:
self.last_sent_seq = 0
self._written_seq = 0
self._sent_at = collections.deque()
+ self._ack_pause_since = None
+ self._ack_stall_credit = {}
+ self._last_logged_sent_seq = 0
self._samples = collections.deque()
self._period = []
self._last_ack_seq = -1
@@ -142,6 +147,9 @@ class OutboundLink:
self._followed_at = None
self._followed_to = None
self._answered = False
+ self._response_time = ResponseTime(clock=clock)
+ self._response_time_enabled = False
+ self._next_response_probe = 0.0
self._checked_at = 0.0
self.status = ""
# What the last report was, for the app to word in its own way: "connected", "removed",
@@ -234,10 +242,11 @@ class OutboundLink:
"""What this link's sentences call the machine: its label, so two of one name are told apart."""
entry = entry or {}
try:
- shown = peerlist.label_for(self._book.peers(), token=entry.get("token"))
+ shown = peerlist.label_for(self._book.peers(), token=entry.get("token"),
+ peer_id=entry.get("id"), host=entry.get("host"))
except Exception:
shown = ""
- return shown or entry.get("name") or entry.get("host") or "The other machine"
+ return shown or entry.get("host") or "The other machine"
# The thread
@@ -295,15 +304,23 @@ class OutboundLink:
closed_since = None
if closed_since is not None and now - closed_since >= FORGOTTEN_AFTER_SECONDS:
name = self._name(entry)
+ try:
+ self._book.mark_dormant(self.token, "forgotten")
+ except Exception:
+ LOGGER.exception("Could not save the dormant state for %s", name)
if self.kind != "forgotten":
LOGGER.info("%s has closed every handshake for %d seconds; it no longer has this pairing",
name, FORGOTTEN_AFTER_SECONDS)
- self._report(False, f"{name} no longer has this pairing: remove {name} here and pair "
- "the two again", "forgotten")
+ self._report(False, f"{name} no longer has this pairing: use Re-pair on Overview", "forgotten")
wait = max(wait, FORGOTTEN_RETRY_SECONDS)
else:
self._report(False, ended.text, ended.kind)
if ended.stop_dialling:
+ if ended.kind == "wrong_id":
+ try:
+ self._book.mark_dormant(self.token, "wrong_id")
+ except Exception:
+ LOGGER.exception("Could not save the dormant state for %s", self._name(entry))
self._blocked_for = shape
except Exception:
closed_since = None
@@ -442,7 +459,7 @@ class OutboundLink:
welcome = protocol.read_welcome(protocol.recv_first_msg(sock, session, deadline))
except protocol.HelloRefused as refused:
if refused.error == protocol.ERROR_WRONG_ID:
- raise LinkEnded(f"{name} has this pairing under another machine: remove it on both and pair again.", "wrong_id", stop_dialling=True) from None
+ raise LinkEnded(f"{name} has this pairing under another machine: use Re-pair on Overview.", "wrong_id", stop_dialling=True) from None
raise LinkEnded(f"{name} could not read what this machine sent first; Beamer on the two machines may differ", "unreadable") from None
except (protocol.InvalidWelcome, protocol.NotAnObject):
raise LinkEnded(f"A different Beamer answered at {host}", "different") from None
@@ -461,6 +478,7 @@ class OutboundLink:
if outcome == receiver.WRONG_ID:
raise LinkEnded(f"A different Beamer answered at {host}", "different")
sock.settimeout(READ_SECONDS)
+ welcome["own_caps"] = identity["caps"]
welcome["session"] = session
return welcome
@@ -468,11 +486,15 @@ class OutboundLink:
def _serve(self, sock, fields):
session = fields.pop("session")
+ own_caps = fields.pop("own_caps", ())
entry = self.entry() or {}
now = self._clock()
with self._lock:
self._sock, self._session = sock, session
self._caps = frozenset(fields["caps"])
+ self._response_time_enabled = "ping_rtt" in self._caps and "ping_rtt" in own_caps
+ self._next_response_probe = now + PING_SECONDS
+ self._response_time.reset()
self.peer_id = protocol.id_text(fields["id"])
self.peer_platform = fields["platform"]
self.peer_name = fields["name"]
@@ -513,12 +535,16 @@ class OutboundLink:
self._writing = False
self._seq = self.last_sent_seq = self._written_seq = 0
self._sent_at.clear()
+ self._ack_pause_since = None
+ self._ack_stall_credit.clear()
+ self._last_logged_sent_seq = 0
self._samples.clear()
self._period = []
self._last_ack_seq = -1
self.last_ack_at = None
self._locked = False
self._drop_reason = None
+ self._response_time.reset()
def _close(self, only=None):
with self._cond:
@@ -547,6 +573,10 @@ class OutboundLink:
began = now
buffer.extend(chunk)
self._last_rx = now
+ if len(buffer) >= protocol.HEADER_SIZE:
+ length = int.from_bytes(buffer[:protocol.HEADER_SIZE], "big")
+ if length - 20 > protocol.SMALL_MESSAGE_BYTES:
+ self._begin_ack_pause(began or now)
elif now - self._last_rx > SILENCE_SECONDS:
raise LinkEnded(f"{name} stopped responding", "stopped")
while len(buffer) >= protocol.HEADER_SIZE:
@@ -560,14 +590,22 @@ class OutboundLink:
body = bytes(buffer[protocol.HEADER_SIZE:protocol.HEADER_SIZE + length])
del buffer[:protocol.HEADER_SIZE + length]
plain = session.open_raw(body)
- if len(plain) > protocol.SMALL_MESSAGE_BYTES and not self._large_due(began or now):
- LOGGER.warning("Dropped a %d byte message from %s that no clipboard was due for", len(plain), name)
- else:
- self._deal(protocol.parse_message(plain), began or now)
+ try:
+ if len(plain) > protocol.SMALL_MESSAGE_BYTES and not self._large_due(began or now):
+ LOGGER.warning("Dropped a %d byte message from %s that no clipboard was due for", len(plain), name)
+ else:
+ self._deal(protocol.parse_message(plain), began or now)
+ finally:
+ if length - 20 > protocol.SMALL_MESSAGE_BYTES:
+ self._end_ack_pause(self._clock())
began = now if buffer else None
+ if len(buffer) >= protocol.HEADER_SIZE:
+ next_length = int.from_bytes(buffer[:protocol.HEADER_SIZE], "big")
+ if next_length - 20 > protocol.SMALL_MESSAGE_BYTES:
+ self._begin_ack_pause(began or now)
if buffer and now - began > protocol.FRAME_COMPLETE_SECONDS:
raise LinkEnded(f"{name} took too long to send one message", "stopped")
- self._tick(now)
+ self._tick(self._clock())
def _large_due(self, began):
if self._large is None:
@@ -578,14 +616,53 @@ class OutboundLink:
LOGGER.exception("Could not tell whether a large message was due")
return False
+ def _begin_ack_pause(self, began):
+ with self._lock:
+ if self._ack_pause_since is None:
+ self._ack_pause_since = began
+
+ def _end_ack_pause(self, ended):
+ with self._lock:
+ began, self._ack_pause_since = self._ack_pause_since, None
+ if began is not None:
+ for seq, sent in self._sent_at:
+ self._ack_stall_credit[seq] = self._ack_stall_credit.get(seq, 0.0) + max(
+ 0.0, ended - max(began, sent)
+ )
+
def _deal(self, message, began):
if message.get("type") == protocol.MSG_ACK:
self._ack(protocol.read_ack(message))
return
+ if message.get("type") == protocol.MSG_PING:
+ self._handle_ping(message)
message.began_at = began
self._call(2, message)
+ def _handle_ping(self, message):
+ if not self._response_time_enabled:
+ return
+ read = protocol.read_ping(message)
+ if read is None:
+ return
+ if "echo" in read:
+ self._response_time.echoed(read["echo"])
+ if "probe" in read:
+ self._enqueue(protocol.ping_msg(echo=read["probe"]), seq=False)
+
def _tick(self, now):
+ with self._lock:
+ oldest = self._sent_at[0] if self._sent_at else None
+ last_acked = self._last_ack_seq
+ pending = len(self._sent_at)
+ ack_paused = self._ack_pause_since is not None
+ oldest_age = now - oldest[1] - self._ack_stall_credit.get(oldest[0], 0.0) if oldest else 0.0
+ if oldest is not None and not ack_paused and oldest_age > ACK_STALL_SECONDS:
+ LOGGER.warning(
+ "%s stopped acknowledging input: oldest seq %d, last acked seq %d, %d unacknowledged",
+ self.peer_name, oldest[0], last_acked, pending,
+ )
+ raise LinkEnded(f"{self.peer_name} stopped acknowledging input", "stalled")
if self._writing and now - self._last_progress > STALL_SECONDS:
raise LinkEnded(f"{self._name(self.entry())} stopped accepting data", "stopped")
if now - self._checked_at >= 1.0:
@@ -595,7 +672,11 @@ class OutboundLink:
raise LinkEnded("This pairing was removed", "removed")
if entry.get("send") is not True:
raise LinkEnded("Sending to this machine was switched off", "off")
- if now - self._last_tx >= PING_SECONDS:
+ if self._response_time_enabled:
+ if now >= self._next_response_probe:
+ self._next_response_probe = now + PING_SECONDS
+ self._tick_response_ping()
+ elif now - self._last_tx >= PING_SECONDS:
self._tick_ping()
if now - self._logged_at >= LOG_SECONDS:
self._logged_at = now
@@ -606,7 +687,20 @@ class OutboundLink:
was on this link."""
with self._lock:
period, self._period = self._period, []
+ sent_seq = self._written_seq
+ sent_count = max(0, sent_seq - self._last_logged_sent_seq)
+ self._last_logged_sent_seq = sent_seq
+ pending = len(self._sent_at)
+ oldest = self._sent_at[0] if self._sent_at else None
+ last_acked = self._last_ack_seq
+ if not period and not sent_count:
+ return
if not period:
+ LOGGER.info(
+ "round trip to %s: sent %d, acknowledged 0, oldest unacknowledged seq %d for %.1f s (%d pending, last acked seq %d)",
+ self.peer_name, sent_count, oldest[0] if oldest else sent_seq,
+ max(0.0, self._clock() - oldest[1]) if oldest else 0.0, pending, last_acked,
+ )
return
ordered = sorted(sample for sample, _held in period)
count = len(ordered)
@@ -623,6 +717,21 @@ class OutboundLink:
if not self._enqueue(protocol.ping_msg(), seq=False):
self._ping_queued = False
+ def _tick_response_ping(self):
+ with self._cond:
+ if self._ping_queued:
+ return
+ self._ping_queued = True
+ probe = self._response_time.new_probe()
+ if probe is None or not self._enqueue(protocol.ping_msg(probe=probe), seq=False):
+ self._ping_queued = False
+
+ @property
+ def response_time_ms(self):
+ if not self._live or not self._response_time_enabled:
+ return None
+ return self._response_time.response_time_ms
+
# Sending
def post(self, message):
@@ -631,6 +740,11 @@ class OutboundLink:
if not self._live:
return False
kind = message.get("type")
+ if kind in (protocol.MSG_FOCUS, protocol.MSG_SWITCH) and "displays" not in self._caps:
+ data = dict(message.get("data") or {})
+ data.pop("display", None)
+ data.pop("side", None)
+ message = {"type": kind, "data": data}
if kind == protocol.MSG_CLIPBOARD:
data = dict(message.get("data") or {})
if "clipboard" not in self._caps:
@@ -685,8 +799,6 @@ class OutboundLink:
return
message = self._outbox.popleft()
self._queued_bytes = max(0, self._queued_bytes - _weight(message))
- if message.get("type") == protocol.MSG_PING:
- self._ping_queued = False
self._writing = True
self._last_progress = self._clock()
seq = message.get("data", {}).get("seq")
@@ -696,9 +808,14 @@ class OutboundLink:
with self._lock:
self._written_seq = seq
self._sent_at.append((seq, self._clock()))
+ self._ack_stall_credit[seq] = 0.0
self._check_sent_record()
frame = memoryview(session.seal(message))
sent = 0
+ if message.get("type") == protocol.MSG_PING:
+ probe = (message.get("data") or {}).get("probe")
+ if probe is not None and self._response_time_enabled:
+ self._response_time.sent(probe)
while sent < len(frame):
try:
sent += sock.send(frame[sent:sent + SEND_CHUNK])
@@ -706,6 +823,9 @@ class OutboundLink:
except socket.timeout:
if self._sock is not sock:
return
+ if message.get("type") == protocol.MSG_PING and "echo" not in (message.get("data") or {}):
+ with self._cond:
+ self._ping_queued = False
self._last_tx = self._clock()
self._writing = False
except (OSError, protocol.ProtocolError, ValueError) as exc:
@@ -732,6 +852,7 @@ class OutboundLink:
sent = None
while self._sent_at and self._sent_at[0][0] <= seq:
sent_seq, at = self._sent_at.popleft()
+ self._ack_stall_credit.pop(sent_seq, None)
if sent_seq == seq:
sent = at
if advanced and sent is not None:
diff --git a/core/owner.py b/core/owner.py
index affb952..a43ff81 100644
--- a/core/owner.py
+++ b/core/owner.py
@@ -68,6 +68,8 @@ class Moved:
edge: Optional[str] = None # where to land the pointer, when the move says
offset: Optional[float] = None
other: Optional[object] = None
+ display: Optional[str] = None
+ side: Optional[str] = None
@dataclass(frozen=True)
@@ -104,6 +106,8 @@ class _Wait:
reach: list
edge: Optional[str] = None
offset: Optional[float] = None
+ display: Optional[str] = None
+ side: Optional[str] = None
def _ident(message):
@@ -126,6 +130,7 @@ class Owner:
self.resistance_px = resistance_px # None for a phone, which has no hand at an edge
self.route = 0
self.on = None # the peer this machine's input is on, None at home
+ self._chain = (own_id,)
self.reach_sent = [] # the `reach` last sent there
self._clock = clock
self._visit_route = 0 # the route of the take that began the current visit
@@ -145,6 +150,11 @@ class Owner:
def away(self):
return self.on is not None
+ @property
+ def chain(self):
+ """The active route, including the refusal's named onward machine when there is one."""
+ return self._chain
+
def deadline(self):
times = list(self._left_out.values())
if self._wait is not None:
@@ -191,7 +201,7 @@ class Owner:
# Moves
- def go(self, peer, edge=None, offset=None):
+ def go(self, peer, edge=None, offset=None, display=None, side=None):
if peer is None or peer == self.own_id:
return self._come_home("asked") if self.on is not None else []
if peer == self.on:
@@ -209,10 +219,11 @@ class Owner:
self.route += 1
if left is not None:
actions += self._let_go_of(left, peer)
- actions += self._take(peer, edge, offset, chain=False)
+ actions += self._take(peer, edge, offset, chain=False, display=display, side=side)
self._arrive(peer, self._wait.reach)
+ self._chain = (self.own_id, peer)
actions += self._clipboard_to(peer)
- actions.append(Moved(peer, left, "asked", edge, offset))
+ actions.append(Moved(peer, left, "asked", edge, offset, display=display, side=side))
return actions + self._replay_held()
def switch(self, peer, data):
@@ -220,16 +231,17 @@ class Owner:
return []
route, nxt = data.get("route"), data.get("next")
edge, offset = data.get("edge"), data.get("offset")
+ display, side = data.get("display"), data.get("side")
if nxt == self.own_id:
if not isinstance(route, int) or route < self._visit_route:
return []
- return self._come_home("switch", edge, offset)
+ return self._come_home("switch", edge, offset, display=display, side=side)
if route != self.route or (self._wait is not None and self._wait.chain):
return []
if nxt not in self.reach_sent or nxt not in self._links & self._accepting:
return self._not_taken(nxt, "unreachable")
self.route += 1
- return self._take(nxt, edge, offset, chain=True)
+ return self._take(nxt, edge, offset, chain=True, display=display, side=side)
def accept(self, peer, data):
route = data.get("route")
@@ -245,8 +257,9 @@ class Owner:
left = self.on
actions = self._let_go_of(left, peer)
self._arrive(peer, wait.reach)
+ self._chain = (*self._chain, peer)
actions += self._clipboard_to(peer)
- actions.append(Moved(peer, left, "switch", wait.edge, wait.offset))
+ actions.append(Moved(peer, left, "switch", wait.edge, wait.offset, display=wait.display, side=wait.side))
return actions + self._replay_held() + self._refresh_reach()
if peer == self.on:
return []
@@ -259,12 +272,16 @@ class Owner:
wait = self._wait
if wait is not None and wait.chain:
if peer == wait.peer and route == wait.route:
- return self._not_taken(peer, why, data.get("other"))
+ actions = self._not_taken(peer, why, data.get("other"))
+ self._append_refusal_chain(peer, why, data.get("other"))
+ return actions
return []
# The take's own route too: a re-arm sent before its answer came raised the route past it.
if peer == self.on and (route == self.route or (wait is not None and route == wait.route)):
self._hold_back(peer, why)
- return self._come_home(why, other=data.get("other"))
+ actions = self._come_home(why, other=data.get("other"))
+ self._append_refusal_chain(peer, why, data.get("other"))
+ return actions
return []
def tick(self):
@@ -361,11 +378,13 @@ class Owner:
# The pieces
- def _take(self, peer, edge, offset, chain):
+ def _take(self, peer, edge, offset, chain, display=None, side=None):
reach = self.reach_for(peer)
data = {"route": self.route, "target": peer}
if edge is not None:
data["edge"], data["offset"] = edge, offset
+ if display is not None and side is not None:
+ data["display"], data["side"] = display, side
if self.resistance_px is not None:
data["resistance_px"] = self.resistance_px
data["reach"] = reach
@@ -373,7 +392,7 @@ class Owner:
for route in [route for route, (_, when) in self._takes.items() if now - when > TAKE_MEMORY]:
del self._takes[route]
self._takes[self.route] = (peer, now)
- self._wait = _Wait(peer, self.route, now + TAKE_WAIT, chain, reach, edge, offset)
+ self._wait = _Wait(peer, self.route, now + TAKE_WAIT, chain, reach, edge, offset, display, side)
return [Send(peer, {"type": "focus", "data": data})]
def _arrive(self, peer, reach):
@@ -392,7 +411,7 @@ class Owner:
def _forget_pressed(self, peer):
self._swallow.update(self._pressed.pop(peer, {}))
- def _come_home(self, why, edge=None, offset=None, other=None):
+ def _come_home(self, why, edge=None, offset=None, other=None, display=None, side=None):
left = self.on
if self._wait is not None and not self._wait.chain:
# Never taken: a clipboard sent after the take was dropped there.
@@ -404,8 +423,9 @@ class Owner:
else:
self._forget_pressed(left)
self.on = None
+ self._chain = (self.own_id,)
self.reach_sent = []
- actions.append(Moved(None, left, why, edge, offset, other))
+ actions.append(Moved(None, left, why, edge, offset, other, display, side))
return actions + self._replay_held()
def _abandon(self, unless=None):
@@ -437,6 +457,16 @@ class Owner:
otherwise ask, be refused, and say so."""
self._left_out[peer] = self._clock() + (SENT_HOME_FOR if why == "sent_home" else LEFT_OUT)
+ def _append_refusal_chain(self, peer, why, other):
+ if why not in ("owned", "busy") or peer is None or other is None:
+ return
+ chain = list(self._chain)
+ if not chain or chain[-1] != peer:
+ chain.append(peer)
+ if chain[-1] != other:
+ chain.append(other)
+ self._chain = tuple(chain)
+
def _stay(self):
self.route += 1
self.reach_sent = self.reach_for(self.on)
diff --git a/core/pairing.py b/core/pairing.py
index 466707b..984240b 100644
--- a/core/pairing.py
+++ b/core/pairing.py
@@ -336,6 +336,10 @@ def peer_entry(identity: bytes, name: str, platform: str, port: int, token: str,
}
+def _dormant_repairable(entry: dict) -> bool:
+ return entry.get("dormant") is True
+
+
def _find_known(peers: list, own: bytes, theirs: bytes, name: str, platform: str, now: float) -> tuple:
"""(refused, replaced) for a pairing that proved `theirs`, `name` and `platform`. `refused` is
True when the id is this machine's own and otherwise the entry already holding it, None when
@@ -348,6 +352,8 @@ def _find_known(peers: list, own: bytes, theirs: bytes, name: str, platform: str
for known in peers:
if known.get("id") != wanted:
continue
+ if _dormant_repairable(known):
+ return None, known
if known.get("from_1_4") is True:
return None, known
paired_at = known.get("paired_at")
@@ -544,8 +550,8 @@ class PairingHost:
return self.version == PAIRING_V3
def begin(self) -> str:
- if self.v3 and len(self._peers()) >= MAX_PEERS:
- # A host with 32 peers shows no code: the pairing could not be kept.
+ peers = self._peers()
+ if self.v3 and len(peers) >= MAX_PEERS and not any(_dormant_repairable(peer) for peer in peers):
raise PairingError(ERROR_FULL)
self.code = new_code()
self.pair_id = self._entropy(16).hex()
@@ -616,7 +622,8 @@ class PairingHost:
version = message.get("v")
if not _is_int(version) or version != self.version:
return self._end(MSG_PAIR_ANSWER, sent, pair_id, ERROR_VERSION, "version")
- if self.v3 and len(self._peers()) >= MAX_PEERS:
+ peers = self._peers()
+ if self.v3 and len(peers) >= MAX_PEERS and not any(_dormant_repairable(peer) for peer in peers):
return self._end(MSG_PAIR_ANSWER, sent, pair_id, ERROR_FULL, "full")
try:
nonce = _unb64(message.get("nonce"))
@@ -766,8 +773,8 @@ class PairingClient:
yields the token once the host says it has stored it.
Version 3 also takes this machine's platform and link port, `peers` (a callable giving the
- peer entries), `wall` for `paired_at`, and `qr_secret` when the code was read from a QR. It
- raises PairingError(ERROR_FULL) at once when this machine already has MAX_PEERS peers."""
+ peer entries), `wall` for `paired_at`, and `qr_secret` when the code was read from a QR. Capacity
+ is checked once the host identity is known, so a repair can replace a saved entry."""
def __init__(self, pair_id: str, code: str, name: str, identity: bytes = b"", entropy=secrets.token_bytes,
*, version: int = PAIRING_VERSION, platform: str = "", port: int = 0, qr_secret: bytes = None, peers=None, wall=time.time):
@@ -778,7 +785,8 @@ class PairingClient:
_check_own(identity, platform, port)
if qr_secret is not None and len(qr_secret) != QR_SECRET_BYTES:
raise ValueError("a QR secret is 16 bytes")
- if len(self._peers()) >= MAX_PEERS:
+ peers = self._peers()
+ if len(peers) >= MAX_PEERS and not any(_dormant_repairable(peer) for peer in peers):
raise PairingError(ERROR_FULL)
self.pair_id = pair_id
self.name = name[:MAX_NAME_CHARS]
@@ -869,10 +877,13 @@ class PairingClient:
return {"type": MSG_PAIR_CONFIRM, "pair": self.pair_id, "tag": _b64(requester_tag)}
def _check_host(self, identity: bytes, name: str, platform: str) -> None:
- known, self.replaces = _find_known(self._peers(), self.identity, identity, name, platform, self.wall())
+ peers = self._peers()
+ known, self.replaces = _find_known(peers, self.identity, identity, name, platform, self.wall())
if known is not None:
self._known = True
raise AlreadyPaired(None if known is True else known)
+ if self.replaces is None and len(peers) >= MAX_PEERS:
+ raise PairingError(ERROR_FULL)
def abort(self) -> dict:
"""What to send a host whose answer failed: a confirmation that cannot pass, so the host
@@ -1822,7 +1833,7 @@ class PairingService(Discovery):
# The host's side.
def begin_pairing(self) -> str:
- """Shows a new code, raising PairingError(ERROR_FULL) when this machine has 32 peers."""
+ """Shows a new code; capacity is checked when the requester identity is known."""
with self._host_lock:
self.host.port = self.port_getter()
code = self.host.begin()
@@ -2179,7 +2190,8 @@ class PairingService(Discovery):
def _pair_tcp(self, address: str, port: int, code: str, secret) -> dict:
with self._attempt(code):
- if len(self._peer_entries()) >= MAX_PEERS:
+ peers = self._peer_entries()
+ if len(peers) >= MAX_PEERS and not any(_dormant_repairable(peer) for peer in peers):
raise PairingError(ERROR_FULL)
try:
sock = socket.create_connection((address, port), timeout=TCP_CONNECT_SECONDS)
@@ -2221,7 +2233,8 @@ class PairingService(Discovery):
raise AlreadyPaired(None)
for known in self._peer_entries():
if known.get("id") == identity:
- raise AlreadyPaired(known)
+ if not _dormant_repairable(known):
+ raise AlreadyPaired(known)
def _keep(self, client: PairingClient, address: str) -> dict:
"""The requester writes its entry once Td has checked out. The checks are made again,
diff --git a/core/peerlist.py b/core/peerlist.py
index 456fe0f..358e793 100644
--- a/core/peerlist.py
+++ b/core/peerlist.py
@@ -5,10 +5,34 @@ settings layer calls `add_peer` from `PairingService`'s `store` and `remove_peer
button, each under its own settings lock; neither touches a file.
"""
+import copy
import time
from typing import Optional
-from core import pairing
+from core import pairing, protocol
+
+
+class RefusalThrottle:
+ """One native notice per identical refusal during a sustained crossing attempt."""
+
+ interval = 30.0
+
+ def __init__(self):
+ self._last: dict[str, float] = {}
+
+ def allow(self, message: str, now: Optional[float] = None) -> bool:
+ if not message:
+ return False
+ now = time.monotonic() if now is None else now
+ previous = self._last.get(message)
+ self._last = {text: stamp for text, stamp in self._last.items() if now - stamp < self.interval}
+ if previous is not None and now - previous < self.interval:
+ return False
+ self._last[message] = now
+ return True
+
+ def reset(self) -> None:
+ self._last.clear()
UNNAMED = "Unnamed machine"
TAIL = 4
@@ -54,7 +78,10 @@ def normalise_phones(settings: dict) -> bool:
def _name(entry: dict) -> str:
- return (entry.get("name") or "").strip()
+ label = entry.get("label")
+ label = label.strip()[:64] if isinstance(label, str) else ""
+ name = entry.get("name")
+ return label or (name.strip() if isinstance(name, str) else "")
def labels(peers: list) -> dict:
@@ -90,16 +117,44 @@ def label_for(peers: list, *, token: Optional[str] = None, peer_id: Optional[str
"""`labels()` for one machine, found by its token, its id (`b64`) or its address, in that order of
preference; "" when none matches. What a status or a notice calls a machine, so two of one name
are told apart there as they are in the list."""
- peers = [entry for entry in peers if isinstance(entry, dict) and "token" in entry]
+ peers = [entry for entry in peers if isinstance(entry, dict)]
shown = labels(peers)
for key, value in (("token", token), ("id", peer_id), ("host", host)):
if value:
found = next((entry for entry in peers if entry.get(key) == value), None)
if found is not None:
- return shown[found["token"]]
+ if found.get("port") == 0:
+ return ""
+ return shown.get(found.get("token")) or _name(found) or found.get("host") or ""
return ""
+def dormant_reason(entry: dict) -> Optional[str]:
+ """Why a saved peer needs pairing again, or None when the link has not proved that it is stale."""
+ if entry.get("dormant") is not True:
+ return None
+ reason = entry.get("dormant_reason")
+ return {
+ "wrong_id": "The saved pairing now identifies a different machine.",
+ "forgotten": "The other machine no longer has this pairing.",
+ }.get(reason, "This pairing needs to be set up again.")
+
+
+def paired_ids(peers: list, exclude: Optional[str] = None) -> list:
+ """The valid, live desktop ids listed in a `paired` message, less its receiver."""
+ ids = []
+ for entry in peers:
+ if (not isinstance(entry, dict) or entry.get("port") == 0
+ or entry.get("in_use", True) is False or dormant_reason(entry) is not None):
+ continue
+ ident = entry.get("id")
+ if ident != exclude and protocol.read_id(ident) is not None:
+ ids.append(ident)
+ if len(ids) == protocol.MAX_PEERS:
+ break
+ return ids
+
+
def add_peer(settings: dict, entry: dict, replaced: Optional[dict] = None) -> None:
"""Puts a newly paired `entry` in `settings` (WIRE.md section 6, item 5). `replaced`, an entry
as `peers()` gave it, is dropped by its token and the new one takes its place: the first desktop
@@ -113,7 +168,12 @@ def add_peer(settings: dict, entry: dict, replaced: Optional[dict] = None) -> No
if at is None:
peers.append(entry)
else:
+ old = peers[at]
peers[at] = entry
+ if old.get("id") and old.get("id") == entry.get("id"):
+ for field in ("label", "left_out", "left_out_ways", "side", "side_set_at", "side_by"):
+ if field in old:
+ entry[field] = copy.deepcopy(old[field])
if (replaced is not None and replaced.get("from_1_4") is True and replaced.get("id") == "" and entry.get("id")
and replaced.get("host") and replaced.get("host") == entry.get("host")
and replaced.get("platform") == entry.get("platform")):
@@ -137,6 +197,10 @@ def remove_peer(settings: dict, token: str) -> Optional[dict]:
return None
removed = peers.pop(at)
_drop_orphan_zones(settings)
+ layout = settings.get("layout")
+ if isinstance(layout, dict):
+ from core import ways
+ ways.prune_layout(settings)
return removed
diff --git a/core/protocol.py b/core/protocol.py
index 3c8d7f7..01f9766 100644
--- a/core/protocol.py
+++ b/core/protocol.py
@@ -232,10 +232,34 @@ def recv_frame(sock: socket.socket, limit: int = MAX_FRAME_BYTES, deadline: floa
pass # closed meanwhile by another thread: what the read raised is the news
-def ping_msg() -> dict:
+def ping_msg(probe=None, echo=None) -> dict:
"""Sent by the sender while idle so a dead connection is detected quickly.
- Carries no `seq` and must never be recorded as a processed input event."""
- return {"type": MSG_PING, "data": {}}
+ Carries no `seq` and must never be recorded as a processed input event. Probe fields are
+ optional so older peers retain the original empty ping."""
+ data = {}
+ if probe is not None:
+ data["probe"] = probe
+ if echo is not None:
+ data["echo"] = echo
+ return {"type": MSG_PING, "data": data}
+
+
+def read_ping(message):
+ """Validated optional ping metadata, or None for a different or malformed message."""
+ parsed = read_message(message)
+ if parsed is None or parsed[0] != MSG_PING:
+ return None
+ data = parsed[1]
+ if "probe" in data and "echo" in data:
+ return None
+ result = {}
+ for field in ("probe", "echo"):
+ if field in data:
+ value = data[field]
+ if not _int(value, 1, 2**31 - 1):
+ return None
+ result[field] = value
+ return result
def scroll_msg(dy, dx=0.0, mode: str = "line") -> dict:
@@ -409,6 +433,7 @@ TEXT_MAX_BYTES = 4096
_PLATFORM_SHAPE = re.compile(r"[a-z0-9_]{1,16}")
_HW_SHAPE = re.compile(r"[0-9a-f]{2}(:[0-9a-f]{2}){5}")
+_DISPLAY_KEY = re.compile(r"[A-Za-z0-9_.:-]{1,64}")
_PRINTABLE_ASCII = re.compile(r"[\x20-\x7e]+")
# A lone surrogate can only reach a parsed string through a \u escape: UTF-8 cannot carry one.
_SURROGATE_ESCAPE = re.compile(r"\\u[dD][89a-fA-F]")
@@ -466,6 +491,15 @@ def read_id(text):
return None if ident is None or ident == bytes(MACHINE_ID_SIZE) else ident
+def peer_id_text(ident):
+ """The wire text for a peer id held as bytes by Windows or text by macOS."""
+ if isinstance(ident, str):
+ if read_id(ident) is None:
+ raise ValueError("peer id is not canonical wire text")
+ return ident
+ return id_text(ident)
+
+
def is_paired_token(token) -> bool:
"""Whether `token` has the shape pairing gives: the `b64` of 32 bytes, in its one spelling.
Anything else is a typed token. The shape proves nothing about where a token came from (a
@@ -917,7 +951,8 @@ def wrong_id_v6() -> dict:
return {"type": MSG_WELCOME, "data": {"version": LINK_VERSION, "error": ERROR_WRONG_ID}}
-def focus_v6(route: int, target: bytes, edge: str = None, offset: float = None, resistance_px: int = None, reach=None, stay: bool = False) -> dict:
+def focus_v6(route: int, target: bytes, edge: str = None, offset: float = None, resistance_px: int = None,
+ reach=None, stay: bool = False, display: str = None, side: str = None) -> dict:
"""A `focus`. Leave everything but `route` and `target` out to let go; pass `reach` (and
`resistance_px`) to take, with `edge` and `offset` for a zone, or with `stay` to re-arm."""
data = {"route": route, "target": id_text(target)}
@@ -926,6 +961,11 @@ def focus_v6(route: int, target: bytes, edge: str = None, offset: float = None,
if edge is not None:
data["edge"] = edge
data["offset"] = offset
+ if (display is None) != (side is None):
+ raise ValueError("display and side go together")
+ if display is not None:
+ data["display"] = display
+ data["side"] = side
if resistance_px is not None:
data["resistance_px"] = resistance_px
if reach is not None:
@@ -952,7 +992,7 @@ def read_focus(message, own_id: bytes):
return None
here = target == bytes(own_id)
focus = {"route": route, "target": target, "here": here, "malformed": False, "edge": None, "offset": None,
- "resistance_px": DEFAULT_RESISTANCE_PX, "reach": [], "stay": False}
+ "display": None, "side": None, "resistance_px": DEFAULT_RESISTANCE_PX, "reach": [], "stay": False}
if not here:
return None if getattr(message, "malformed", False) else focus
malformed = getattr(message, "malformed", False)
@@ -964,6 +1004,12 @@ def read_focus(message, own_id: bytes):
focus["edge"], focus["offset"] = data["edge"], _clamp_offset(data["offset"])
else:
malformed = True
+ if "display" in data or "side" in data:
+ display, side = data.get("display"), data.get("side")
+ if isinstance(display, str) and display.isascii() and _DISPLAY_KEY.fullmatch(display) and side in EDGES:
+ focus["display"], focus["side"] = display, side
+ else:
+ malformed = True
if "resistance_px" in data:
if _int(data["resistance_px"], 0, MAX_RESISTANCE_PX):
focus["resistance_px"] = data["resistance_px"]
@@ -1028,13 +1074,19 @@ def read_accepts(message):
return {"accepts": parsed[1]["accepts"]}
-def switch_v6(route: int, next_id: bytes, edge: str = None, offset: float = None) -> dict:
+def switch_v6(route: int, next_id: bytes, edge: str = None, offset: float = None,
+ display: str = None, side: str = None) -> dict:
data = {"route": route, "next": id_text(next_id)}
if (edge is None) != (offset is None):
raise ValueError("edge and offset go together")
if edge is not None:
data["edge"] = edge
data["offset"] = offset
+ if (display is None) != (side is None):
+ raise ValueError("display and side go together")
+ if display is not None:
+ data["display"] = display
+ data["side"] = side
return {"type": MSG_SWITCH, "data": data}
@@ -1051,7 +1103,14 @@ def read_switch(message):
if not _one_of(data.get("edge"), EDGES) or not _number(data.get("offset"), -math.inf, math.inf):
return None
edge, offset = data["edge"], _clamp_offset(data["offset"])
- return {"route": route, "next": next_id, "edge": edge, "offset": offset}
+ display = side = None
+ if "display" in data or "side" in data:
+ display, side = data.get("display"), data.get("side")
+ if (not isinstance(display, str) or not display.isascii() or not _DISPLAY_KEY.fullmatch(display)
+ or side not in EDGES):
+ return None
+ return {"route": route, "next": next_id, "edge": edge, "offset": offset,
+ "display": display, "side": side}
def ack_v6(seq: int, held_us: int, locked: bool = False) -> dict:
diff --git a/core/receiver.py b/core/receiver.py
index 32c08fa..46c6593 100644
--- a/core/receiver.py
+++ b/core/receiver.py
@@ -18,6 +18,7 @@ from typing import Callable, Optional, Tuple
from . import return_edge as crossing
from . import peerlist
from . import protocol
+from .response_time import ResponseTime
LOGGER = logging.getLogger(__name__)
@@ -32,6 +33,8 @@ ACK_IDLE_SECONDS = 0.4
ACK_COALESCE_SECONDS = 0.015
LOCK_CHECK_SECONDS = 0.5
INJECTION_ERROR_STATUS_INTERVAL_SECONDS = 5.0
+SLOW_INJECTION_SECONDS = 0.25
+SLOW_INJECTION_LOG_INTERVAL_SECONDS = 1.0
# Windows hands the port back only when whatever holds it lets go — WinNAT's
# dynamic reservations move on every reboot and can land on ours — so a bind
# that fails is waited out rather than ending the listener.
@@ -189,14 +192,26 @@ def zone_models(zones, peers, allowed, resistance_px: int, notch_span=None) -> l
peer = protocol.read_id(zone.get("peer"))
if peer is None or peer not in allowed or peer not in sides:
continue
- kind, side = zone.get("kind"), sides.get(peer)
+ kind = zone.get("kind")
+ side = zone.get("side", sides.get(peer))
+ display = zone.get("display")
+ target_display = zone.get("target_display")
+ target_side = zone.get("target_side")
+ if display is not None and (not isinstance(display, str) or not display or not display.isascii()):
+ continue
+ if side not in crossing.EDGES and kind in ("edge", "part"):
+ continue
try:
if kind == "edge" and side in crossing.EDGES:
- model = crossing.ReturnEdge(side, resistance_px)
+ model = crossing.ReturnEdge(side, resistance_px, display=display,
+ target_display=target_display, target_side=target_side)
elif kind == "part" and side in crossing.EDGES and isinstance(zone.get("parts"), list):
- model = crossing.PartEdge(side, [part for part in zone["parts"] if isinstance(part, str)], resistance_px)
+ model = crossing.PartEdge(side, [part for part in zone["parts"] if isinstance(part, str)],
+ resistance_px, display=display, target_display=target_display,
+ target_side=target_side)
elif kind == "corner" and isinstance(zone.get("corner"), str) and zone.get("edge") in zone["corner"].split("_"):
- model = crossing.CornerPush(zone["corner"], zone["edge"], resistance_px)
+ model = crossing.CornerPush(zone["corner"], zone["edge"], resistance_px, display=display,
+ target_display=target_display, target_side=target_side)
elif kind == "notch" and notch_span is not None:
model = crossing.SpanEdge("top", notch_span, resistance_px)
else:
@@ -274,6 +289,19 @@ class PeerBook:
entry["paired_with"] = list(ids)
self._save(settings)
+ def mark_dormant(self, token: str, reason: str) -> None:
+ """Persist conclusive evidence that a peer no longer recognises this pairing."""
+ if reason not in ("wrong_id", "forgotten"):
+ raise ValueError("unknown dormant reason")
+ with self.lock:
+ settings = copy.deepcopy(self._load() or {})
+ entry = next((item for item in settings.get("peers") or [] if item.get("token") == token), None)
+ if entry is None or (entry.get("dormant") is True and entry.get("dormant_reason") == reason):
+ return
+ entry["dormant"] = True
+ entry["dormant_reason"] = reason
+ self._save(settings)
+
def find(self, key_id: bytes) -> Optional[dict]:
"""The entry, a copy, whose token (one made by pairing) has `key_id`."""
for entry in self.peers():
@@ -299,8 +327,14 @@ class PeerBook:
if entry.get("in_use", True) is not True:
return IN_USE_OFF, None
before = copy.deepcopy(entry)
+ was_dormant = entry.get("dormant") is True
entry.update(changes)
entry["linked"] = True
+ entry.pop("dormant", None)
+ entry.pop("dormant_reason", None)
+ if was_dormant:
+ from . import ways
+ ways._turn_off_clashes(settings, entry, "this computer")
if entry != before:
self._save(settings)
return ADMITTED, copy.deepcopy(entry)
@@ -312,8 +346,9 @@ class _Link:
the `ack`s when they are due, so nothing that holds the responder's lock ever waits on a
socket."""
- def __init__(self, sock, session, peer_id, key_id, host, name, caps, own_id, own_caps, allow_drive) -> None:
+ def __init__(self, sock, session, peer_id, key_id, host, name, caps, own_id, own_caps, allow_drive, platform="") -> None:
self.sock = sock
+ self.peer_platform = platform # the hello's: the Mac scales a PC's wheel lines by it
self.session = session
self.peer_id = peer_id
self.key_id = key_id
@@ -322,6 +357,9 @@ class _Link:
self.caps = frozenset(caps)
self.own_id = own_id
self.own_caps = frozenset(own_caps)
+ self.response_time_enabled = "ping_rtt" in self.caps and "ping_rtt" in self.own_caps
+ self.response_time = ResponseTime()
+ self.next_response_probe = time.monotonic() + 1.0
self.allow_drive = allow_drive
self.route = 0 # the last route accepted on this link
self.held = {} # ("key" or "button", name): `us`, what the owner holds down here
@@ -334,6 +372,19 @@ class _Link:
self.acked = 0
self.last_ack_at = time.monotonic()
self.input_error_at = float("-inf") # when an injection error last reached the status
+ self.slow_injection_at = float("-inf")
+ self.incoming_moves_at = None
+ self.incoming_move_last_at = None
+ self.incoming_move_count = 0
+ self.incoming_dx = 0
+ self.incoming_dy = 0
+ self.incoming_largest = 0
+
+ @property
+ def response_time_ms(self):
+ if self.closed.is_set() or not self.response_time_enabled:
+ return None
+ return self.response_time.response_time_ms
def post(self, message: dict) -> bool:
with self.cond:
@@ -363,6 +414,7 @@ class _Link:
def _close_locked(self) -> None:
self.closed.set()
+ self.response_time.reset()
self.cond.notify_all()
try:
self.sock.shutdown(socket.SHUT_RDWR)
@@ -522,6 +574,12 @@ class LinkResponder:
link = self._links.get(peer)
return link.caps if link is not None else None
+ def response_time_ms(self, peer_id) -> Optional[int]:
+ """A fresh local round-trip sample for this linked peer, or None."""
+ with self._lock:
+ link = self._links.get(peer_id)
+ return link.response_time_ms if link is not None else None
+
def start(self, port: int) -> None:
with self._lock:
if self._thread is not None and self._thread.is_alive():
@@ -657,6 +715,7 @@ class LinkResponder:
if entry is None:
LOGGER.info("%s named a pairing this machine does not have; closed", host)
return None
+ token = entry["token"]
session = protocol.LinkSession(entry["token"], protocol.ROLE_RESPONDER)
session.accept_preamble(preamble)
deadline = accepted + HANDSHAKE_SECONDS
@@ -686,6 +745,10 @@ class LinkResponder:
return None
if outcome == WRONG_ID:
LOGGER.warning("%s holds a pairing of this machine's under another machine's id", host)
+ try:
+ self._book.mark_dormant(token, "wrong_id")
+ except Exception:
+ LOGGER.exception("Could not save the dormant state for %s", host)
self._answer(connection, host, session.seal(protocol.wrong_id_v6()))
return None
if outcome == IN_USE_OFF:
@@ -699,7 +762,8 @@ class LinkResponder:
except (socket.timeout, protocol.ConnectionClosed, protocol.ProtocolError, OSError) as exc:
LOGGER.info("Handshake with %s ended: %s", host, exc)
return None
- return _Link(connection, session, hello["id"], key_id, host, hello["name"], hello["caps"], own_id, identity["caps"], allow_drive)
+ return _Link(connection, session, hello["id"], key_id, host, hello["name"], hello["caps"], own_id, identity["caps"], allow_drive,
+ hello["platform"])
def _hardware_towards(self, host, identity):
"""The `hw` for the welcome to `host`, as the initiator's hook does for its hello: the hook is
@@ -824,10 +888,16 @@ class LinkResponder:
while True:
if link.closed.is_set():
return
+ now = time.monotonic()
+ if link.response_time_enabled and now >= link.next_response_probe:
+ link.next_response_probe = now + 1.0
+ probe = link.response_time.new_probe()
+ if probe is not None:
+ message = protocol.ping_msg(probe=probe)
+ break
if link.outbox:
message = link.outbox.popleft()
break
- now = time.monotonic()
due = ack_due(link.last_ack_at, link.pending_since)
if now >= due:
seq = link.dealt
@@ -839,12 +909,16 @@ class LinkResponder:
message = protocol.ack_v6(seq, held_us, locked=locked)
is_ack = True
break
+ if link.response_time_enabled:
+ due = min(due, link.next_response_probe)
link.cond.wait(due - now)
try:
# Only this thread sends once the link is up, so sealing and sending need not be
# one step under the session's lock to keep the counters in order.
frame = memoryview(link.session.seal(message))
sent = 0
+ if message.get("type") == protocol.MSG_PING and "probe" in (message.get("data") or {}):
+ link.response_time.sent(message["data"]["probe"])
while sent < len(frame):
sent += link.sock.send(frame[sent:sent + SEND_CHUNK])
except (OSError, protocol.ProtocolError, ValueError) as exc:
@@ -871,6 +945,8 @@ class LinkResponder:
parsed = protocol.read_message(message)
if parsed is not None and "settings" in link.caps:
self._callback("settings", link.peer_id, parsed[1])
+ elif kind == protocol.MSG_PING:
+ self._on_ping(link, message)
elif kind == protocol.MSG_PAIRED:
ids = protocol.read_paired(message)
if ids is not None:
@@ -878,12 +954,26 @@ class LinkResponder:
except Exception:
LOGGER.exception("A %r from %s could not be dealt with", kind, link.name)
+ @staticmethod
+ def _on_ping(link: _Link, message) -> None:
+ if not link.response_time_enabled:
+ return
+ read = protocol.read_ping(message)
+ if read is None:
+ return
+ if "echo" in read:
+ link.response_time.echoed(read["echo"])
+ elif "probe" in read:
+ link.post(protocol.ping_msg(echo=read["probe"]))
+
# Input (sections 3, 4 and 10)
def _on_input(self, link: _Link, message) -> None:
read = protocol.read_input(message)
if read is None:
return
+ if read["type"] == protocol.MSG_MOUSEMOVE:
+ self._record_incoming_move(link, read)
after = []
try:
with self._lock:
@@ -893,9 +983,9 @@ class LinkResponder:
# Input that arrives while the lock screen clears is dropped, but a release of
# something injected before it still goes, or that key stays down after.
if self._releases_held(link, read):
- self._inject_locked(link, read)
+ self._inject_timed_locked(link, read)
elif not (read["type"] == protocol.MSG_MOUSEMOVE and self._zones_locked(link, read, after)):
- self._inject_locked(link, read)
+ self._inject_timed_locked(link, read)
except Exception:
LOGGER.exception("Input from %s could not be injected", link.name)
self._input_error_status(link)
@@ -903,6 +993,24 @@ class LinkResponder:
link.dealt_with(read["seq"])
self._run(after)
+ def _record_incoming_move(self, link: _Link, read: dict) -> None:
+ now = time.monotonic()
+ if link.incoming_moves_at is None or now - link.incoming_move_last_at > 1.0:
+ link.incoming_moves_at = now
+ link.incoming_move_count = link.incoming_dx = link.incoming_dy = link.incoming_largest = 0
+ dx, dy = abs(int(read["dx"])), abs(int(read["dy"]))
+ link.incoming_move_count += 1
+ link.incoming_dx += dx
+ link.incoming_dy += dy
+ link.incoming_largest = max(link.incoming_largest, dx, dy)
+ link.incoming_move_last_at = now
+ if now - link.incoming_moves_at < 1.0:
+ return
+ LOGGER.debug("incoming moves from %s: %d moves, |dx| sum %d, |dy| sum %d, largest %d in the last second",
+ link.name, link.incoming_move_count, link.incoming_dx, link.incoming_dy, link.incoming_largest)
+ link.incoming_moves_at = now
+ link.incoming_move_count = link.incoming_dx = link.incoming_dy = link.incoming_largest = 0
+
def _input_error_status(self, link: _Link) -> None:
"""Says in the status that this peer's input is not being injected, as ReceiverServer did:
at most once per INJECTION_ERROR_STATUS_INTERVAL_SECONDS a link, since a broken injector
@@ -914,6 +1022,30 @@ class LinkResponder:
who = peerlist.label_for(self._settings_now()[0], peer_id=protocol.id_text(link.peer_id)) or link.name
self._set_status(ServerState.CONNECTED, f"Input error from {who}; see log")
+ def _inject_timed_locked(self, link: _Link, read: dict) -> None:
+ began = time.monotonic()
+ try:
+ self._inject_locked(link, read)
+ finally:
+ elapsed = time.monotonic() - began
+ now = time.monotonic()
+ if elapsed >= SLOW_INJECTION_SECONDS and now - link.slow_injection_at >= SLOW_INJECTION_LOG_INTERVAL_SECONDS:
+ link.slow_injection_at = now
+ calls = {
+ protocol.MSG_KEYDOWN: "inject_key",
+ protocol.MSG_KEYUP: "inject_key",
+ protocol.MSG_MOUSEMOVE: "inject_mouse_move",
+ protocol.MSG_MOUSEDOWN: "inject_mouse_button",
+ protocol.MSG_MOUSEUP: "inject_mouse_button",
+ protocol.MSG_SCROLL: "inject_scroll",
+ protocol.MSG_GESTURE: "inject_gesture",
+ protocol.MSG_TEXT: "inject_text",
+ }
+ LOGGER.warning(
+ "slow input injection from %s: %s took %.1f ms in injector.%s",
+ link.name, read["type"], elapsed * 1000, calls.get(read["type"], "unknown"),
+ )
+
@staticmethod
def _releases_held(link: _Link, read: dict) -> bool:
if read["type"] == protocol.MSG_KEYUP:
@@ -959,7 +1091,11 @@ class LinkResponder:
dy, dx = read["dy"], read["dx"]
if self.input_scale is not None:
dy, dx = self.input_scale.wheel(dy, dx)
- injector.inject_scroll(dy, dx, read["mode"])
+ inject_from_peer = getattr(injector, "inject_scroll_from_peer", None)
+ if inject_from_peer is None:
+ injector.inject_scroll(dy, dx, read["mode"])
+ else:
+ inject_from_peer(dy, dx, read["mode"], link.peer_platform)
elif kind == protocol.MSG_GESTURE:
injector.inject_gesture(read["name"])
elif kind == protocol.MSG_TEXT:
@@ -992,13 +1128,22 @@ class LinkResponder:
# The zones (sections 5 and 8)
- def _arm_locked(self, peers, zones) -> None:
+ def _arm_locked(self, peers, zones, arrival_peer=None, landed=False) -> None:
owner = self._owner
if owner is None:
self._armed, self._zones_live = [], False
return
try:
+ previous = self._armed
self._armed = zone_models(zones, peers, {owner.peer_id} | self._reach, self._resistance, self._notch_span)
+ if arrival_peer is None:
+ crossing.keep_grace(previous, self._armed)
+ # A take that lands the pointer on an edge holds every zone, not only the way back: a hand
+ # still moving from the push that brought it here otherwise crossed the zone beside the
+ # landing to a third machine (rc14, 10-10-2026). A take by the shortcut lands nowhere.
+ for peer, model in self._armed:
+ if arrival_peer is not None and (landed or peer == arrival_peer):
+ model.start_grace()
except Exception:
LOGGER.exception("Could not arm the zones for %s", owner.name)
self._armed = []
@@ -1013,14 +1158,17 @@ class LinkResponder:
if not self._armed or self.edges_held():
return False
desktop = self._desktop_module()
+ display_map = getattr(desktop, "display_map", lambda: {})()
monitors, pointer = desktop.monitors(), desktop.cursor_position()
for peer, model in self._armed:
- outcome = model.feed(monitors, pointer, float(read["dx"]), float(read["dy"]))
+ outcome = model.feed(monitors, pointer, float(read["dx"]), float(read["dy"]), display_map=display_map)
if outcome.action == crossing.PASS:
continue
part = None
if isinstance(model, crossing.PartEdge):
- part = crossing.part_of(crossing.display_fraction(monitors, model.edge, pointer))
+ target = display_map.get(model.display) if model.display else None
+ fraction = crossing.edge_offset(target, model.edge, pointer) if isinstance(target, crossing.Rect) else crossing.display_fraction(monitors, model.edge, pointer)
+ part = crossing.part_of(fraction)
elif isinstance(model, crossing.CornerPush):
part = model.corner
if outcome.action == crossing.HOLD:
@@ -1028,10 +1176,24 @@ class LinkResponder:
after.append(lambda: self._callback("pressure", model.edge, outcome.pressure, False, part))
return True
offset = corner_offset(model.corner, model.edge) if isinstance(model, crossing.CornerPush) else outcome.offset
+ # Built before disarming: a switch that cannot be built must not leave this machine with
+ # no way out until the next focus (rc12, 10-10-2026).
+ try:
+ message = protocol.switch_v6(link.route, peer, outcome.edge, offset,
+ display=outcome.display, side=outcome.side)
+ except ValueError:
+ LOGGER.exception("The zone at this machine's %s edge could not name where it leads", model.edge)
+ try:
+ message = protocol.switch_v6(link.route, peer, outcome.edge, offset)
+ except ValueError:
+ LOGGER.exception("The zone at this machine's %s edge could not cross", model.edge)
+ model.armed = True
+ model.reset()
+ return True
self._disarm_locked()
LOGGER.info("The pointer pushed through the zone at this machine's %s edge; asking %s to move its input on",
model.edge, link.name)
- link.post(protocol.switch_v6(link.route, peer, outcome.edge, offset))
+ link.post(message)
after.append(lambda: self._callback("pressure", model.edge, 1.0, True, part))
return True
return False
@@ -1145,7 +1307,7 @@ class LinkResponder:
self._claiming = None
self._reach = frozenset(peer for peer in focus["reach"] if peer not in (link.peer_id, link.own_id))
self._resistance = focus["resistance_px"]
- self._arm_locked(peers, zones)
+ self._arm_locked(peers, zones, link.peer_id if began else None, landed=focus.get("edge") is not None)
after = []
if began:
self._visit += 1
@@ -1296,9 +1458,10 @@ class LinkResponder:
"""A let-go owner gets this machine's clipboard only when something other than its own
`clipboard` messages changed it during the visit, so an idle machine gives nothing away;
and never once another ownership has begun or the clipboard changed while it was read, so
- what it gets is never the next owner's."""
+ what it gets is never the next owner's. Nor when the clipboard could not be read as the
+ visit began (a Wayland session not up yet): what changed during it cannot be told."""
stamp = self._clipboard_stamp()
- if stamp is None or stamp == mark:
+ if stamp is None or mark is None or stamp == mark:
return
try:
text, image = self._clipboard_module().get_contents()
@@ -1328,12 +1491,16 @@ class LinkResponder:
return
desktop = self._desktop_module()
if focus["edge"] is not None:
- x, y = crossing.arrival_position(desktop.monitors(), focus["edge"], focus["offset"])
+ display_map = getattr(desktop, "display_map", lambda: {})()
+ x, y = crossing.arrival_position(desktop.monitors(), focus["edge"], focus["offset"],
+ focus.get("display"), focus.get("side"), display_map)
desktop.set_cursor_position(x, y)
- LOGGER.info("%s's pointer arrived at this machine's %s edge", link.name, focus["edge"])
+ LOGGER.info("%s's pointer arrived at this machine's %s edge", link.name,
+ focus.get("side") if focus.get("display") else focus["edge"])
self._callback("arrival", focus["edge"], x, y)
else:
x, y = desktop.cursor_position()
+ LOGGER.info("%s's input arrived by its shortcut; pointer stays at (%d, %d)", link.name, x, y)
self._callback("arrival", None, x, y)
except Exception:
LOGGER.exception("Could not land %s's pointer", link.name)
diff --git a/core/resistance_strip.py b/core/resistance_strip.py
new file mode 100644
index 0000000..4dbad5a
--- /dev/null
+++ b/core/resistance_strip.py
@@ -0,0 +1,13 @@
+"""Shared coordinate mapping for the Resistance strip's 0–500 pointer-delta scale."""
+
+MAX_RESISTANCE = 500
+TRACK_INSET = 18.0
+
+
+def resistance_x(width: float, value: float, maximum: int = MAX_RESISTANCE,
+ inset: float = TRACK_INSET) -> float:
+ """Map a raw resistance or pressure value onto the strip's shared track."""
+ start = min(max(0.0, float(inset)), max(0.0, float(width)) / 2)
+ end = max(start, float(width) - start)
+ fraction = min(1.0, max(0.0, float(value) / maximum)) if maximum > 0 else 0.0
+ return start + (end - start) * fraction
diff --git a/core/response_time.py b/core/response_time.py
new file mode 100644
index 0000000..e1c5eae
--- /dev/null
+++ b/core/response_time.py
@@ -0,0 +1,63 @@
+"""Local, monotonic round-trip samples carried by optional ping probes."""
+
+import threading
+import time
+
+
+FRESH_SECONDS = 3.0
+_MAX_PROBE_ID = 2**31 - 1
+
+
+class ResponseTime:
+ def __init__(self, clock=time.monotonic):
+ self._clock = clock
+ self._lock = threading.Lock()
+ self._next_id = 0
+ self._pending = None
+ self._sample = None
+
+ def new_probe(self):
+ now = self._clock()
+ with self._lock:
+ if self._pending is not None:
+ if now - self._pending[1] < FRESH_SECONDS:
+ return None
+ self._pending = None
+ self._next_id += 1
+ if self._next_id > _MAX_PROBE_ID:
+ self._next_id = 1
+ return self._next_id
+
+ def sent(self, identifier):
+ now = self._clock()
+ with self._lock:
+ self._pending = (identifier, now)
+
+ def echoed(self, identifier):
+ now = self._clock()
+ with self._lock:
+ pending = self._pending
+ if pending is None or pending[0] != identifier:
+ return False
+ self._pending = None
+ sent_at = pending[1]
+ if now - sent_at > FRESH_SECONDS:
+ return False
+ self._sample = (now, max(0.0, now - sent_at))
+ return True
+
+ @property
+ def response_time_ms(self):
+ with self._lock:
+ if self._sample is None:
+ return None
+ at, elapsed = self._sample
+ if self._clock() - at > FRESH_SECONDS:
+ self._sample = None
+ return None
+ return round(elapsed * 1000)
+
+ def reset(self):
+ with self._lock:
+ self._pending = None
+ self._sample = None
diff --git a/core/return_edge.py b/core/return_edge.py
index 643b7b7..1857db6 100644
--- a/core/return_edge.py
+++ b/core/return_edge.py
@@ -5,7 +5,7 @@ rectangles, the pointer position, each incoming movement delta and a clock, and
answers with what to do — inject the delta, hold the pointer at the edge, or
cross. The model mirrors the Mac's so the two boundaries feel like one:
outward travel at the edge accumulates as pressure, inward travel subtracts,
-time decays it to nothing over DECAY_SECONDS, and at `resistance_px` of net
+time decays it at DECAY_PX_PER_SECOND, and at `resistance_px` of net
outward travel the edge gives.
"""
@@ -17,10 +17,17 @@ EDGES = ("left", "right", "top", "bottom")
OPPOSITE = {"left": "right", "right": "left", "top": "bottom", "bottom": "top"}
DEFAULT_RESISTANCE_PX = 120
DECAY_SECONDS = 0.4
+DECAY_PX_PER_SECOND = DEFAULT_RESISTANCE_PX / DECAY_SECONDS
+ARRIVAL_GRACE_PX = 4
+ARRIVAL_GRACE_SECONDS = 0.3
# How near a corner counts as being in it. The Mac's own engine uses the same
# 8 pixels, and the two boundaries are meant to feel like one.
CORNER_PX = 8
CORNERS = ("top_left", "top_right", "bottom_left", "bottom_right")
+# An arrival lands at least this far from either end of its edge: at the very end it sat in another
+# machine's corner box or on the edge beside it, and the hand still moving sent input on to that
+# machine (rc14, 10-10-2026: a corner crossing landed the Mac on its left edge and went to the PC there).
+LANDING_CLEAR_PX = CORNER_PX + 2
# The thirds of an edge "Part of the edge" may use, top to bottom or left to right. Both machines'
# engines read them through in_parts, so a third means the same stretch on each.
PARTS = ("start", "middle", "end")
@@ -72,6 +79,8 @@ class Outcome:
position: Optional[Tuple[int, int]] = None
edge: Optional[str] = None
offset: Optional[float] = None
+ display: Optional[str] = None
+ side: Optional[str] = None
def _clamp(value, low, high):
@@ -128,39 +137,89 @@ def landing_monitor(monitors: List[Rect], edge: str, along: float) -> Rect:
return min(monitors, key=lambda r: (distance(r), outer(r)))
-def arrival_position(monitors: List[Rect], edge: str, offset: float) -> Tuple[int, int]:
+def arrival_position(monitors: List[Rect], edge: str, offset: float, display=None, side=None,
+ display_map=None) -> Tuple[int, int]:
"""Where a pointer arriving at `edge`, `offset` of the way along it, lands. The fraction is
applied against the whole bounding box, then placed on the monitor `landing_monitor` picks, so
- no arrangement lands it in a gap or on the wrong one of two monitors sharing the edge."""
+ no arrangement lands it in a gap or on the wrong one of two monitors sharing the edge. A valid
+ `display` and `side` pair selects that display's edge, including a seam."""
+ if isinstance(display, str) and side in EDGES and isinstance(display_map, dict):
+ target = display_map.get(display)
+ if isinstance(target, Rect):
+ offset = _clamp(float(offset), 0.0, 1.0)
+ along = round((target.y if side in ("left", "right") else target.x)
+ + offset * ((target.height if side in ("left", "right") else target.width) - 1))
+ if side == "left":
+ return target.x, _clear(along, target.y, target.bottom)
+ if side == "right":
+ return target.right, _clear(along, target.y, target.bottom)
+ if side == "top":
+ return _clear(along, target.x, target.right), target.y
+ return _clear(along, target.x, target.right), target.bottom
bounds = union(monitors)
offset = _clamp(float(offset), 0.0, 1.0)
if edge in ("left", "right"):
along = int(round(bounds.y + offset * bounds.height))
owner = landing_monitor(monitors, edge, along)
x = owner.x if edge == "left" else owner.right
- y = _clamp(along, owner.y, owner.bottom)
+ y = _clear(along, owner.y, owner.bottom)
+ if _covered((x + (-1 if edge == "left" else 1), y), monitors):
+ # Moved in along a staggered neighbour's seam: the wall is the exposed end itself.
+ y = _clamp(along, owner.y, owner.bottom)
else:
along = int(round(bounds.x + offset * bounds.width))
owner = landing_monitor(monitors, edge, along)
y = owner.y if edge == "top" else owner.bottom
- x = _clamp(along, owner.x, owner.right)
+ x = _clear(along, owner.x, owner.right)
+ if _covered((x, y + (-1 if edge == "top" else 1)), monitors):
+ x = _clamp(along, owner.x, owner.right)
return x, y
+def _covered(point, monitors) -> bool:
+ return any(_contains(monitor, point) for monitor in monitors)
+
+
+def _clear(along, low, high):
+ """`along` within [low, high], kept LANDING_CLEAR_PX from both ends where the edge is long enough."""
+ if high - low > 2 * LANDING_CLEAR_PX:
+ return _clamp(along, low + LANDING_CLEAR_PX, high - LANDING_CLEAR_PX)
+ return _clamp(along, low, high)
+
+
+def keep_grace(previous, models) -> None:
+ """[(peer, model)] rebuilt from `previous` (a settings change, a peer starting to accept) keep the
+ arrival grace of the zone each replaces: a re-arm just after a landing must not end it."""
+ def key(peer, model):
+ return peer, type(model), model.edge, getattr(model, "corner", None), model.display
+ held = {key(peer, model): model for peer, model in previous}
+ for peer, model in models:
+ old = held.get(key(peer, model))
+ if old is not None:
+ model._arrival_at, model._arrival_inward = old._arrival_at, old._arrival_inward
+
+
class ReturnEdge:
"""Pressure against one edge of the Windows virtual desktop. Armed by the
Mac on every switch (it sends `return_edge` and `resistance_px`), and
disarmed once a crossing has been sent, so a burst of deltas still in
flight after breakthrough cannot send a second one."""
- def __init__(self, edge: str, resistance_px: int = DEFAULT_RESISTANCE_PX, clock: Callable[[], float] = time.monotonic) -> None:
+ def __init__(self, edge: str, resistance_px: int = DEFAULT_RESISTANCE_PX,
+ clock: Callable[[], float] = time.monotonic, display: str = None,
+ target_display: str = None, target_side: str = None) -> None:
if edge not in EDGES:
raise ValueError(f"unknown edge {edge!r}")
self.edge = edge
+ self.display = display
+ self.target_display = target_display
+ self.target_side = target_side
self.resistance_px = max(0, int(resistance_px))
self._clock = clock
self._travel = 0.0
self._last_at = clock()
+ self._arrival_at = None
+ self._arrival_inward = 0.0
self.armed = True
@property
@@ -169,9 +228,22 @@ class ReturnEdge:
return 1.0 if self._travel > 0 else 0.0
return _clamp(self._travel / self.resistance_px, 0.0, 1.0)
+ def pressure_at(self, now: float) -> float:
+ """Current pressure fraction at `now`, without changing the input model."""
+ if self.resistance_px == 0:
+ return self.pressure
+ elapsed = max(0.0, now - self._last_at)
+ return _clamp((self._travel - self._decay(elapsed)) / self.resistance_px, 0.0, 1.0)
+
def reset(self) -> None:
self._travel = 0.0
self._last_at = self._clock()
+ self._arrival_at = None
+ self._arrival_inward = 0.0
+
+ def start_grace(self) -> None:
+ self._arrival_at = self._clock()
+ self._arrival_inward = 0.0
def _outward(self, dx: float, dy: float) -> float:
if self.edge == "left":
@@ -182,45 +254,75 @@ class ReturnEdge:
return -dy
return dy
- def _at_edge(self, monitors: List[Rect], pointer: Tuple[int, int]) -> bool:
+ def _at_edge(self, monitors: List[Rect], pointer: Tuple[int, int], display_map=None) -> bool:
"""On a monitor, with no monitor one pixel beyond it: the pointer is
against a wall. Testing the bounding box instead made the edge of a
shorter monitor in a staggered arrangement unreachable — for example,
pushing down on a monitor whose bottom stops above its neighbour's
could never reach the edge."""
x, y = pointer
+ target = display_map.get(self.display) if self.display and isinstance(display_map, dict) else None
+ if isinstance(target, Rect):
+ along = target.y <= y <= target.bottom if self.edge in ("left", "right") else target.x <= x <= target.right
+ near = {
+ "left": x <= target.x + 1.5,
+ "right": x >= target.right - 1.5,
+ "top": y <= target.y + 1.5,
+ "bottom": y >= target.bottom - 1.5,
+ }[self.edge]
+ return along and near
step_x, step_y = {"left": (-1, 0), "right": (1, 0), "top": (0, -1), "bottom": (0, 1)}[self.edge]
beyond = (x + step_x, y + step_y)
return any(_contains(m, pointer) for m in monitors) and not any(_contains(m, beyond) for m in monitors)
- def feed(self, monitors: List[Rect], pointer: Tuple[int, int], dx: float, dy: float) -> Outcome:
+ def feed(self, monitors: List[Rect], pointer: Tuple[int, int], dx: float, dy: float, display_map=None) -> Outcome:
bounds = union(monitors)
+ edge_bounds = display_map.get(self.display, bounds) if self.display and isinstance(display_map, dict) else bounds
+ if not isinstance(edge_bounds, Rect):
+ edge_bounds = bounds
+
+ def held_position():
+ x, y = pointer
+ if self.edge in ("left", "right"):
+ return (edge_bounds.x if self.edge == "left" else edge_bounds.right, _clamp(int(y + dy), edge_bounds.y, edge_bounds.bottom))
+ return (_clamp(int(x + dx), edge_bounds.x, edge_bounds.right),
+ edge_bounds.y if self.edge == "top" else edge_bounds.bottom)
+
now = self._clock()
elapsed = max(0.0, now - self._last_at)
self._last_at = now
# Decay runs against the wall clock between deltas, pushing or not. A
# brisk push outruns it; a slow lean on the edge to reach a menu never
# accumulates, which is the whole point of the resistance.
- self._travel = max(0.0, self._travel - self.resistance_px * elapsed / DECAY_SECONDS)
+ self._travel = max(0.0, self._travel - self._decay(elapsed))
if not self.armed:
return Outcome(PASS, self.pressure)
outward = self._outward(dx, dy)
- if outward <= 0 or not self._at_edge(monitors, pointer):
+ if self._arrival_at is not None and outward < 0:
+ self._arrival_inward += -outward
+ in_grace = (self._arrival_at is not None
+ and self._arrival_inward < ARRIVAL_GRACE_PX
+ and now - self._arrival_at < ARRIVAL_GRACE_SECONDS)
+ if outward <= 0 or not self._at_edge(monitors, pointer, display_map):
if outward < 0:
self._travel = max(0.0, self._travel + outward)
return Outcome(PASS, self.pressure)
+ if in_grace:
+ return Outcome(HOLD, self.pressure, position=held_position())
self._travel += outward
if self._travel >= self.resistance_px:
self.armed = False
- offset = edge_offset(bounds, self.edge, pointer)
+ offset = edge_offset(edge_bounds, self.edge, pointer)
self._travel = 0.0
- return Outcome(CROSS, 1.0, edge=OPPOSITE[self.edge], offset=offset)
- x, y = pointer
- if self.edge in ("left", "right"):
- position = (x, _clamp(int(y + dy), bounds.y, bounds.bottom))
- else:
- position = (_clamp(int(x + dx), bounds.x, bounds.right), y)
- return Outcome(HOLD, self.pressure, position=position)
+ # A display and its side go together (WIRE.md section 5), as the Mac's engine sends them.
+ return Outcome(CROSS, 1.0, edge=OPPOSITE[self.edge], offset=offset,
+ display=self.target_display or None,
+ side=(self.target_side or OPPOSITE[self.edge]) if self.target_display else None)
+ return Outcome(HOLD, self.pressure, position=held_position())
+
+ @staticmethod
+ def _decay(elapsed: float) -> float:
+ return DECAY_PX_PER_SECOND * max(0.0, elapsed)
class PartEdge(ReturnEdge):
@@ -228,12 +330,18 @@ class PartEdge(ReturnEdge):
a menu or a dock at one end can sit against it without the pointer ever crossing there. The
thirds are measured along the display the pointer is on, by `display_fraction`."""
- def __init__(self, edge: str, parts, resistance_px: int = DEFAULT_RESISTANCE_PX, clock=time.monotonic) -> None:
- super().__init__(edge, resistance_px, clock)
+ def __init__(self, edge: str, parts, resistance_px: int = DEFAULT_RESISTANCE_PX, clock=time.monotonic,
+ display: str = None, target_display: str = None, target_side: str = None) -> None:
+ super().__init__(edge, resistance_px, clock, display=display, target_display=target_display,
+ target_side=target_side)
self.parts = frozenset(part for part in parts if part in PARTS)
- def _at_edge(self, monitors: List[Rect], pointer: Tuple[int, int]) -> bool:
- return super()._at_edge(monitors, pointer) and in_parts(display_fraction(monitors, self.edge, pointer), self.parts)
+ def _at_edge(self, monitors: List[Rect], pointer: Tuple[int, int], display_map=None) -> bool:
+ if not super()._at_edge(monitors, pointer, display_map):
+ return False
+ target = display_map.get(self.display) if self.display and isinstance(display_map, dict) else None
+ fraction = edge_offset(target, self.edge, pointer) if isinstance(target, Rect) else display_fraction(monitors, self.edge, pointer)
+ return in_parts(fraction, self.parts)
class SpanEdge(ReturnEdge):
@@ -246,10 +354,10 @@ class SpanEdge(ReturnEdge):
super().__init__(edge, resistance_px, clock)
self.span = span
- def _at_edge(self, monitors: List[Rect], pointer: Tuple[int, int]) -> bool:
+ def _at_edge(self, monitors: List[Rect], pointer: Tuple[int, int], display_map=None) -> bool:
span = self.span()
along = pointer[0] if self.edge in ("top", "bottom") else pointer[1]
- return span is not None and super()._at_edge(monitors, pointer) and span[0] <= along <= span[1]
+ return span is not None and super()._at_edge(monitors, pointer, display_map) and span[0] <= along <= span[1]
class CornerPush(ReturnEdge):
@@ -263,10 +371,13 @@ class CornerPush(ReturnEdge):
crossing arrives where an edge crossing would, at the end of that edge the
corner sits at."""
- def __init__(self, corner: str, edge: str, resistance_px: int = DEFAULT_RESISTANCE_PX, clock=time.monotonic) -> None:
+ def __init__(self, corner: str, edge: str, resistance_px: int = DEFAULT_RESISTANCE_PX,
+ clock=time.monotonic, display: str = None, target_display: str = None,
+ target_side: str = None) -> None:
if corner not in CORNERS:
raise ValueError(f"unknown corner {corner!r}")
- super().__init__(edge, resistance_px, clock)
+ super().__init__(edge, resistance_px, clock, display=display, target_display=target_display,
+ target_side=target_side)
self.corner = corner
self.vertical, self.horizontal = corner.split("_")
@@ -278,13 +389,15 @@ class CornerPush(ReturnEdge):
inward = (min(0.0, out_x) ** 2 + min(0.0, out_y) ** 2) ** 0.5
return -inward
- def _at_edge(self, monitors: List[Rect], pointer: Tuple[int, int]) -> bool:
+ def _at_edge(self, monitors: List[Rect], pointer: Tuple[int, int], display_map=None) -> bool:
"""In the corner's own box, and against at least one of its two walls.
The box is measured on the monitor the pointer is on, for the same
reason the edge test is: on a staggered arrangement the bounding box
has corners no display reaches."""
x, y = pointer
- home = next((m for m in monitors if _contains(m, pointer)), None)
+ home = display_map.get(self.display) if self.display and isinstance(display_map, dict) else None
+ if not isinstance(home, Rect):
+ home = next((m for m in monitors if _contains(m, pointer)), None)
if home is None:
return False
near_x = x <= home.x + CORNER_PX if self.horizontal == "left" else x >= home.right - CORNER_PX
diff --git a/core/settings_sync.py b/core/settings_sync.py
index 0796449..7b230d9 100644
--- a/core/settings_sync.py
+++ b/core/settings_sync.py
@@ -1,4 +1,4 @@
-"""Same on all machines: the Crossing and Design settings every machine keeps in step (WIRE.md section 10).
+"""Same on all machines: selected Crossing, Design, Shortcut and Names groups (WIRE.md section 10).
Pure, with no AppKit and no Qt.
Off by default. While it is on, a change to a shared setting at any machine is sent to every peer
@@ -18,8 +18,7 @@ settings, so the adapters read and write it there.
Never shared, whatever the switch says: zones (the ways, thirds and corner), `side`, the direction
switches, the Mac's notch way in and notch look, the haptics, whether crossings animate on each
-screen, whether a full-screen app holds the edges, appearance, and anything outside the Crossing
-and Design pages.
+screen, whether a full-screen app holds the edges, appearance, and per-system keyboard mapping.
"""
import base64
@@ -37,8 +36,13 @@ LENGTHS = tuple(value for value, _name in effects.LENGTHS)
# Keys a trigger cannot be, beside characters and media keys, which the receiver's own table rejects.
NOT_TRIGGERS = ("browser_back", "browser_forward", "backspace", "tab", "enter", "esc", "space", "print_screen")
-CROSSING_KEYS = ("resistance_px", "block_while_dragging", "shortcut", "trigger_key", "trigger_style", "double_tap_ms")
-DESIGN_KEYS = ("glow_style", "glow_colour", "effect_length", "effect_size", "shortcut_arrival", "shortcut_arrival_style")
+CROSSING_KEYS = ("resistance_px", "block_while_dragging", "shortcut", "trigger_key", "shortcut_goes_to", "trigger_style", "double_tap_ms")
+SHORTCUT_KEYS = ("shortcut", "trigger_key", "shortcut_goes_to", "trigger_style", "double_tap_ms")
+CROSSING_GROUP_KEYS = ("resistance_px", "block_while_dragging")
+DESIGN_KEYS = ("glow_style", "glow_colour", "effect_length", "effect_size", "effect_pace",
+ "effect_size_fraction", "shortcut_arrival", "shortcut_arrival_style")
+GROUP_KEYS = {"crossing": CROSSING_GROUP_KEYS, "design": DESIGN_KEYS, "shortcut": SHORTCUT_KEYS, "names": ()}
+ALL_GROUPS = tuple(GROUP_KEYS)
DESIGN_UNAVAILABLE = "Design not available yet: connect to this machine with Beamer 1.5.0 beta.6 or later."
NEEDS_DESIGN_SYNC = "Needs beta.6 or later"
OLD_PEER_NOTE = "A connected machine is unavailable until it has beta.6 or later."
@@ -46,14 +50,127 @@ NO_MACHINE_CONNECTED = "No paired machine is connected."
MAX_STAMP = 2 ** 53 - 2
DAY = 24 * 60 * 60
+SNAPSHOT_TTL = 30 * DAY
+
+
+def normalise_groups(groups):
+ """Known groups in the wire's stable order, ignoring unknown future groups."""
+ if not isinstance(groups, (list, tuple, set)) or any(not isinstance(group, str) for group in groups):
+ return ()
+ selected = set(groups)
+ return tuple(group for group in ALL_GROUPS if group in selected)
+
+
+def groups_for_choice(groups):
+ selected = normalise_groups(groups)
+ return ALL_GROUPS if "everything" in groups else selected
+
+
+def group_on(config, group):
+ return config.same_on_both and group in normalise_groups(config.same_groups)
+
+
+def _message_groups(data, current_groups=None):
+ if "groups" not in data:
+ if current_groups is None:
+ return ALL_GROUPS
+ # A peer from before groups (1.5.1) turning Same on while none is chosen here means every
+ # group, as turning it on here does; kept empty, this end went on sharing nothing.
+ return normalise_groups(current_groups) or (ALL_GROUPS if data.get("on") is True else ())
+ groups = data.get("groups")
+ if not isinstance(groups, list) or any(not isinstance(group, str) or group not in ALL_GROUPS for group in groups):
+ return None
+ return normalise_groups(groups)
+
+
+def arrival_groups(data, current_groups):
+ """Selected groups in an accepted message, retaining local selection for legacy peers."""
+ return _message_groups(data, current_groups)
+
+
+def same_snapshot(groups, values, now=None, value_groups=None, names=None):
+ selected = normalise_groups(groups)
+ included = selected if value_groups is None else normalise_groups(value_groups)
+ keys = {key for group in included for key in GROUP_KEYS[group]}
+ snapshot = {"groups": list(selected), "values": {key: values[key] for key in keys if key in values},
+ "saved_at": int(time.time() if now is None else now)}
+ if names is not None:
+ snapshot["names"] = names
+ return snapshot
+
+
+def snapshot_available(snapshot, now=None):
+ if (not isinstance(snapshot, dict) or type(snapshot.get("saved_at")) is not int
+ or not isinstance(snapshot.get("groups"), list)
+ or any(group not in ALL_GROUPS for group in snapshot["groups"])
+ or not isinstance(snapshot.get("values"), dict)
+ or any(key not in CROSSING_KEYS + DESIGN_KEYS for key in snapshot["values"])):
+ return False
+ names = snapshot.get("names", {})
+ if (not isinstance(names, dict) or any(
+ not isinstance(value, dict) or not isinstance(value.get("label"), str)
+ or type(value.get("set_at")) is not int or not isinstance(value.get("by"), str)
+ for value in names.values())):
+ return False
+ current = int(time.time() if now is None else now)
+ return 0 <= current - snapshot["saved_at"] <= SNAPSHOT_TTL
+
+
+def restore_snapshot(snapshot, now=None):
+ if (not snapshot_available(snapshot, now) or not isinstance(snapshot.get("groups"), list)
+ or not isinstance(snapshot.get("values"), dict)
+ or "names" in snapshot and not isinstance(snapshot["names"], dict)):
+ return None
+ result = {"groups": list(normalise_groups(snapshot["groups"])),
+ "values": {} if snapshot.get("selection_only") else dict(snapshot["values"])}
+ if "names" in snapshot:
+ result["names"] = dict(snapshot["names"])
+ return result
+
+
+def snapshot_for_arrival(data, held_stamp, trigger_keys, by_here, current_groups, current_values, now=None,
+ applied_values=None, merged=None):
+ """The pre-update copy to save for an accepted update, or None when it changes no local values.
+ `merged` is `merge`'s result: its values may be taken while the whole state is not newer."""
+ current_groups = normalise_groups(current_groups)
+ if merged is not None:
+ on, incoming_values, groups = merged["on"], merged["values"], normalise_groups(merged["groups"])
+ if applied_values is not None:
+ incoming_values = applied_values
+ applies = groups
+ else:
+ taken = arrived(data, held_stamp, trigger_keys, by_here=by_here, now=now,
+ current_groups=current_groups)
+ if taken is None:
+ return None
+ on, _stamp, incoming_values = taken
+ if applied_values is not None:
+ incoming_values = applied_values
+ groups = _message_groups(data, current_groups)
+ if groups is None:
+ return None
+ applies = groups if "groups" in data else current_groups
+ changed_values = on and any(current_values.get(key) != value for key, value in incoming_values.items())
+ if not changed_values and groups == current_groups:
+ return None
+ snapshot = same_snapshot(current_groups, current_values, now=now, value_groups=applies)
+ if not changed_values:
+ snapshot["selection_only"] = True
+ return snapshot
+
+
+def revert_groups(snapshot, current_groups):
+ """Value restorations travel under the current policy; selection-only undo restores policy."""
+ return list(normalise_groups(snapshot["groups"] if snapshot.get("selection_only") else current_groups))
# The PC's field for each wire key that is a field of its own; `shortcut` is a way in
# `crossing_methods`.
PC_FIELDS = {
"resistance_px": "crossing_resistance_px", "block_while_dragging": "block_while_dragging",
- "trigger_key": "trigger_key", "trigger_style": "trigger_style", "double_tap_ms": "double_tap_ms",
+ "trigger_key": "trigger_key", "shortcut_goes_to": "shortcut_goes_to",
+ "trigger_style": "trigger_style", "double_tap_ms": "double_tap_ms",
"glow_style": "glow_style", "glow_colour": "glow_colour", "effect_length": "effect_length",
- "effect_size": "effect_size",
+ "effect_size": "effect_size", "effect_pace": "effect_pace", "effect_size_fraction": "effect_size_fraction",
"shortcut_arrival": "shortcut_arrival", "shortcut_arrival_style": "shortcut_arrival_style",
}
# The Mac keeps the shortcut's key at the top of its settings and the rest in `crossing`.
@@ -69,6 +186,8 @@ def _valid(key, value, trigger_keys):
return _whole(value, 0, 500)
if key in ("block_while_dragging", "shortcut", "shortcut_arrival"):
return isinstance(value, bool)
+ if key == "shortcut_goes_to":
+ return value in ("last", "next", "ticked")
if key == "trigger_key":
return isinstance(value, str) and value in trigger_keys and value not in NOT_TRIGGERS
if key == "trigger_style":
@@ -83,23 +202,220 @@ def _valid(key, value, trigger_keys):
return value in LENGTHS
if key == "effect_size":
return value in tuple(size for size, _name in effects.SIZES)
+ if key == "effect_pace":
+ return effects.valid_effect_pace(value)
+ if key == "effect_size_fraction":
+ return effects.valid_effect_size_fraction(value)
if key == "shortcut_arrival_style":
return value in effects.SWITCH_STYLES
return False
-def message_data(on, set_at, values=None, by="", design_state=None):
+def message_data(on, set_at, values=None, by="", design_state=None, names=None, layout_state=None, groups=None,
+ stamps=None):
"""What a `settings` message carries: whether it is on, when that or a shared value last
- changed and by which machine (`by`, its id as base64), and while on, the values."""
+ changed and by which machine (`by`, its id as base64), and while on, the values, each value's
+ own stamp when `stamps` (held_stamps) is given, and optional per-machine names. Optional direct
+ Design and layout states keep their own stamps."""
+ selected = None if groups is None else normalise_groups(groups)
data = {"on": bool(on), "set_at": int(set_at), "by": by}
+ if selected is not None:
+ data["groups"] = list(selected)
if on and values is not None:
- data["crossing"] = {key: values[key] for key in CROSSING_KEYS if key in values}
- data["design"] = {key: values[key] for key in DESIGN_KEYS if key in values}
+ crossing = GROUP_KEYS["crossing"] + GROUP_KEYS["shortcut"]
+ data["crossing"] = {key: values[key] for key in crossing if key in values
+ and (selected is None or ("crossing" if key in CROSSING_GROUP_KEYS else "shortcut") in selected)}
+ data["design"] = {key: values[key] for key in DESIGN_KEYS if key in values
+ and (selected is None or "design" in selected)}
+ if stamps is not None:
+ data["stamps"] = {key: [stamps[key][0], stamps[key][1]]
+ for section in ("crossing", "design") for key in data[section] if key in stamps}
if design_state is not None:
data["design_sync"] = design_state
+ if on and names is not None and (selected is None or "names" in selected):
+ data["names"] = names
+ if layout_state is not None:
+ data["layout"] = layout_state
return data
+def names_arrived(data, held, own_id="", now=None, current_groups=None, policy_groups=None):
+ """The newer valid name overrides in a Same-on message, plus this machine's name if included."""
+ groups = _message_groups(data, current_groups) if isinstance(data, dict) else None
+ if (not _valid_envelope(data, now) or not data["on"] or groups is None
+ or policy_groups is not None and "names" not in normalise_groups(policy_groups)
+ or "names" in data and "names" not in groups):
+ return {}, None
+ if not isinstance(data.get("names"), dict):
+ return {}, None
+ held = held if isinstance(held, dict) else {}
+ accepted = {}
+ own_name = None
+ current_time = time.time() if now is None else now
+ for ident, state in data["names"].items():
+ ident_bytes = _id(ident)
+ if ident_bytes is None or len(ident_bytes) != MACHINE_ID_SIZE or not isinstance(state, dict):
+ continue
+ label = state.get("label")
+ set_at = state.get("set_at")
+ by = state.get("by")
+ author = _id(by)
+ if not isinstance(label, str):
+ continue
+ label = label.strip()
+ if (len(label) > 64 or type(set_at) is not int or author is None
+ or len(author) != MACHINE_ID_SIZE
+ or not 0 <= set_at <= MAX_STAMP or set_at > current_time + DAY):
+ continue
+ entry = {"label": label, "set_at": set_at, "by": by}
+ previous = held.get(ident)
+ previous_at = previous.get("set_at", 0) if isinstance(previous, dict) else 0
+ previous_by = _id(previous.get("by", "")) if isinstance(previous, dict) else b""
+ if type(previous_at) is not int or previous_at < 0 or previous_at > MAX_STAMP:
+ previous_at, previous_by = 0, b""
+ if previous_by is None:
+ previous_by = b""
+ if set_at > previous_at or (set_at == previous_at and author > previous_by):
+ accepted[ident] = entry
+ if ident == own_id:
+ own_name = entry["label"]
+ return accepted, own_name
+
+
+def names_from_settings(settings):
+ """The names this machine can announce, including peers whose labels are still empty."""
+ own_id = settings.get("machine_id", "")
+ names = {}
+ if own_id:
+ own_stamp = settings.get("name_set_at", 0)
+ names[own_id] = {"label": settings.get("name", ""),
+ "set_at": own_stamp,
+ "by": (settings.get("name_by") or own_id) if own_stamp else own_id}
+ for entry in settings.get("peers", []):
+ ident = entry.get("id")
+ if ident:
+ label_stamp = entry.get("label_set_at", 0)
+ names[ident] = {"label": entry.get("label", ""),
+ "set_at": label_stamp,
+ "by": (entry.get("label_by") or own_id) if label_stamp else own_id}
+ return names
+
+
+def apply_names(settings, updates):
+ """Keep accepted name stamps and values in the settings dict; return whether anything changed."""
+ changed = False
+ own_id = settings.get("machine_id", "")
+ for ident, state in updates.items():
+ if ident == own_id:
+ fields = (("name", state["label"]), ("name_set_at", state["set_at"]), ("name_by", state["by"]))
+ target = settings
+ else:
+ target = next((entry for entry in settings.get("peers", []) if entry.get("id") == ident), None)
+ if target is None:
+ continue
+ fields = (("label", state["label"]), ("label_set_at", state["set_at"]), ("label_by", state["by"]))
+ for key, value in fields:
+ if target.get(key) != value:
+ target[key] = value
+ changed = True
+ return changed
+
+
+def restamp_names(settings, updates, by, now=None):
+ """Names restored locally need newer per-entry stamps so peers accept the restoration."""
+ held = names_from_settings(settings)
+ stamp_now = time.time() if now is None else now
+ result = {}
+ for ident, state in updates.items():
+ previous = held.get(ident, {})
+ result[ident] = {"label": state["label"],
+ "set_at": next_stamp(previous.get("set_at", 0), stamp_now), "by": by}
+ return result
+
+
+def read_layout_state(data, now=None):
+ """A validated independently stamped shared tile picture and display geometry, or None when malformed."""
+ if not _valid_envelope(data, now):
+ return None
+ state = data.get("layout")
+ if not isinstance(state, dict) or type(state.get("set_at")) is not int or _id(state.get("by", "")) is None:
+ return None
+ stamp = state["set_at"]
+ if stamp < 0 or stamp > MAX_STAMP or stamp > (time.time() if now is None else now) + DAY:
+ return None
+ tiles = state.get("tiles")
+ if not isinstance(tiles, dict) or not tiles or len(tiles) > MAX_PEERS + 1:
+ return None
+ accepted = {}
+ for machine, tile in tiles.items():
+ ident = _id(machine)
+ if not machine or ident in (None, b"") or not any(ident) or not isinstance(tile, dict):
+ return None
+ if any(type(tile.get(key)) is not int for key in ("x", "y", "w", "h")) or tile["w"] < 1 or tile["h"] < 1:
+ return None
+ accepted_tile = {key: tile[key] for key in ("x", "y", "w", "h")}
+ if "name" in tile:
+ if isinstance(tile["name"], str) and tile["name"].strip() and len(tile["name"]) <= 64:
+ accepted_tile["name"] = tile["name"].strip()
+ if "displays" in tile:
+ screens = tile["displays"]
+ if not isinstance(screens, dict) or not screens or len(screens) > 16:
+ return None
+ accepted_screens = {}
+ for key, rect in screens.items():
+ if (not isinstance(key, str) or not key.isascii() or not 1 <= len(key) <= 64
+ or not isinstance(rect, dict)
+ or any(type(rect.get(name)) is not int for name in ("x", "y", "w", "h"))
+ or rect["w"] < 1 or rect["h"] < 1):
+ return None
+ accepted_screens[key] = {name: rect[name] for name in ("x", "y", "w", "h")}
+ accepted_tile["displays"] = accepted_screens
+ offsets = tile.get("display_offsets", {})
+ if (not isinstance(offsets, dict) or len(offsets) > 16
+ or any(key not in accepted_screens or not isinstance(offset, dict)
+ or type(offset.get("x")) is not int or type(offset.get("y")) is not int
+ for key, offset in offsets.items())):
+ return None
+ if offsets:
+ accepted_tile["display_offsets"] = {
+ key: {"x": offset["x"], "y": offset["y"]} for key, offset in offsets.items()
+ }
+ elif tile.get("display_offsets"):
+ return None
+ accepted[machine] = accepted_tile
+ return {"set_at": stamp, "by": state.get("by", ""), "tiles": accepted}
+
+
+def layout_arrived(state, set_at_here, by_here=""):
+ """Whether a validated shared tile picture is newer than the one held locally."""
+ if not isinstance(state, dict) or _id(state.get("by", "")) is None or type(state.get("set_at")) is not int:
+ return False
+ return (state["set_at"] > int(set_at_here or 0) or
+ (state["set_at"] == int(set_at_here or 0) and _id(state["by"]) > (_id(by_here) or b"")))
+
+
+def layout_recipients(peers, source=None):
+ """Linked peers that advertise both settings and the shared layout capability."""
+ return [peer for peer, capabilities in peers.items()
+ if peer != source and "settings" in capabilities and "layout" in capabilities]
+
+
+def for_capabilities(data, capabilities):
+ """Drop optional settings members a peer did not advertise support for."""
+ result = dict(data)
+ if "layout" not in capabilities:
+ result.pop("layout", None)
+ elif "displays" not in capabilities and isinstance(result.get("layout"), dict):
+ layout = dict(result["layout"])
+ tiles = layout.get("tiles")
+ if isinstance(tiles, dict):
+ layout["tiles"] = {machine: {key: value for key, value in tile.items()
+ if key not in ("displays", "display_offsets")}
+ if isinstance(tile, dict) else tile for machine, tile in tiles.items()}
+ result["layout"] = layout
+ return result
+
+
def read_design_state(data, trigger_keys, now=None):
"""A directly advertised local Design state from a settings message, or None if absent or
invalid. Each supported value stands alone, as for Same on all machines. The outer settings
@@ -120,8 +436,7 @@ def read_design_state(data, trigger_keys, now=None):
return None
accepted = {key: values[key] for key in DESIGN_KEYS
if key in values and _valid(key, values[key], trigger_keys)}
- if "effect_size" not in values:
- accepted["effect_size"] = "medium"
+ _normalise_design(accepted, default_size="effect_size" not in values)
result = {"set_at": set_at, "by": by, "values": accepted}
if "path" in state:
path = state["path"]
@@ -160,9 +475,7 @@ def followed_design(current, state, source, follower, same_on, set_at_here, by_h
if not force and not design_arrived(state, set_at_here, by_here):
return None
values = dict(current)
- for key in DESIGN_KEYS:
- if key in state["values"]:
- values[key] = state["values"][key]
+ values.update(_with_continuous({key: value for key, value in state["values"].items() if key in DESIGN_KEYS}))
changed = any(current.get(key) != values.get(key) for key in DESIGN_KEYS)
result = {"changed": changed, "values": values, "set_at": state["set_at"], "by": state["by"]}
if own_id:
@@ -221,7 +534,7 @@ def design_change_stamp(current, incoming, set_at_here, source_state, own_id, no
"""A Same-on Design change announced as this machine's direct state, or None if unchanged."""
if not isinstance(current, dict) or not isinstance(incoming, dict):
return None
- if not any(current.get(key) != incoming.get(key) for key in DESIGN_KEYS):
+ if not any(key in incoming and current.get(key) != incoming[key] for key in DESIGN_KEYS):
return None
held = int(set_at_here or 0)
if isinstance(source_state, dict) and type(source_state.get("set_at")) is int:
@@ -230,21 +543,26 @@ def design_change_stamp(current, incoming, set_at_here, source_state, own_id, no
return {"set_at": stamp, "by": own_id}
-def read(data, trigger_keys, now=None):
+def read(data, trigger_keys, now=None, current_groups=None):
"""(on, set_at, values) from a `settings` message's data, or None when it is not one. A value
this end cannot hold -- a key it does not have, an effect it does not know, a zone -- is left
out rather than failing the rest. Never raises: a malformed message must not take a link down."""
if not _valid_envelope(data, now):
return None
set_at = data["set_at"]
+ selected = arrival_groups(data, current_groups)
+ if selected is None:
+ return None
values = {}
for group, keys in (("crossing", CROSSING_KEYS), ("design", DESIGN_KEYS)):
section = data.get(group)
if not isinstance(section, dict):
continue
for key in keys:
- if key in section and _valid(key, section[key], trigger_keys):
+ value_group = "shortcut" if group == "crossing" and key in SHORTCUT_KEYS else group
+ if value_group in selected and key in section and _valid(key, section[key], trigger_keys):
values[key] = section[key]
+ _normalise_design(values)
return data["on"], set_at, values
@@ -277,6 +595,17 @@ def _valid_envelope(data, now=None):
and set_at <= (time.time() if now is None else now) + DAY)
+def _normalise_design(values, default_size=False):
+ if "effect_pace" in values or "effect_length" in values:
+ pace_value, _fraction, length, _size = effects.design_values(
+ values.get("effect_pace"), None, values.get("effect_length"))
+ values.update(effect_pace=pace_value, effect_length=length)
+ if "effect_size_fraction" in values or "effect_size" in values or default_size:
+ _pace, fraction, _length, size = effects.design_values(
+ None, values.get("effect_size_fraction"), size=values.get("effect_size"))
+ values.update(effect_size_fraction=fraction, effect_size=size)
+
+
def next_stamp(held, now):
"""The stamp for a change made here: now, or one past the stamp held if that is not older.
Two changes in one second would otherwise tie and the second be ignored at the other end, and
@@ -284,7 +613,15 @@ def next_stamp(held, now):
return max(int(now), int(held or 0) + 1)
-def arrived(data, set_at_here, trigger_keys, by_here="", now=None):
+def rename_peer(entry, text, by, now=None):
+ """The fields to store for a local rename of a paired machine."""
+ now = time.time() if now is None else now
+ return {"label": text.strip()[:64],
+ "label_set_at": next_stamp(entry.get("label_set_at", 0), now),
+ "label_by": by}
+
+
+def arrived(data, set_at_here, trigger_keys, by_here="", now=None, current_groups=None):
"""What to do with a `settings` message that arrived: (on, set_at, values) to take in place of
this end's state, or None to keep it -- malformed, a stamp more than a day ahead of `now` or
above 2^53 - 2, or no newer than what is held here.
@@ -292,7 +629,7 @@ def arrived(data, set_at_here, trigger_keys, by_here="", now=None):
Newer is a higher stamp, or the same stamp and the larger `by` as bytes; `by_here` is the id
that made the change this end holds. Equal in both is the copy that arrives over a second
link, and changes nothing, so a state sent on never comes back round."""
- read_back = read(data, trigger_keys, now)
+ read_back = read(data, trigger_keys, now, current_groups)
by = _id(data.get("by", "")) if read_back is not None else None
if read_back is None or by is None:
return None
@@ -305,6 +642,108 @@ def arrived(data, set_at_here, trigger_keys, by_here="", now=None):
return None
+# Each shared value's own stamp, (set_at, by), since 1.5.2 (WIRE.md section 10, "stamps"): an edit
+# carries only what a person changed, so values a machine missed or never set no longer ride along
+# with someone's edit and overwrite real choices everywhere (rc14, 10-10-2026).
+STAMPED_KEYS = CROSSING_KEYS + DESIGN_KEYS
+
+
+def _stamp_pair(value, now=None):
+ """(set_at, by) from a stored or sent `[set_at, by]`, or None when it is not one."""
+ if not isinstance(value, (list, tuple)) or len(value) != 2:
+ return None
+ set_at, by = value
+ if (type(set_at) is not int or not 0 <= set_at <= MAX_STAMP
+ or set_at > (time.time() if now is None else now) + DAY or _id(by) is None):
+ return None
+ return set_at, by
+
+
+def held_stamps(stamps, set_at, by):
+ """Every shared key's (set_at, by) as held here. A key with no stamp of its own takes the whole
+ state's, which is what it meant before 1.5.2: a fresh machine's are (0, ""), so it adopts the
+ group's values and never sends its defaults over anyone's choices."""
+ stamps = stamps if isinstance(stamps, dict) else {}
+ whole = (int(set_at or 0), by if isinstance(by, str) and _id(by) is not None else "")
+ return {key: _stamp_pair(stamps.get(key), now=MAX_STAMP) or whole for key in STAMPED_KEYS}
+
+
+def stored_stamps(stamps):
+ """The stamps as the settings file keeps them, `{key: [set_at, by]}`."""
+ return {key: [set_at, by] for key, (set_at, by) in stamps.items()}
+
+
+def stamp_changes(stamps, before, after, by, floor=0, now=None):
+ """`stamps` with a new stamp on each key whose value differs between `before` and `after`, a
+ change made here by `by`; and that stamp, or None when nothing changed. The stamp is newer than
+ every one held, and than `floor` (the whole state's), as next_stamp makes it."""
+ changed_keys = {key for key in STAMPED_KEYS if key in after and before.get(key) != after.get(key)}
+ # A slider and its preset are one choice: stamped apart, a newer preset held elsewhere pulled a
+ # newer slider back to itself (design_values) and the person's last choice was lost.
+ for pair in (("effect_length", "effect_pace"), ("effect_size", "effect_size_fraction")):
+ if changed_keys & set(pair):
+ changed_keys |= {key for key in pair if key in after}
+ if not changed_keys:
+ return dict(stamps), None
+ top = max([floor or 0] + [set_at for set_at, _by in stamps.values()])
+ stamp = next_stamp(top, time.time() if now is None else now)
+ result = dict(stamps)
+ for key in changed_keys:
+ result[key] = (stamp, by)
+ return result, stamp
+
+
+def _newer(one, other):
+ return one[0] > other[0] or (one[0] == other[0] and (_id(one[1]) or b"") > (_id(other[1]) or b""))
+
+
+def _value_group(key):
+ return "crossing" if key in CROSSING_GROUP_KEYS else "shortcut" if key in SHORTCUT_KEYS else "design"
+
+
+def merge(data, stamps_here, set_at_here, trigger_keys, by_here="", on_here=False, now=None, current_groups=None):
+ """What a `settings` message brings, key by key: None when it is not one, else a dict of
+ `policy` -- (on, set_at, values) as `arrived` gives it when the whole state is newer, which
+ decides on, off and the groups, else None -- `on` and `groups` as they stand after it,
+ `values`, the shared values in those groups whose own stamp is newer than the one held here,
+ none while Same is off, and `stamps`, those keys' stamps.
+
+ A peer from before 1.5.2 sends no stamps: each of its values counts as stamped with its whole
+ state, which is what its state meant, so it behaves as it did against a peer of its own."""
+ read_back = read(data, trigger_keys, now, current_groups)
+ by = _id(data.get("by", "")) if read_back is not None else None
+ if read_back is None or by is None:
+ return None
+ on, set_at, values = read_back
+ if set_at > (time.time() if now is None else now) + DAY:
+ return None
+ policy = arrived(data, set_at_here, trigger_keys, by_here=by_here, now=now, current_groups=current_groups)
+ final_on = policy[0] if policy is not None else bool(on_here)
+ final_groups = (arrival_groups(data, current_groups) if policy is not None
+ else normalise_groups(current_groups or ()))
+ sent = data.get("stamps") if isinstance(data.get("stamps"), dict) else {}
+ whole = (set_at, data.get("by", ""))
+ held = held_stamps(stamps_here, set_at_here, by_here)
+ taken, taken_stamps, answer = {}, {}, False
+ if on and final_on:
+ for key, value in values.items():
+ if _value_group(key) not in final_groups:
+ continue
+ # A value's stamp may be newer than the state it travels in: one changed while its group
+ # was off is stamped then, and the state only when Same next changes.
+ stamp = _stamp_pair(sent.get(key), now) if "stamps" in data else whole
+ if stamp is None:
+ continue
+ if _newer(stamp, held[key]):
+ taken[key], taken_stamps[key] = value, stamp
+ elif _newer(held[key], stamp):
+ answer = True
+ # `answer`: this machine holds a value newer than the sender's, so it sends its own state, or
+ # the sender, having nothing newer to take from the message it sent, would never learn it.
+ return {"policy": policy, "on": final_on, "groups": tuple(final_groups), "values": taken,
+ "stamps": taken_stamps, "answer": answer}
+
+
def recipients(peers, source=None):
"""Whom a state goes to: every peer that lists `settings` among its capabilities, except the
one it came from. `peers` maps a peer's id to its capabilities."""
@@ -328,17 +767,35 @@ def mac_values(raw):
crossing = raw.get("crossing", {})
values = {key: raw[key] if key in MAC_TOP_LEVEL else crossing.get(key)
for key in CROSSING_KEYS + DESIGN_KEYS if key != "shortcut"}
- values["effect_size"] = crossing.get("effect_size", "medium")
+ pace_value, fraction, length, size = effects.design_values(
+ crossing.get("effect_pace"), crossing.get("effect_size_fraction"),
+ crossing.get("effect_length"), crossing.get("effect_size"))
+ values.update(effect_pace=pace_value, effect_size_fraction=fraction,
+ effect_length=length, effect_size=size)
values["shortcut"] = "shortcut" in crossing.get("methods", [])
return _in_order(values)
+def _with_continuous(values):
+ """`values` with the slider fields following a preset that arrives without them, as from a
+ 1.5.0 to 1.5.2 peer: kept as they were, the old pace or fraction would win over the new preset
+ on the next read and the slider would snap back."""
+ values = dict(values)
+ if "effect_length" in values and "effect_pace" not in values:
+ values["effect_pace"] = effects.design_values(length=values["effect_length"])[0]
+ if "effect_size" in values and "effect_size_fraction" not in values:
+ values["effect_size_fraction"] = effects.design_values(size=values["effect_size"])[1]
+ return values
+
+
def apply_mac(raw, values):
"""A copy of the Mac's raw settings with `values` in place. The other ways, the notch among
them, stay as they were: they are this Mac's own zones."""
raw = dict(raw)
crossing = dict(raw.get("crossing", {}))
- for key, value in values.items():
+ for key, value in _with_continuous(values).items():
+ if key not in CROSSING_KEYS and key not in DESIGN_KEYS:
+ continue
if key in MAC_TOP_LEVEL:
raw[key] = value
elif key == "shortcut":
@@ -351,41 +808,71 @@ def apply_mac(raw, values):
def pc_values(config):
"""The shared values in the PC's Config."""
- values = {key: getattr(config, field) for key, field in PC_FIELDS.items()}
- values["effect_size"] = getattr(config, "effect_size", "medium")
+ values = {key: getattr(config, field) for key, field in PC_FIELDS.items()
+ if key not in ("effect_pace", "effect_size_fraction")}
+ values["effect_pace"] = getattr(config, "effect_pace", None)
+ values["effect_size_fraction"] = getattr(config, "effect_size_fraction", None)
+ pace_value, fraction, length, size = effects.design_values(
+ getattr(config, "effect_pace", None), getattr(config, "effect_size_fraction", None),
+ getattr(config, "effect_length", None), getattr(config, "effect_size", None))
+ values.update(effect_pace=pace_value, effect_size_fraction=fraction,
+ effect_length=length, effect_size=size)
values["shortcut"] = "shortcut" in config.crossing_methods
return _in_order(values)
def apply_pc(config, values):
"""Sets `values` on the PC's Config in place."""
- for key, value in values.items():
+ for key, value in _with_continuous(values).items():
+ if key not in CROSSING_KEYS and key not in DESIGN_KEYS:
+ continue
if key == "shortcut":
config.crossing_methods = _with_shortcut(config.crossing_methods, value)
else:
setattr(config, PC_FIELDS[key], value)
-def changed(before, after):
+def changed(before, after, groups=None):
"""Whether any shared value differs between two value dicts."""
- return any(before.get(key) != after.get(key) for key in CROSSING_KEYS + DESIGN_KEYS)
+ keys = CROSSING_KEYS + DESIGN_KEYS if groups is None else tuple(
+ key for group in normalise_groups(groups) for key in GROUP_KEYS[group])
+ return any(before.get(key) != after.get(key) for key in keys)
SHARED_PAGES = ("crossing", "design")
+def group_note(groups, on):
+ if not on:
+ return "Off: each machine keeps its current values."
+ selected = normalise_groups(groups)
+ return "Shares " + ", ".join(group.capitalize() for group in selected) + " with compatible paired machines."
+
+
def who(labels):
"""How the notes name the machines the pages are kept in step with: the one paired machine by its
label, else every paired machine."""
return labels[0] if len(labels) == 1 else "every paired machine"
-def scope(page, who, on, own, platform=""):
+def scope(page, who, on, own, platform="", groups=None):
"""The line under a page's purpose: `own` (the page's usual "for this machine only") unless
the page is kept in step and the switch is on. `who` is from `who()`."""
if on and page in SHARED_PAGES:
+ selected = ALL_GROUPS if groups is None else normalise_groups(groups)
if page == "crossing":
+ if groups is not None and not {"crossing", "shortcut"} <= set(selected):
+ shared = []
+ if "crossing" in selected:
+ shared.extend(("Resistance", "drag protection"))
+ if "shortcut" in selected:
+ shared.append("Shortcut")
+ if not shared:
+ return own
+ return ", ".join(shared) + " stay in step. Ways and jump keys below are local; each side is shared with its paired machine."
return "Resistance, drag protection and Shortcut stay in step. Ways and jump keys below are local; each side is shared with its paired machine."
+ if "design" not in selected:
+ return own
text = "Style, colour, length, size and landing animation stay in step. Animation enable and window appearance stay local."
if platform == "mac":
text += " Notch and trackpad controls stay local."
diff --git a/core/special_keys.py b/core/special_keys.py
new file mode 100644
index 0000000..5079180
--- /dev/null
+++ b/core/special_keys.py
@@ -0,0 +1,59 @@
+"""Cross-platform names for system keys whose physical key differs by OS."""
+
+from core import keytable, protocol
+
+
+def wire_name(physical: str, own_platform: str, peer_platform: str):
+ """Return a safe target intent, the unchanged key name, or None when no target exists."""
+ if own_platform == peer_platform:
+ return physical
+ if own_platform == "macos":
+ if physical == "f13" and peer_platform == "windows":
+ return "print_screen"
+ if peer_platform == "macos" and physical in ("browser_search", "search"):
+ return "spotlight"
+ return physical
+
+
+def windows_shortcut_intent(key: str):
+ """The Windows system shortcuts that have safe macOS equivalents."""
+ return {"s": "spotlight", "h": "dictation", "n": ""}.get(key.lower())
+
+
+def switcher_chord(own_platform: str, peer_platform: str, key: str, held_modifiers):
+ """The physical modifier(s) to retarget for a cross-system window switcher chord."""
+ if key != "tab":
+ return None
+ own_mac, peer_mac = keytable.is_mac(own_platform), keytable.is_mac(peer_platform)
+ if own_mac == peer_mac:
+ return None
+ sources, target = (("cmd", "cmd_r"), "alt") if own_mac else (("alt", "alt_r"), "cmd")
+ held = tuple(name for name in sources if name in held_modifiers)
+ return (held, target) if held else None
+
+
+def release_key(physical: str, sent: dict):
+ """Return the wire name to release, unless another physical key still holds it."""
+ name = sent.get(physical)
+ if name is None or any(key != physical and held == name for key, held in sent.items()):
+ return None
+ return name
+
+
+def switcher_transitions(own_platform: str, peer_platform: str, sent: dict):
+ """For a Tab going down towards `peer_platform`: the key messages that first move a held Cmd
+ (from a Mac) or Alt (to a Mac) onto the receiver's window-switcher modifier, and the names those
+ physical keys are held as from then on, so their release lets go of the right key. `sent` maps
+ each physical key held towards that peer to the name it was sent as."""
+ decision = switcher_chord(own_platform, peer_platform, "tab", sent)
+ if decision is None:
+ return [], {}
+ sources, target = decision
+ if all(sent.get(source) == target for source in sources):
+ return [], {}
+ old_names = {sent[source] for source in sources if source in sent}
+ other_names = {name for physical, name in sent.items() if physical not in sources}
+ messages = [{"type": protocol.MSG_KEYUP, "data": {"key": name}} for name in sorted(old_names - other_names)]
+ if target not in other_names:
+ messages.append({"type": protocol.MSG_KEYDOWN, "data": {"key": target}})
+ return messages, {source: target for source in sources}
diff --git a/core/tests/crossing_harness.py b/core/tests/crossing_harness.py
new file mode 100644
index 0000000..0e2c410
--- /dev/null
+++ b/core/tests/crossing_harness.py
@@ -0,0 +1,465 @@
+"""End-to-end crossing: two or three desktops on loopback, each a real responder and a real owner,
+linked as a full mesh with real pairing tokens and handshakes, whose Crossing pages and maps are
+driven as each app drives them, and whose pointers are pushed through every edge and corner.
+
+A desk is one machine:
+- `machine`, its core/receiver.LinkResponder (what another desk's input lands on, and the zones
+ that send a driven pointer onward or home), with a screen of real display rectangles;
+- `hand`, its own keyboard and mouse: core/owner.Owner over one scripted initiator per other desk;
+- `shell`, the app around them (crossing_shells.py): what a map drop, a page edit, an incoming
+ `arrangement` or `settings`, and a link coming up do to the settings and who is told.
+
+A push is decided by the code that decides it in the product: at home, the Mac's
+mac_app/crossing.CrossingEngine or the PC's receiver.zone_models (win_app/sender.py's own path);
+on a driven desk, that desk's responder and its armed zones. Assertions are by effect: which desk
+holds a hand's input, and where the pointer landed on it.
+
+Platform edges only are faked: the injector, the cursor and the clipboard (responder_harness)."""
+
+import copy
+import threading
+import time
+
+from core import owner as owner_module
+from core import protocol, receiver, return_edge
+from core.return_edge import Rect
+from core.tests.responder_harness import FakeDesktop, Initiator, Machine, entry, ident, token, wait_for
+
+try:
+ from mac_app import crossing as mac_crossing
+except ImportError: # pragma: no cover - mac_app/crossing.py is pure and ships in the tree
+ mac_crossing = None
+
+CAPS = ["clipboard", "clipboard_image", "gestures", "media_keys", "text", "settings", "design_sync",
+ "layout", "displays", "ping_rtt"]
+# The way a push goes through each side, and how hard: well past the 120 px resistance.
+PUSH = {"left": (-40, 0), "right": (40, 0), "top": (0, -40), "bottom": (0, 40)}
+PUSHES = 8
+CORNER_PUSH = {"top_left": (-30, -30), "top_right": (30, -30), "bottom_left": (-30, 30),
+ "bottom_right": (30, 30)}
+# The fraction along an edge at the middle of each third.
+THIRD_AT = {"start": 1 / 6, "middle": 0.5, "end": 5 / 6}
+
+
+def key(one, other):
+ """The token one pair shares, whichever end asks."""
+ low, high = sorted((one, other))
+ return token(low[0] * 3 + high[0])
+
+
+def text(peer):
+ return protocol.id_text(peer)
+
+
+class Screen(FakeDesktop):
+ """A desk's displays, keyed as the app keys them (`display_map`)."""
+
+ def __init__(self, displays):
+ self.displays = dict(displays)
+ first = next(iter(self.displays.values()))
+ super().__init__(monitors=list(self.displays.values()),
+ cursor=(first.x + first.width // 2, first.y + first.height // 2))
+
+ def display_map(self):
+ return dict(self.displays)
+
+ def point(self, display, side, along=0.5):
+ """The pixel on `side` of `display`, `along` of the way down or across it."""
+ rect = self.displays[display]
+ if side in ("left", "right"):
+ y = rect.y + min(rect.height - 1, int(along * rect.height))
+ return (rect.x if side == "left" else rect.right, y)
+ x = rect.x + min(rect.width - 1, int(along * rect.width))
+ return (x, rect.y if side == "top" else rect.bottom)
+
+ def corner(self, display, corner):
+ rect = self.displays[display]
+ vertical, horizontal = corner.split("_")
+ return (rect.x if horizontal == "left" else rect.right, rect.y if vertical == "top" else rect.bottom)
+
+ def on_display(self, point):
+ for name, rect in self.displays.items():
+ if rect.x <= point[0] <= rect.right and rect.y <= point[1] <= rect.bottom:
+ return name
+ return None
+
+
+class Hand:
+ """A desk's own keyboard and mouse: every decision core/owner.Owner's, carried out over one
+ initiator per other desk. Messages the app sends (`arrangement`, `settings`) go out on these
+ links too, and the other desk's responder hands them to its shell."""
+
+ def __init__(self, desk):
+ self.desk = desk
+ self.owner = owner_module.Owner(text(desk.own), time.monotonic)
+ self.links = {}
+ self.capabilities = {}
+ self.lock = threading.RLock()
+ self.sent = []
+ self.moved = []
+ self._closed = threading.Event()
+ threading.Thread(target=self._keep_alive, name="hand-pings", daemon=True).start()
+
+ def _keep_alive(self):
+ # core/link.py pings every PING_SECONDS while nothing else is sent; without it the responder
+ # ends a quiet link after LINK_READ_TIMEOUT_SECONDS.
+ from core.link import PING_SECONDS
+ while not self._closed.wait(PING_SECONDS):
+ with self.lock:
+ for link in list(self.links.values()):
+ try:
+ link.send(protocol.ping_msg())
+ except OSError:
+ pass
+
+ def connect(self, other):
+ link = Initiator(other.machine, self.desk.own, key(self.desk.own, other.own))
+ welcome = link.handshake(hello=link.hello(id=self.desk.own, name=self.desk.name,
+ platform=self.desk.platform_name, caps=list(CAPS)))
+ with self.lock:
+ self.links[text(other.own)] = link
+ self.capabilities[text(other.own)] = set(welcome["caps"])
+ self.carry_out(self.owner.link_up(text(other.own), welcome["accepts"]))
+ return link
+
+ def drop(self, other):
+ with self.lock:
+ link = self.links.pop(text(other.own), None)
+ if link is not None:
+ link.close()
+ self.carry_out(self.owner.link_down(text(other.own)))
+
+ def close(self):
+ self._closed.set()
+ for link in list(self.links.values()):
+ link.close()
+
+ def carry_out(self, actions):
+ for action in actions:
+ if isinstance(action, owner_module.Send):
+ message = action.message
+ link = self.links.get(action.peer)
+ if link is None:
+ continue
+ if message["type"] == protocol.MSG_FOCUS:
+ self.sent.append((action.peer, dict(message["data"])))
+ try:
+ if message["type"] in protocol.INPUT_TYPES:
+ link.input(message)
+ else:
+ link.send(message)
+ except OSError:
+ pass
+ elif isinstance(action, owner_module.SendClipboard):
+ link = self.links.get(action.peer)
+ if link is not None:
+ link.send(protocol.clipboard_msg(text="hand's"))
+ elif isinstance(action, owner_module.Moved):
+ self.moved.append(action)
+ if action.to is None and action.edge in return_edge.EDGES and action.offset is not None:
+ screen = self.desk.screen
+ point = return_edge.arrival_position(screen.monitors(), action.edge, action.offset,
+ action.display, action.side, screen.display_map())
+ screen.set_cursor_position(*point)
+ elif isinstance(action, owner_module.Drop):
+ link = self.links.get(action.peer)
+ if link is not None:
+ link.close()
+
+ def send(self, peer, message):
+ """An app message to `peer` (an id text) over this desk's link to it; False with none."""
+ with self.lock:
+ link = self.links.get(peer)
+ if link is None:
+ return False
+ try:
+ link.send(message)
+ except OSError:
+ return False
+ return True
+
+ def pump(self):
+ with self.lock:
+ for peer, link in list(self.links.items()):
+ while not link.inbox.empty():
+ message = link.inbox.get_nowait()
+ kind, data = message.get("type"), message.get("data") or {}
+ if kind == protocol.MSG_SWITCH:
+ self.carry_out(self.owner.switch(peer, data))
+ elif kind == protocol.MSG_ACCEPT:
+ self.carry_out(self.owner.accept(peer, data))
+ elif kind == protocol.MSG_REFUSE:
+ self.carry_out(self.owner.refuse(peer, data))
+ elif kind == protocol.MSG_ACCEPTS:
+ self.carry_out(self.owner.accepts(peer, data.get("accepts")))
+ self.carry_out(self.owner.tick())
+
+ def until(self, predicate, timeout=2.0):
+ deadline = time.monotonic() + timeout
+ while time.monotonic() < deadline:
+ self.pump()
+ if predicate():
+ return True
+ time.sleep(0.003)
+ self.pump()
+ return bool(predicate())
+
+ def go(self, peer, edge=None, offset=None, display=None, side=None):
+ with self.lock:
+ self.carry_out(self.owner.go(peer, edge, offset, display=display, side=side))
+
+ def move(self, dx, dy):
+ with self.lock:
+ self.carry_out(self.owner.input(protocol.mousemove_msg(dx, dy)))
+
+ @property
+ def on(self):
+ return self.owner.on
+
+
+class Desk:
+ """One machine. `platform` is "mac" or "pc"; `displays` maps the app's display keys to their
+ rectangles in its own pixels (points on a Mac)."""
+
+ def __init__(self, net, own, name, platform, displays, tile=(160, 100)):
+ self.net = net
+ self.own = own
+ self.id = text(own)
+ self.name = name
+ self.platform = platform
+ self.platform_name = "macos" if platform == "mac" else "windows"
+ self.screen = Screen(displays)
+ self.tile_size = tile
+ self.lock = threading.RLock()
+ self.machine = Machine([], [], caps=CAPS, desktop=self.screen, own=own, name=name)
+ self.machine.settings.data.update({"layout": {}, "layout_set_at": 0, "layout_by": "",
+ "same_on_both": False})
+ self.machine.book = receiver.PeerBook(self.machine.settings.load, self.machine.settings.save, self.lock)
+ self.machine.responder._book = self.machine.book
+ self.hand = Hand(self)
+ self.shell = None
+ self.started = False
+
+ # The settings, as the app holds them.
+
+ @property
+ def settings(self):
+ return self.machine.settings.data
+
+ def save(self, settings):
+ with self.lock:
+ self.machine.settings.save(settings)
+
+ def peer(self, other):
+ return next((item for item in self.settings["peers"] if item["id"] == other.id), None)
+
+ # What this desk's own hand does at home.
+
+ def own_models(self):
+ """The ways out of this desk's own screen as its app arms them: [(peer id text, push)]."""
+ settings = copy.deepcopy(self.settings)
+ ready = {peer for peer in self.hand.owner.reach_for(None)}
+ if self.platform == "mac":
+ peers = [item for item in settings["peers"] if item.get("id") in ready]
+ engine = mac_crossing.CrossingEngine.from_zones(
+ {"resistance_px": 120, "block_while_dragging": True}, settings["zones"], peers)
+ return ("mac", engine)
+ allowed = {protocol.read_id(peer) for peer in ready}
+ return ("pc", receiver.zone_models(settings["zones"], settings["peers"], allowed, 120, None))
+
+ def push_home(self, point, delta):
+ """This desk's own pointer at `point`, pushed by `delta` until something gives. The peer
+ id it crossed to, or None."""
+ kind, models = self.own_models()
+ self.screen.cursor = point
+ if kind == "mac":
+ displays = [(rect.x, rect.y, rect.x + rect.width, rect.y + rect.height)
+ for rect in self.screen.displays.values()]
+ union = return_edge.union(self.screen.monitors())
+ bounds = (union.x, union.y, union.x + union.width, union.y + union.height)
+ now = time.monotonic()
+ x, y = point
+ # The Mac's event tap sees the pointer pinned at the wall and the delta beyond it.
+ for index in range(PUSHES * 2):
+ step = models.feed(x, y, delta[0], delta[1], bounds, now + index * 0.004, displays=displays,
+ ready=lambda peer: True)
+ if step is not None and step.crossed:
+ self.hand.go(step.peer, step.edge, step.offset, display=step.display, side=step.side)
+ return step.peer
+ return None
+ monitors, display_map = self.screen.monitors(), self.screen.display_map()
+ for _ in range(PUSHES * 2):
+ for peer, model in models:
+ outcome = model.feed(monitors, point, delta[0], delta[1], display_map=display_map)
+ if outcome.action == return_edge.CROSS:
+ offset = (receiver.corner_offset(model.corner, model.edge)
+ if isinstance(model, return_edge.CornerPush) else outcome.offset)
+ # win_app/sender.py's own crossing, display and side included.
+ self.hand.go(protocol.id_text(peer), outcome.edge, offset, display=outcome.display,
+ side=outcome.side)
+ return protocol.id_text(peer)
+ return None
+
+
+class Net:
+ """The desks, all paired with each other. `test` owns their cleanup."""
+
+ def __init__(self, test, shells):
+ self.test = test
+ self.desks = {}
+ self.shells = shells
+
+ def add(self, name, platform, displays, seed, tile=(160, 100)):
+ desk = Desk(self, ident(seed), name, platform, displays, tile)
+ desk.shell = self.shells[platform](desk)
+ self.test.addCleanup(desk.shell.stop)
+ self.desks[name] = desk
+ return desk
+
+ def pair_all(self):
+ """Every desk paired with every other as pairing leaves them: the peer entry, its whole edge,
+ no side yet (the Mac's one peer holds Right, unstamped), and each desk's own tile."""
+ for desk in self.desks.values():
+ others = [other for other in self.desks.values() if other is not desk]
+ with desk.lock:
+ settings = copy.deepcopy(desk.settings)
+ settings["peers"] = [entry(other.own, other.name, token=key(desk.own, other.own),
+ platform=other.platform_name, linked=False,
+ paired_with=[item.id for item in self.desks.values()
+ if item is not other])
+ for other in others]
+ for item in settings["peers"]:
+ item["side"] = ""
+ settings["zones"] = []
+ desk.shell.paired(settings)
+ desk.save(settings)
+
+ def start(self):
+ for desk in self.desks.values():
+ desk.machine.start()
+ self.test.addCleanup(desk.machine.stop)
+ desk.started = True
+ for desk in self.desks.values():
+ for other in self.desks.values():
+ if other is not desk:
+ desk.hand.connect(other)
+ self.test.addCleanup(desk.hand.close)
+ for desk in self.desks.values():
+ for other in self.desks.values():
+ if other is not desk:
+ desk.shell.link_up(other)
+ self.settle()
+
+ def settle(self, timeout=2.0):
+ """Wait until every desk's shell has nothing in flight and every message sent has landed:
+ each shell counts what it sent and what it handled."""
+ deadline = time.monotonic() + timeout
+ quiet_since = None
+ while time.monotonic() < deadline:
+ for desk in self.desks.values():
+ desk.hand.pump()
+ busy = any(desk.shell.busy() for desk in self.desks.values())
+ sent = sum(desk.shell.sent_count for desk in self.desks.values())
+ handled = sum(desk.shell.handled_count for desk in self.desks.values())
+ if not busy and sent == handled:
+ quiet_since = quiet_since or time.monotonic()
+ if time.monotonic() - quiet_since > 0.05:
+ return True
+ else:
+ quiet_since = None
+ time.sleep(0.003)
+ return False
+
+ # Where input is.
+
+ def at(self, holder):
+ """The desk whose screen `holder`'s pointer is on."""
+ on = holder.hand.on
+ return holder if on is None else next(desk for desk in self.desks.values() if desk.id == on)
+
+ def push(self, holder, side, along=0.5, display=None):
+ """`holder`'s pointer, on whichever desk it is, pushed through `side` of `display` (that
+ desk's first display by default) at `along` of the way along it. The desk it is on after."""
+ here = self.at(holder)
+ display = display or next(iter(here.screen.displays))
+ point = here.screen.point(display, side, along)
+ return self._push(holder, here, point, PUSH[side])
+
+ def push_corner(self, holder, corner, display=None):
+ here = self.at(holder)
+ display = display or next(iter(here.screen.displays))
+ point = here.screen.corner(display, corner)
+ return self._push(holder, here, point, CORNER_PUSH[corner])
+
+ def _push(self, holder, here, point, delta):
+ if here is holder:
+ holder.push_home(point, delta)
+ else:
+ here.screen.cursor = point
+ for _ in range(PUSHES):
+ holder.hand.move(*delta)
+ here.screen.cursor = point
+ # Every move is acked or acted on before the result is read.
+ holder.hand.until(lambda: False, timeout=0.15)
+ holder.hand.until(lambda: getattr(holder.hand.owner, "_wait", None) is None, timeout=0.5)
+ self.settle(0.5)
+ return self.at(holder)
+
+ def shortcut(self, holder, other=None):
+ """`holder`'s shortcut, menu or Send button: to `other`, or home with None."""
+ holder.hand.go(None if other is None or other is holder else other.id)
+ holder.hand.until(lambda: getattr(holder.hand.owner, "_wait", None) is None, timeout=0.5)
+ self.settle(0.5)
+ return self.at(holder)
+
+ def driven_by(self, desk):
+ """The desk whose input `desk`'s responder takes now, or None."""
+ owner = desk.machine.responder.owner
+ return None if owner is None else next(other for other in self.desks.values() if other.own == owner)
+
+ def views_agree(self):
+ """[(problem)] where two desks disagree about the picture or the sides: every pair's sides
+ face each other, and every desk holds the same tiles, each with its own displays."""
+ problems = []
+ desks = list(self.desks.values())
+ for one in desks:
+ for two in desks:
+ if one is two:
+ continue
+ mine, theirs = one.peer(two), two.peer(one)
+ if mine is None or theirs is None:
+ continue
+ if mine.get("side") in return_edge.EDGES and theirs.get("side") in return_edge.EDGES:
+ if return_edge.OPPOSITE[mine["side"]] != theirs["side"]:
+ problems.append(f"{one.name} holds {two.name} {mine['side']}, {two.name} holds {one.name} "
+ f"{theirs['side']}")
+ first = desks[0]
+ for other in desks[1:]:
+ a = {key: (tile["x"], tile["y"], tile["w"], tile["h"]) for key, tile in first.settings["layout"].items()}
+ b = {key: (tile["x"], tile["y"], tile["w"], tile["h"]) for key, tile in other.settings["layout"].items()}
+ if {key: value for key, value in a.items() if key in b} != {key: value for key, value in b.items() if key in a}:
+ problems.append(f"{first.name} and {other.name} hold different pictures: {a} / {b}")
+ for desk in desks:
+ for holder in desks:
+ tile = holder.settings["layout"].get(desk.id)
+ if isinstance(tile, dict) and "displays" not in tile:
+ problems.append(f"{holder.name}'s picture has {desk.name}'s tile without its displays")
+ return problems
+
+ def bad_zones(self):
+ """Zones whose target side has no target display: the switch they would send is malformed."""
+ return [(desk.name, zone) for desk in self.desks.values() for zone in desk.settings["zones"]
+ if zone.get("target_side") and not zone.get("target_display")]
+
+ def landed(self, desk):
+ """Where `desk`'s cursor was last placed by an arrival: (display, side it is on or None)."""
+ if not desk.screen.placed:
+ return None
+ point = desk.screen.placed[-1]
+ name = desk.screen.on_display(point)
+ rect = desk.screen.displays.get(name)
+ if rect is None:
+ return (None, None)
+ side = ("left" if point[0] <= rect.x + 2 else "right" if point[0] >= rect.right - 2
+ else "top" if point[1] <= rect.y + 2 else "bottom" if point[1] >= rect.bottom - 2 else None)
+ return (name, side)
diff --git a/core/tests/crossing_shells.py b/core/tests/crossing_shells.py
new file mode 100644
index 0000000..2e0df1a
--- /dev/null
+++ b/core/tests/crossing_shells.py
@@ -0,0 +1,235 @@
+"""Thin headless shells for the crossing model, shared by both desktop platforms.
+
+Every crossing event calls core.crossing_state and carries out its Outcome. AppKit and Qt
+are absent; the only platform difference is the platform argument supplied to the core.
+The harness uses real responders, owners and wire messages beneath these shells.
+"""
+
+import copy
+import threading
+import time
+
+from core import crossing_state, protocol, return_edge, settings_sync, ways
+
+SNAP_RADIUS = 12
+
+
+class Shell:
+ platform = None
+
+ def __init__(self, desk):
+ self.desk = desk
+ self.sent_count = 0
+ self.handled_count = 0
+ self.lock = threading.RLock()
+ self.refused = []
+ callbacks = desk.machine.responder._callbacks
+ callbacks["arrangement"] = self._arrangement_arrived
+ callbacks["settings"] = self._settings_arrived
+
+ def busy(self):
+ return False
+
+ def live(self, peer):
+ return peer in self.desk.hand.links
+
+ def gone(self, peer):
+ return False
+
+ def capable(self):
+ return {peer for peer, caps in self.desk.hand.capabilities.items() if "layout" in caps} | {self.desk.id}
+
+ def current(self):
+ return copy.deepcopy(self.desk.settings)
+
+ def _args(self):
+ return dict(platform=self.platform, live=self.live, gone=self.gone, now=time.time())
+
+ def _send(self, peer, message):
+ if self.desk.hand.send(peer, message):
+ self.sent_count += 1
+ return True
+ return False
+
+ def _arrangement_arrived(self, peer, read):
+ try:
+ with self.lock:
+ self.on_arrangement(protocol.id_text(peer), read)
+ finally:
+ self.handled_count += 1
+
+ def _settings_arrived(self, peer, data):
+ try:
+ with self.lock:
+ self.on_settings(protocol.id_text(peer), data)
+ finally:
+ self.handled_count += 1
+
+ def carry_out(self, outcome, source=None, arrived=None):
+ if outcome["changed"]:
+ self.desk.save(outcome["settings"])
+ for peer in outcome["tell"]:
+ self.tell(peer)
+ if outcome["send_picture"]:
+ self.send_same()
+ if outcome["forward_picture"] and arrived is not None:
+ self.send_same(exclude=source, data=arrived)
+ if outcome["changed"]:
+ self.after_change()
+ return outcome
+
+ def paired(self, settings):
+ outcome = crossing_state.paired(settings, platform=self.platform,
+ own_displays=self.desk.screen.display_map(), now=time.time())
+ settings.clear()
+ settings.update(outcome["settings"])
+
+ def same_state(self):
+ settings = self.current()
+ tiles = copy.deepcopy(settings.get("layout", {}))
+ for entry in settings.get("peers", []):
+ tile = tiles.get(entry.get("id"))
+ if isinstance(tile, dict) and entry.get("name", "").strip():
+ tile["name"] = entry["name"].strip()[:64]
+ state = {"set_at": settings.get("layout_set_at", 0),
+ "by": settings.get("layout_by") or self.desk.id, "tiles": tiles}
+ return settings_sync.message_data(False, settings.get("same_set_at", 0), {},
+ by=self.desk.id, layout_state=state)
+
+ def send_same(self, exclude=None, data=None):
+ data = self.same_state() if data is None else data
+ for peer in list(self.desk.hand.links):
+ if peer != exclude and peer in self.capable():
+ self._send(peer, protocol.settings_msg(data))
+
+ def link_up(self, other):
+ with self.lock:
+ outcome = crossing_state.link_up(self.current(), other.id, platform=self.platform,
+ own_displays=self.desk.screen.display_map(), now=time.time(), capable=self.capable())
+ self.carry_out(outcome)
+
+ def tell(self, peer):
+ settings = self.current()
+ entry = ways._entry(settings, peer)
+ if entry is None or entry.get("side") not in return_edge.EDGES:
+ return
+ author = protocol.read_id(entry.get("side_by")) or self.desk.own
+ self._send(peer, protocol.arrangement_v6(
+ entry["side"], int(entry.get("side_set_at", 0)), author,
+ way_back=ways.has_way(settings, peer),
+ way_back_by=protocol.read_id(ways.way_back_by(settings, peer))))
+
+ def after_change(self):
+ server = self.desk.machine.responder
+ server.peers_changed()
+ server.rearm()
+
+ def stop(self):
+ pass
+
+ def drop(self, moved, x, y, snap=True):
+ with self.lock:
+ settings = self.current()
+ tiles = copy.deepcopy(settings["layout"])
+ tile = tiles.get(moved.id, dict(w=moved.tile_size[0], h=moved.tile_size[1]))
+ tiles[moved.id] = dict(tile, x=int(x), y=int(y))
+ outcome = crossing_state.drop(settings, tiles, moved.id, capable=self.capable(),
+ snap_radius=SNAP_RADIUS if snap else 0, **self._args())
+ if not outcome["accepted"]:
+ self.refused.append(moved.id)
+ return False
+ self.carry_out(outcome)
+ return True
+
+ def edit(self, other, methods, parts=None, corner=None):
+ with self.lock:
+ settings = self.current()
+ held = ways.ways(settings, other.id)
+ thirds = list(ways.PARTS) if "edge" in methods else (parts if parts is not None else held["parts"])
+ outcome = crossing_state.edit_ways(settings, other.id, edge=bool(set(methods) & {"edge", "part"}),
+ thirds=thirds, corner="corner" in methods, corner_at=corner,
+ notch="notch" in methods, capable=self.capable(), **self._args())
+ self.carry_out(outcome)
+ return True
+
+ def pick_third(self, other, third):
+ return self.click_third(other, third)
+
+ def click_third(self, other, third):
+ with self.lock:
+ settings = self.current()
+ held = ways.ways(settings, other.id)
+ if ways._entry(settings, other.id).get("left_out") or held["side"] not in ways.EDGES:
+ return False
+ methods, parts = ways.toggle_third(held["methods"], held["parts"], third)
+ outcome = crossing_state.edit_ways(settings, other.id,
+ edge=bool(set(methods) & {"edge", "part"}), thirds=parts,
+ capable=self.capable(), **self._args())
+ self.carry_out(outcome)
+ return True
+
+ def click_edge_text(self, other):
+ with self.lock:
+ settings = self.current()
+ if ways._entry(settings, other.id).get("left_out"):
+ return False
+ held = ways.ways(settings, other.id)
+ methods, parts = ways.toggle_edge(held["methods"], held["parts"])
+ outcome = crossing_state.edit_ways(settings, other.id,
+ edge=bool(set(methods) & {"edge", "part"}), thirds=parts,
+ capable=self.capable(), **self._args())
+ self.carry_out(outcome)
+ return True
+
+ def click_corner(self, other, corner):
+ with self.lock:
+ settings = self.current()
+ if (ways._entry(settings, other.id).get("left_out")
+ or ways.corner_holder(settings, corner, exclude=other.id) is not None):
+ return False
+ held = ways.ways(settings, other.id)
+ on = not ("corner" in held["methods"] and held["corner"] == corner)
+ outcome = crossing_state.edit_ways(settings, other.id, corner=on, corner_at=corner,
+ capable=self.capable(), **self._args())
+ self.carry_out(outcome)
+ return True
+
+ def leave_out(self, other):
+ with self.lock:
+ return self.carry_out(crossing_state.leave_out(self.current(), other.id,
+ capable=self.capable(), **self._args()))
+
+ def put_back(self, other):
+ with self.lock:
+ return self.carry_out(crossing_state.put_back(self.current(), other.id,
+ capable=self.capable(), **self._args()))
+
+ def displays_changed(self):
+ with self.lock:
+ return self.carry_out(crossing_state.displays_changed(self.current(), platform=self.platform,
+ own_displays=self.desk.screen.display_map(), now=time.time(),
+ capable=self.capable()))
+
+ def on_arrangement(self, peer, read):
+ outcome = crossing_state.receive_arrangement(self.current(), peer, read,
+ capable=self.capable(), **self._args())
+ return self.carry_out(outcome)["changed"]
+
+ def on_settings(self, peer, data):
+ state = settings_sync.read_layout_state(data)
+ if state is None:
+ return False
+ outcome = crossing_state.receive_picture(self.current(), state, source=peer,
+ capable=self.capable(), own_displays=self.desk.screen.display_map(), **self._args())
+ return self.carry_out(outcome, source=peer, arrived=data)["changed"]
+
+
+class MacShell(Shell):
+ platform = "mac"
+
+
+class PcShell(Shell):
+ platform = "pc"
+
+
+SHELLS = {"mac": MacShell, "pc": PcShell}
diff --git a/core/tests/settings_behaviour.py b/core/tests/settings_behaviour.py
index f8fc3c0..8af23c0 100644
--- a/core/tests/settings_behaviour.py
+++ b/core/tests/settings_behaviour.py
@@ -4,8 +4,10 @@ import ast
import copy
import importlib
import logging
+import platform as system_platform
from pathlib import Path
import sys
+import tempfile
import time
from dataclasses import replace
from types import SimpleNamespace
@@ -17,6 +19,7 @@ from core.tests.app_methods import load_methods
ROOT = Path(__file__).resolve().parents[2]
IDS = [protocol.id_text(bytes([value]) * 16) for value in (1, 2, 3)]
+SETTINGS_ROOT = tempfile.TemporaryDirectory()
VALUES = dict(glow_style="beam", glow_colour="ocean", effect_length="long",
effect_size="large", shortcut_arrival=False, shortcut_arrival_style="locator")
@@ -32,12 +35,13 @@ def mac_adapter():
def fixture(platform, ident):
- namespace = dict(settings_sync=settings_sync, protocol=protocol, peerlist=peerlist, time=time,
+ namespace = dict(settings_sync=settings_sync, protocol=protocol, peerlist=peerlist, time=time, copy=copy,
Optional=Optional, replace=replace, LOGGER=logging.getLogger("settings-behaviour"),
core_ways=ways, ways=ways)
if platform == "mac":
config, to_raw = mac_adapter()
- namespace.update(config_to_raw=to_raw, KEY_NAME_TO_CODE={"cmd_r", "f13"}, SettingsError=ValueError)
+ namespace.update(config_to_raw=to_raw, KEY_NAME_TO_CODE={"cmd_r", "f13"}, SettingsError=ValueError,
+ desktop_mac=SimpleNamespace(display_map=lambda: {}))
names = ("same_state", "_apply_followed_design", "_receive_design", "apply_same", "_set_design_follow", "_set_same",
"_show_trigger_conflict", "_trigger_chosen")
cls = load_methods("mac_app/kvm_bridge_app.py", "ControlWindow", names, namespace)
@@ -45,7 +49,8 @@ def fixture(platform, ident):
cfg = config.parse_config(dict(host="", port=24800, auth_token="", design_set_at=1000, design_by=ident))
app.controller = SimpleNamespace(cfg=cfg)
app.controller.apply_settings = lambda value: setattr(app.controller, "cfg", value)
- app.settings_store = SimpleNamespace(save=lambda raw: config.parse_config(copy.deepcopy(raw)))
+ app.settings_store = SimpleNamespace(save=lambda raw, **kwargs: config.parse_config(copy.deepcopy(raw)))
+ app._receive_layout = lambda data, peer: False
app.own_id = lambda: ident
app.previews = None
app._load_shared = lambda raw: None
@@ -68,6 +73,7 @@ def fixture(platform, ident):
sys.path.insert(0, str(ROOT / "win_app"))
config = importlib.import_module("app_config")
namespace.update(app_config=config, ConfigError=config.ConfigError, TRIGGER_KEYS={"cmd_r", "f13"})
+ namespace["platform"] = system_platform
names = ("_same_state", "_apply_followed_design", "_on_settings", "_design_follow_chosen", "_set_same",
"_show_trigger_conflict", "_record_trigger")
namespace.update(TRIGGER_KEYS=config.TRIGGER_KEYS, TRIGGER_VKS=config.TRIGGER_VKS,
@@ -103,6 +109,10 @@ def fixture(platform, ident):
app.controller.book = SimpleNamespace(peers=lambda: app.peers)
else:
app.book = SimpleNamespace(peers=lambda: app.peers)
+ app._peer_caps = lambda: {}
+ app.config_path = Path(tempfile.mkdtemp(dir=SETTINGS_ROOT.name)) / "settings.json"
+ config.write_settings(app.config_path, {"schema": config.SCHEMA, "machine_id": ident,
+ "peers": copy.deepcopy(app.peers), "zones": []})
app._design_states = {}
app._followed_version = None
app._design_path = [ident]
@@ -137,7 +147,8 @@ def reflect_shortcut_visibility(app, platform):
raise UnrelatedUI
def visibility(view, visible):
view.visible = visible
- motion = SimpleNamespace(set_hidden=lambda view, hidden: visibility(view, not hidden), set_shown=visibility)
+ motion = SimpleNamespace(set_hidden=lambda view, hidden: visibility(view, not hidden),
+ set_shown=lambda view, visible, **_options: visibility(view, visible))
if platform == "mac":
pages = importlib.import_module("pages")
namespace = dict(pages=SimpleNamespace(crossing_rows=pages.crossing_rows, part_names=stop), motion=motion)
@@ -145,7 +156,9 @@ def reflect_shortcut_visibility(app, platform):
app.method_boxes = {name: SimpleNamespace(value=name in app.cfg().crossing["methods"])
for name in ("shortcut", "edge", "corner", "part", "notch")}
app.edge_row = app.parts_row = app.corner_row = SimpleNamespace()
- app.dragging_box = app.resistance_module = SimpleNamespace(view=SimpleNamespace())
+ app.corner_select = SimpleNamespace(set_enabled=lambda enabled: None)
+ app.resistance_module = SimpleNamespace(view=SimpleNamespace())
+ app.dragging_box = SimpleNamespace(view=SimpleNamespace(), set_enabled=lambda enabled: None)
app.shortcut_module = SimpleNamespace(view=SimpleNamespace(visible=False))
app.key_recorder.cancel = lambda: None
app.edge_select = SimpleNamespace(value="right")
@@ -153,25 +166,82 @@ def reflect_shortcut_visibility(app, platform):
view = app.shortcut_module.view
else:
pages = importlib.import_module("pages_win")
- namespace = dict(pages_win=pages, ways=ways, motion=motion, TRIGGER_KEYS=SimpleNamespace(get=stop))
+ namespace = dict(pages_win=pages, ways=ways, motion=motion, peerlist=peerlist,
+ widgets=SimpleNamespace(set_role=lambda *args: None),
+ platform=system_platform,
+ OWN_PLATFORM="windows",
+ TRIGGER_KEYS=SimpleNamespace(get=stop))
cls = load_methods("win_app/kvm_bridge_win.py", "WindowsApplication", ["_reflect_ways"], namespace)
- app._crossing_settings = lambda: {"peers": [], "zones": []}
+ app._crossing_settings = lambda: {"machine_id": app._config.machine_id, "peers": [], "zones": []}
app._crossing_machines = lambda: []
app._chosen_machine = lambda: None
app._rebuild_machine_choice = lambda values: None
app._ways_in = lambda: set()
- ui = SimpleNamespace(
- set_value=lambda *args: None,
- set_names=lambda *args: None,
- setText=lambda *args: None,
- view=SimpleNamespace(setToolTip=lambda text: None),
- )
+
+ class UI:
+ def __init__(self):
+ self.visible = True
+ self.view = self
+ self._buttons = {"next": self, "ticked": self}
+
+ def set_value(self, *args): pass
+ def set_names(self, *args): pass
+ def setText(self, *args): pass
+ def setVisible(self, visible): self.visible = visible
+ def setToolTip(self, *args): pass
+ def setAccessibleName(self, *args): pass
+ def setAccessibleDescription(self, *args): pass
+ def setText(self, *args): pass
+ def setChecked(self, *args): pass
+ def isChecked(self): return False
+ def blockSignals(self, *args): pass
+ def set_edge(self, *args): pass
+ def text(self): return ""
+ def toolTip(self): return ""
+ def accessibleName(self): return ""
+ def accessibleDescription(self): return ""
+ def isEnabled(self): return True
+ def setEnabled(self, *args): pass
+ def isVisible(self): return self.visible
+ def isHidden(self): return not self.visible
+ def hide(self): pass
+ def deleteLater(self): pass
+
+ def __getattr__(self, name):
+ # Any other widget call the refresh makes is not what these tests measure.
+ return lambda *args, **kwargs: None
+
+ ui = UI()
+ app._peer_entries = []
+ app._design_peer_caps = lambda: {}
+ app._live = lambda _peer: False
+ app._gone = lambda _peer: False
+ app._shown = lambda value: value
+ app.atlas_note = UI()
+ app.atlas_canvas = SimpleNamespace(set_tiles=lambda *args, **kwargs: None,
+ set_left_out=lambda *args: None,
+ shelf_ids=[], cycle={})
+ app.left_out_layout = SimpleNamespace(count=lambda: 0, takeAt=lambda _index: None)
+ app.left_out_shelf = app.left_out_heading = app.left_out_note = UI()
+ app.selected_machine_name = app.dormant_note = app.selected_machine_status = UI()
+ app.selected_machine_header = app.ways_heading = app.ways_summary = UI()
+ app.canvas_rename = app.canvas_leave_out = UI()
+ app.blocked_note = app.missing_note = app.no_way_back_note = UI()
+ app.shortcut_target_choice = app.shortcut_target_note = UI()
+ app.resistance_strip = UI()
+ app._reflect_jump_key = stop
for name in ("machine_choice", "edge_choice", "edge_heading", "edge_note", "edge_unlearned", "corner_choice", "parts_note"):
setattr(app, name, ui)
app.machine_row = app.resistance_module = SimpleNamespace()
app.ways_module = SimpleNamespace(eyebrow=SimpleNamespace(setText=lambda text: None))
- app.shortcut_module = SimpleNamespace(visible=False)
- app.way_boxes = app.part_buttons = app.crossing_rows = {}
+ app.shortcut_module = UI()
+ app.way_boxes = {name: UI() for name in ("edge", "corner", "parts", "shortcut")}
+ app.edge_way_detail = UI()
+ app.part_buttons = {}
+ app.third_boxes = {name: UI() for name in ("start", "middle", "end")}
+ app.crossing_rows = {name: UI() for name in ("edge", "corner", "parts", "thirds", "shortcut", "dragging", "resistance")}
+ app._crossing_text = lambda widget, text: widget.setText(text)
+ app._left_out_rows = {}
method = lambda: cls._reflect_ways(app)
view = app.shortcut_module
try:
@@ -198,6 +268,7 @@ def status_fixture(platform, caps, cached=False, following=False, offline=()):
self.items = []
for value, title in choices:
cell = SimpleNamespace(enabled=True, tooltip="", setAlphaValue_=lambda alpha: None)
+ cell.title = lambda title=title: title
cell.setToolTip_ = lambda text, cell=cell: setattr(cell, "tooltip", text)
cell.setEnabled_ = lambda enabled, cell=cell: setattr(cell, "enabled", enabled)
self.items.append((value, cell))
@@ -261,7 +332,8 @@ class SettingsBehaviourTests(TestCase):
self.app.select(IDS[0])
def assert_design(self, app, values=VALUES):
- self.assertEqual({key: app.values()[key] for key in settings_sync.DESIGN_KEYS}, values)
+ expected = settings_sync._with_continuous(values)
+ self.assertEqual({key: app.values()[key] for key in settings_sync.DESIGN_KEYS}, expected)
def test_selecting_older_leader_adopts_all_six_values_and_announces_local_version(self):
self.cache_and_select()
@@ -284,7 +356,7 @@ class SettingsBehaviourTests(TestCase):
# paired machines were offline and their missing Design set the note to "not available".
app = status_fixture(self.platform, {IDS[0]: {"settings", "design_sync"}}, cached=True, offline=(IDS[2],))
self.assertEqual(app.status_titles, ["None", "Leader"])
- self.assertEqual(app.status_tooltip, "")
+ self.assertEqual(app.status_tooltip, "Leader" if self.platform == "mac" else "")
self.assertTrue(app.status_note.startswith("None: this "), app.status_note)
def test_no_connected_machine_lists_none_with_one_quiet_line(self):
@@ -303,7 +375,8 @@ class SettingsBehaviourTests(TestCase):
def test_shared_trigger_clash_preserves_local_jump_and_trigger_and_reports_conflict(self):
self.app.peers.append({"id": IDS[0], "jump_key": "ctrl+f13"})
before = self.app.cfg().trigger_key
- data = settings_sync.message_data(True, 20, {"trigger_key": "f13", "resistance_px": 75}, by=IDS[0])
+ data = settings_sync.message_data(True, 20, {"trigger_key": "f13", "resistance_px": 75}, by=IDS[0],
+ groups=settings_sync.ALL_GROUPS)
self.app.peers[0]["jump_key"] = "cmd+f13"
self.app.receive(IDS[0], data)
self.assertEqual(self.app.cfg().trigger_key, before)
@@ -326,7 +399,7 @@ class SettingsBehaviourTests(TestCase):
self.app.peers.append({"id": IDS[0], "jump_key": "ctrl+f13"})
before = self.app.cfg().trigger_key
self.app.receive(IDS[0], settings_sync.message_data(
- True, 20, {"trigger_key": "f13", "shortcut": False}, by=IDS[0]))
+ True, 20, {"trigger_key": "f13", "shortcut": False}, by=IDS[0], groups=settings_sync.ALL_GROUPS))
self.assertEqual(self.app.cfg().trigger_key, before)
self.assertIn("clashes", self.app.conflict_note.text)
self.assertTrue(reflect_shortcut_visibility(self.app, self.platform))
@@ -346,6 +419,7 @@ class SettingsBehaviourTests(TestCase):
def test_same_off_here_resumes_the_already_adopted_cached_version(self):
self.cache_and_select()
self.app.cfg().same_on_both = True
+ self.app.cfg().same_groups = list(settings_sync.ALL_GROUPS)
self._set_values(dict(VALUES, effect_length="short"))
self.app._set_same(False)
self.assert_design(self.app)
@@ -353,6 +427,7 @@ class SettingsBehaviourTests(TestCase):
def test_same_off_received_resumes_the_already_adopted_cached_version(self):
self.cache_and_select()
self.app.cfg().same_on_both = True
+ self.app.cfg().same_groups = list(settings_sync.ALL_GROUPS)
self._set_values(dict(VALUES, effect_length="short"))
data = settings_sync.message_data(False, self.app.cfg().same_set_at + 1, by=IDS[2])
self.app.receive(IDS[2], data)
diff --git a/core/tests/test_arrival_grace.py b/core/tests/test_arrival_grace.py
new file mode 100644
index 0000000..9ca8722
--- /dev/null
+++ b/core/tests/test_arrival_grace.py
@@ -0,0 +1,165 @@
+import collections
+import logging
+import unittest
+from types import SimpleNamespace
+from unittest import mock
+
+from core import protocol, receiver, return_edge
+
+
+MONITORS = [return_edge.Rect(0, 0, 100, 100)]
+
+
+class Clock:
+ def __init__(self):
+ self.now = 10.0
+
+ def __call__(self):
+ return self.now
+
+
+class ReturnEdgeArrivalGrace(unittest.TestCase):
+ def setUp(self):
+ self.clock = Clock()
+ self.edge = return_edge.ReturnEdge("right", resistance_px=10, clock=self.clock)
+
+ def test_outward_flick_during_grace_is_held_without_pressure(self):
+ self.edge.start_grace()
+
+ outcome = self.edge.feed(MONITORS, (99, 50), 20, 0)
+
+ self.assertEqual(outcome.action, return_edge.HOLD)
+ self.assertEqual(outcome.pressure, 0)
+ self.assertEqual(outcome.position, (99, 50))
+
+ def test_outward_push_crosses_after_grace(self):
+ self.edge.start_grace()
+ self.clock.now += 0.3
+
+ outcome = self.edge.feed(MONITORS, (99, 50), 20, 0)
+
+ self.assertEqual(outcome.action, return_edge.CROSS)
+
+ def test_four_pixels_inward_ends_grace(self):
+ self.edge.start_grace()
+ self.assertEqual(self.edge.feed(MONITORS, (95, 50), -4, 0).action, return_edge.PASS)
+
+ outcome = self.edge.feed(MONITORS, (99, 50), 10, 0)
+
+ self.assertEqual(outcome.action, return_edge.CROSS)
+
+ def test_construction_and_reset_do_not_start_grace(self):
+ outcome = self.edge.feed(MONITORS, (99, 50), 20, 0)
+
+ self.assertEqual(outcome.action, return_edge.CROSS)
+
+ edge = return_edge.ReturnEdge("right", resistance_px=10, clock=self.clock)
+ edge.start_grace()
+ edge.reset()
+ self.assertEqual(edge.feed(MONITORS, (99, 50), 20, 0).action, return_edge.CROSS)
+
+ def test_start_grace_begins_a_new_grace_period(self):
+ self.clock.now += 0.3
+ edge = return_edge.ReturnEdge("right", resistance_px=10, clock=self.clock)
+ edge.start_grace()
+
+ outcome = edge.feed(MONITORS, (99, 50), 20, 0)
+
+ self.assertEqual(outcome.action, return_edge.HOLD)
+
+ def test_part_edge_has_the_same_grace(self):
+ edge = return_edge.PartEdge("right", ["middle"], 10, self.clock)
+ edge.start_grace()
+
+ outcome = edge.feed(MONITORS, (99, 50), 20, 0)
+
+ self.assertEqual(outcome.action, return_edge.HOLD)
+
+ def test_corner_push_has_the_same_grace(self):
+ edge = return_edge.CornerPush("top_right", "right", 10, self.clock)
+ edge.start_grace()
+
+ outcome = edge.feed(MONITORS, (99, 0), 20, -20)
+
+ self.assertEqual(outcome.action, return_edge.HOLD)
+
+ def test_a_rearm_keeps_the_grace_of_the_zone_it_replaces(self):
+ old = return_edge.ReturnEdge("right", resistance_px=10, clock=self.clock)
+ old.start_grace()
+ new = return_edge.ReturnEdge("right", resistance_px=10, clock=self.clock)
+ other = return_edge.ReturnEdge("left", resistance_px=10, clock=self.clock)
+ return_edge.keep_grace([(b"a", old)], [(b"a", new), (b"a", other)])
+ self.assertEqual(new.feed(MONITORS, (99, 50), 20, 0).action, return_edge.HOLD)
+ self.assertEqual(other.feed(MONITORS, (0, 50), -20, 0).action, return_edge.CROSS)
+
+ def test_landing_beside_a_seam_staggered_by_less_than_the_clearance_stays_on_the_wall(self):
+ monitors = [return_edge.Rect(0, 0, 2560, 1440), return_edge.Rect(-1920, 5, 1920, 1080)]
+ self.assertEqual(return_edge.arrival_position(monitors, "left", 0.0), (0, 0))
+ self.assertEqual(return_edge.arrival_position([monitors[0]], "left", 0.0), (0, 10))
+
+ def test_take_starts_grace_only_for_the_zone_back_to_its_owner(self):
+ self.assertEqual(self._take({"stay": True}), (return_edge.HOLD, return_edge.CROSS))
+
+ def test_a_take_that_lands_on_an_edge_holds_every_zone(self):
+ # rc14 (10-10-2026): the push that brought input here went on through a zone to a third machine.
+ self.assertEqual(self._take({"stay": False, "edge": "right", "offset": 0.5}),
+ (return_edge.HOLD, return_edge.HOLD))
+
+ def _take(self, how):
+ owner_peer, other_peer = b"owner-peer-id!!!", b"other-peer-id!!!"
+ owner_peer_id, other_peer_id = protocol.id_text(owner_peer), protocol.id_text(other_peer)
+ peers = [
+ {"id": owner_peer_id, "side": "right", "in_use": True, "port": 1},
+ {"id": other_peer_id, "side": "right", "in_use": True, "port": 1},
+ ]
+ zones = [
+ {"kind": "edge", "peer": owner_peer_id},
+ {"kind": "edge", "peer": other_peer_id},
+ ]
+ responder_instance = receiver.LinkResponder.__new__(receiver.LinkResponder)
+ responder_instance._owner = None
+ responder_instance._reach = frozenset((other_peer,))
+ responder_instance._resistance = 10
+ responder_instance._notch_span = None
+ responder_instance._armed = []
+ responder_instance._zones_live = False
+ responder_instance._visit = 0
+ responder_instance._clipboard_mark = None
+ responder_instance._sent_home_for_lock = False
+ responder_instance._locked_since = None
+ responder_instance._owner_events = collections.deque()
+ responder_instance._clipboard_stamp = lambda: None
+ link = SimpleNamespace(peer_id=owner_peer, own_id=b"this-machine-id!", name="Owner")
+ focus = {"reach": (other_peer,), "resistance_px": 10, **how}
+
+ responder_instance._own_locked(link, focus, peers, zones)
+
+ models = dict(responder_instance._armed)
+ return (models[owner_peer].feed(MONITORS, (99, 50), 10, 0).action,
+ models[other_peer].feed(MONITORS, (99, 50), 10, 0).action)
+
+
+class IncomingMoveLogging(unittest.TestCase):
+ def test_logs_one_second_of_move_counts_and_raw_delta_sums(self):
+ link = SimpleNamespace(name="Peer", incoming_moves_at=None, incoming_move_count=0,
+ incoming_move_last_at=None, incoming_dx=0, incoming_dy=0, incoming_largest=0)
+ with mock.patch.object(receiver.time, "monotonic", side_effect=(1.0, 1.2, 2.0)):
+ with self.assertLogs(receiver.LOGGER, level=logging.DEBUG) as logs:
+ receiver.LinkResponder._record_incoming_move(None, link, {"dx": 3, "dy": -4})
+ receiver.LinkResponder._record_incoming_move(None, link, {"dx": -5, "dy": 2})
+ receiver.LinkResponder._record_incoming_move(None, link, {"dx": 1, "dy": 8})
+
+ self.assertEqual(len(logs.output), 1)
+ self.assertIn("incoming moves from Peer: 3 moves, |dx| sum 9, |dy| sum 14, largest 8 in the last second", logs.output[0])
+
+ def test_idle_period_does_not_emit_a_line(self):
+ link = SimpleNamespace(name="Peer", incoming_moves_at=None, incoming_move_count=0,
+ incoming_move_last_at=None, incoming_dx=0, incoming_dy=0, incoming_largest=0)
+ with mock.patch.object(receiver.time, "monotonic", side_effect=(1.0, 5.0)):
+ with self.assertNoLogs(receiver.LOGGER, level=logging.DEBUG):
+ receiver.LinkResponder._record_incoming_move(None, link, {"dx": 3, "dy": 4})
+ receiver.LinkResponder._record_incoming_move(None, link, {"dx": 5, "dy": 2})
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/core/tests/test_atlas.py b/core/tests/test_atlas.py
new file mode 100644
index 0000000..8886ef9
--- /dev/null
+++ b/core/tests/test_atlas.py
@@ -0,0 +1,806 @@
+import copy
+import math
+import unittest
+
+from core import settings_sync, ways
+
+
+class AtlasTests(unittest.TestCase):
+ def test_layout_compile_edge_part_gap_and_corner(self):
+ settings = self.settings(A)
+ layout = self.picture(settings, A, self.tile(160, 0, 160, 100))
+ result = ways.compile_layout(settings, layout, now=10)
+ self.assertEqual(result["tiles"][A]["state"], "edge")
+ self.assertEqual(settings["peers"][0]["side"], "")
+ self.assertEqual(settings["zones"], [])
+ self.assertEqual(result["settings"]["peers"][0]["side"], "right")
+ self.assertEqual(ways.ways(result["settings"], A)["methods"], ["edge"])
+
+ settings = self.settings(A)
+ result = ways.compile_layout(settings, self.picture(settings, A, self.tile(160, 67, 160, 33)), now=10)
+ self.assertEqual(result["tiles"][A]["state"], "part")
+ self.assertEqual(ways.ways(result["settings"], A)["parts"], ["start", "middle", "end"])
+ self.assertEqual(result["settings"]["zones"], [{"peer": A, "kind": "part", "parts": ["end"], "side": "right"}])
+
+ settings = self.settings(A)
+ result = ways.compile_layout(settings, self.picture(settings, A, self.tile(160, 20, 160, 10)), now=10)
+ self.assertEqual(result["tiles"][A]["state"], "gap")
+ self.assertEqual(ways.has_way(result["settings"], A), False)
+
+ settings = self.settings(A)
+ result = ways.compile_layout(settings, self.picture(settings, A, self.tile(160, 100, 100, 100)), now=10)
+ self.assertEqual(result["tiles"][A]["state"], "corner")
+ self.assertEqual(ways.ways(result["settings"], A)["methods"], ["edge"])
+ corner = next(zone for zone in result["settings"]["zones"] if zone["peer"] == A and zone["kind"] == "corner")
+ self.assertEqual(corner["edge"], ways.corner_edge(corner["corner"], "right"))
+
+ def test_two_peers_share_thirds_and_can_touch_elsewhere(self):
+ settings = self.settings(A, B)
+ layout = self.picture(settings, A, self.tile(160, 0, 160, 33), B, self.tile(160, 67, 160, 33))
+ result = ways.compile_layout(settings, layout, now=10)
+ self.assertEqual(ways.ways(result["settings"], A)["parts"], ["start", "middle", "end"])
+ self.assertEqual(ways.ways(result["settings"], B)["parts"], ["start", "middle", "end"])
+ self.assertEqual(result["settings"]["zones"], [
+ {"peer": A, "kind": "part", "parts": ["start"], "side": "right"},
+ {"peer": B, "kind": "part", "parts": ["end"], "side": "right"},
+ ])
+ self.assertEqual(result["tiles"][A]["state"], "part")
+ self.assertEqual(result["tiles"][B]["state"], "part")
+
+ settings = self.settings(A)
+ settings = self.settings(A, B)
+ result = ways.compile_layout(settings, self.picture(settings, A, self.tile(320, 0, 160, 100), B, self.tile(480, 0, 160, 100)), now=10)
+ self.assertEqual(result["tiles"][B]["state"], "set-elsewhere")
+
+ settings = self.settings(A)
+ result = ways.compile_layout(settings, self.picture(settings, A, self.tile(160, 33, 160, 34)), now=10)
+ self.assertEqual(result["tiles"][A]["thirds"], ["middle"])
+
+ settings = self.settings(A)
+ result = ways.compile_layout(settings, self.picture(settings, A, self.tile(160, 15, 160, 36)), now=10)
+ self.assertEqual(result["tiles"][A]["thirds"], ["start", "middle"])
+
+ def test_fourth_contact_on_one_side_is_refused(self):
+ settings = self.settings(A, B, C, D)
+ layout = self.picture(settings,
+ D, self.tile(160, 51, 160, 17), A, self.tile(160, 0, 160, 17),
+ B, self.tile(160, 17, 160, 17), C, self.tile(160, 34, 160, 17))
+ result = ways.compile_layout(settings, layout, moved=A, now=10)
+ self.assertFalse(result["accepted"])
+ self.assertEqual(set(result["snap"]), {A})
+ self.assertEqual(result["tiles"][A]["state"], "overlap")
+ self.assertEqual(result["snap"][A], ways.snap_position(layout[A], settings["machine_id"],
+ {k: v for k, v in layout.items() if k != A}))
+
+ def test_unplaced_picture_peer_derives_no_side_and_keeps_its_ways(self):
+ settings = self.settings(A)
+ settings["peers"][0]["side"] = "left"
+ settings["zones"] = [{"peer": A, "kind": "edge"}, {"peer": A, "kind": "notch"}]
+ result = ways.compile_layout(settings, self.picture(settings, A, self.tile(400, 0, 160, 100)), now=10)
+ self.assertTrue(result["accepted"])
+ compiled = result["settings"]
+ self.assertEqual(compiled["peers"][0]["side"], "")
+ self.assertEqual(ways.ways(compiled, A)["methods"], ["edge", "notch"])
+ self.assertEqual(compiled["zones"], [])
+
+ def test_place_beside_centres_the_tile_for_a_whole_edge_and_keeps_its_fields(self):
+ layout = {"T": self.tile(0, 0, 160, 100), A: {**self.tile(700, 300, 160, 100), "name": "A"}}
+ self.assertEqual(ways.place_beside(layout, "T", A, "right"), {**self.tile(160, 0, 160, 100), "name": "A"})
+ self.assertEqual(ways.place_beside(layout, "T", A, "top"), {**self.tile(0, -100, 160, 100), "name": "A"})
+ layout[B] = self.tile(160, 0, 160, 100)
+ moved = ways.place_beside(layout, "T", A, "right")
+ self.assertFalse(ways._overlaps(moved, layout[B]))
+ self.assertEqual(moved["name"], "A")
+
+ def test_overlap_refused_with_nearest_free_snap(self):
+ near = ways.snap_position(self.tile(162, -50, 160, 100), "T",
+ {"T": self.tile(0, 0, 160, 100)}, radius=12)
+ self.assertEqual(near, self.tile(160, -50, 160, 100))
+ occupied = {"T": self.tile(0, 0, 160, 100), A: self.tile(160, 0, 160, 100)}
+ target = self.tile(160, 0, 160, 100)
+ snapped = ways.snap_position(target, "T", occupied, radius=12)
+ self.assertFalse(ways._overlaps(snapped, occupied["T"]))
+ self.assertFalse(ways._overlaps(snapped, occupied[A]))
+ settings = self.settings(A, B)
+ layout = self.picture(settings, A, self.tile(300, 0, 160, 100), B, self.tile(300, 0, 160, 100))
+ result = ways.compile_layout(settings, layout, moved=B, now=10)
+ self.assertFalse(result["accepted"])
+ self.assertEqual(set(result["snap"]), {B})
+ self.assertEqual(result["snap"][B], ways.snap_position(layout[B], settings["machine_id"],
+ {k: v for k, v in layout.items() if k != B}))
+ self.assertFalse(ways._overlaps(result["snap"][B], layout[settings["machine_id"]]))
+ self.assertFalse(ways._overlaps(result["snap"][B], layout[A]))
+ self.assertEqual(result["tiles"][B]["state"], "overlap")
+
+ def test_snap_near_each_side_centre_uses_the_centred_position(self):
+ own = self.tile(0, 0, 160, 100)
+ layout = {"T": own}
+ positions = {"left": (-80, 30), "right": (160, 30),
+ "top": (40, -40), "bottom": (40, 100)}
+
+ for side, (x, y) in positions.items():
+ with self.subTest(side=side):
+ dropped = self.tile(x+3, y-3, 80, 40)
+ self.assertEqual(ways.snap_position(dropped, "T", layout, radius=4),
+ self.tile(x, y, 80, 40))
+
+ def test_snap_supports_both_flush_alignments_on_each_side(self):
+ own = self.tile(0, 0, 160, 100)
+ layout = {"T": own}
+ positions = ((160, 0), (160, 60), (-80, 0), (-80, 60),
+ (0, -40), (80, -40), (0, 100), (80, 100))
+
+ for x, y in positions:
+ with self.subTest(position=(x, y)):
+ dropped = self.tile(x+3, y+3, 80, 40)
+ self.assertEqual(ways.snap_position(dropped, "T", layout, radius=6),
+ self.tile(x, y, 80, 40))
+
+ def test_snap_keeps_existing_third_marks(self):
+ own = self.tile(0, 0, 160, 100)
+ layout = {"T": own}
+ expected = self.tile(160, 13, 80, 40)
+ dropped = self.tile(162, 14, 80, 40)
+
+ self.assertEqual(ways.snap_position(dropped, "T", layout), expected)
+
+ def test_snap_prefers_centred_candidate_when_a_third_mark_is_equally_near(self):
+ own = self.tile(0, 0, 160, 120)
+ layout = {"T": own}
+ dropped = self.tile(160, 30, 160, 80)
+
+ self.assertEqual(ways.snap_position(dropped, "T", layout), self.tile(160, 20, 160, 80))
+
+ def test_centred_snap_radius_is_larger_than_other_candidates(self):
+ own = self.tile(0, 0, 160, 100)
+ layout = {"T": own}
+ dropped = self.tile(160, 38, 80, 40)
+
+ self.assertTrue(ways.within_snap_radius(dropped, self.tile(160, 30, 80, 40), "T", layout, 6))
+ self.assertFalse(ways.within_snap_radius(dropped, self.tile(160, 13, 80, 40), "T", layout, 6))
+
+ def test_snap_uses_nearest_free_candidate_when_centre_is_occupied(self):
+ own = self.tile(0, 0, 160, 100)
+ centred = self.tile(160, 40, 80, 20)
+ layout = {"T": own, A: centred}
+ dropped = dict(centred)
+
+ snapped = ways.snap_position(dropped, "T", layout, radius=12)
+
+ self.assertNotEqual(snapped, centred)
+ self.assertFalse(ways._overlaps(snapped, own))
+ self.assertFalse(ways._overlaps(snapped, layout[A]))
+ self.assertEqual(snapped, ways.snap_position(dropped, "T", layout, radius=math.inf))
+
+ def test_overlap_marks_only_the_involved_tiles_and_keeps_other_contacts(self):
+ settings = self.settings(A, B, C)
+ layout = self.picture(settings, A, self.tile(160, 0, 160, 100),
+ B, self.tile(400, 0, 160, 100), C, self.tile(400, 0, 160, 100))
+
+ result = ways.compile_layout(settings, layout, capable={A, B, C}, now=10)
+
+ self.assertTrue(result["accepted"])
+ self.assertEqual(result["tiles"][A]["state"], "edge")
+ for peer, other in ((B, C), (C, B)):
+ self.assertEqual(result["tiles"][peer]["state"], "overlap")
+ self.assertEqual(result["tiles"][peer]["overlap_with"], other)
+ self.assertEqual(result["tiles"][peer]["sentence_keys"], ["overlap"])
+
+ def test_overlapping_tiles_keep_intent_but_generate_no_zones(self):
+ settings = self.settings(A, B)
+ for peer in (A, B):
+ next(entry for entry in settings["peers"] if entry["id"] == peer)["side"] = "left"
+ settings["zones"] = [{"peer": A, "kind": "edge"}, {"peer": B, "kind": "edge", "off": True}]
+ layout = self.picture(settings, A, self.tile(-160, 0, 160, 100), B, self.tile(-160, 50, 160, 100))
+
+ result = ways.compile_layout(settings, layout, now=10)
+
+ self.assertEqual(result["tiles"][A]["state"], "overlap")
+ self.assertEqual(result["tiles"][B]["state"], "overlap")
+ self.assertEqual(ways.ways(result["settings"], A)["methods"], ["edge"])
+ self.assertEqual(ways.ways(result["settings"], B)["methods"], [])
+ self.assertEqual(result["settings"]["zones"], [])
+
+ def test_rc7_shape_keeps_pc_crossing_and_names_the_overlapping_pair(self):
+ own, pc, laptop, fedora = "own", "pc", "laptop", "fedora"
+ settings = {"machine_id": own, "peers": [
+ {"id": pc, "port": 24820, "side": "right", "name": "Studio PC"},
+ {"id": laptop, "port": 24820, "side": "top", "name": "Laptop"},
+ {"id": fedora, "port": 24820, "side": "", "name": "Test box"},
+ ], "zones": [], "layout": {}}
+ settings["peers"][0]["paired_with"] = [fedora]
+ layout = {own: self.tile(332, 0, 160, 100), pc: self.tile(172, 17, 160, 100),
+ laptop: self.tile(359, -100, 160, 100), fedora: self.tile(359, -100, 160, 100)}
+
+ result = ways.compile_layout(settings, layout, capable={own, pc, laptop, fedora}, now=10)
+
+ self.assertTrue(result["accepted"])
+ self.assertEqual(result["tiles"][pc]["state"], "part")
+ self.assertTrue(ways.has_way(result["settings"], pc))
+ self.assertEqual(result["tiles"][laptop]["state"], "overlap")
+ self.assertEqual(result["tiles"][laptop]["overlap_with"], fedora)
+ self.assertEqual(result["layout"].keys(), {own, pc, laptop, fedora})
+
+ def test_missing_own_tile_is_placed_before_compiling_contacts(self):
+ settings = self.settings(A)
+ own = settings["machine_id"]
+ result = ways.compile_layout(settings, {A: self.tile(160, 0, 160, 100)}, now=10)
+
+ self.assertTrue(result["accepted"])
+ self.assertEqual(result["layout"][own], self.tile(0, 0, 160, 100))
+ self.assertEqual(result["tiles"][A]["state"], "edge")
+
+ def test_compiling_active_peers_preserves_shelved_peer_intent_without_zones(self):
+ settings = self.settings(A, B)
+ next(peer for peer in settings["peers"] if peer["id"] == B)["left_out"] = True
+ remembered = {"peer": B, "kind": "part", "parts": ["start"]}
+ settings["zones"] = [dict(remembered)]
+ result = ways.compile_layout(settings, self.picture(settings, A, self.tile(160, 0, 160, 100)), now=10)
+ self.assertTrue(result["accepted"])
+ self.assertFalse(any(zone["peer"] == B for zone in result["settings"]["zones"]))
+ self.assertEqual(ways.ways(result["settings"], B)["parts"], ["start"])
+
+ def test_derive_matches_legacy_mac_placement_examples(self):
+ arrangements = [
+ [("right", None)], [("left", None), ("right", None)],
+ [("right", 2), ("right", 0)], [("right", None), ("top", None)],
+ ]
+ recorded = [
+ ((179.0, 142.5, 120.0, 75.0), [(309.0, 148.5, 112.0, 63.0)]),
+ ((240.0, 142.5, 120.0, 75.0), [(118.0, 148.5, 112.0, 63.0), (370.0, 148.5, 112.0, 63.0)]),
+ ((207.0, 142.5, 120.0, 75.0), [(337.0, 183.0, 56.0, 31.5), (337.0, 145.5, 56.0, 31.5)]),
+ ((179.0, 179.0, 120.0, 75.0), [(309.0, 185.0, 112.0, 63.0), (183.0, 106.0, 112.0, 63.0)]),
+ ]
+ from mac_app import pages
+ self.assertIs(pages.diagram_layout, ways.diagram_layout)
+ for machines in arrangements:
+ with self.subTest(machines=machines):
+ index = arrangements.index(machines)
+ self.assertEqual(ways.diagram_layout(600, 360, machines), recorded[index])
+ self.assertEqual(pages.diagram_layout(600, 360, machines), recorded[index])
+
+ def test_saved_peer_tiles_are_authoritative_when_deriving_layout(self):
+ settings = self.settings(A, B)
+ settings["peers"][0]["paired_with"] = [C]
+ settings["peers"][0]["side"] = "right"
+ settings["layout"] = {settings["machine_id"]: self.tile(0, 0, 160, 100),
+ A: self.tile(172, 0, 160, 100),
+ B: self.tile(-172, 40, 160, 100),
+ C: {**self.tile(400, 0, 160, 100), "name": "Test box"}}
+
+ layout = ways.derive_layout(settings)
+
+ self.assertEqual(layout[A], settings["layout"][A])
+ self.assertEqual(layout[B], settings["layout"][B])
+ self.assertEqual(layout[C], settings["layout"][C])
+
+ def test_missing_peer_avoids_saved_tiles_and_keeps_saved_metadata(self):
+ settings = self.settings(A, B)
+ own = settings["machine_id"]
+ saved = {**self.tile(0, 100, 160, 100), "name": "Saved Mac",
+ "displays": {"main": {"x": 0, "y": 0, "w": 160, "h": 100}},
+ "display_offsets": {"main": {"x": 10, "y": 0}}}
+ settings["peers"][0]["side"] = "bottom"
+ settings["layout"] = {own: self.tile(0, 0, 160, 100), A: saved}
+
+ layout = ways.derive_layout(settings, gap=0)
+
+ self.assertEqual(layout[A], {**self.tile(0, 100, 160, 100), "displays": saved["displays"],
+ "display_offsets": saved["display_offsets"], "name": "Saved Mac"})
+ self.assertFalse(ways._overlaps(layout[B], layout[own]))
+ self.assertFalse(ways._overlaps(layout[B], layout[A]))
+ self.assertIsNotNone(ways._rect_contact(layout[own], layout[B]))
+
+ def test_a_shelved_peers_kept_tile_never_blocks_an_active_peers_side(self):
+ settings = self.settings(A, B)
+ own = settings["machine_id"]
+ settings["peers"][0].update(side="right", left_out=True)
+ settings["peers"][1]["side"] = "right"
+ settings["layout"] = {own: self.tile(0, 0, 160, 100), A: self.tile(160, 0, 160, 100)}
+
+ layout = ways.derive_layout(settings, gap=0)
+
+ self.assertEqual(layout[B], self.tile(160, 0, 160, 100))
+ self.assertEqual(layout[A], self.tile(160, 0, 160, 100))
+
+ def test_rc13_right_peer_fills_free_snap_beside_saved_left_peer(self):
+ settings = self.settings(A, B)
+ own = settings["machine_id"]
+ settings["peers"][0]["side"] = "left"
+ settings["peers"][1]["side"] = "right"
+ settings["layout"] = {own: self.tile(-500, 149, 160, 100),
+ A: self.tile(-660, 149, 160, 100)}
+
+ layout = ways.derive_layout(settings, gap=0)
+
+ self.assertEqual(layout[B], self.tile(-340, 149, 160, 100))
+ self.assertEqual(layout[A], settings["layout"][A])
+
+ def test_layout_keeps_only_named_third_parties_listed_by_active_desktops(self):
+ settings = self.settings(A, B)
+ settings["peers"][0]["paired_with"] = [C, D]
+ settings["layout"].update({
+ A: self.tile(160, 0, 160, 100),
+ B: self.tile(320, 0, 160, 100),
+ C: {**self.tile(480, 0, 160, 100), "name": "Test box"},
+ D: self.tile(640, 0, 160, 100),
+ })
+
+ layout = ways.derive_layout(settings)
+
+ self.assertEqual(set(layout), {settings["machine_id"], A, B, C})
+ self.assertEqual(layout[C]["name"], "Test box")
+
+ def test_rc7_ghost_tiles_are_pruned_and_not_derived_or_fabricated(self):
+ own, pc, laptop, phone, box, old_pc = "M", "PC", "LAPTOP", "PHONE", "BOX", "OLDPC"
+ settings = {"machine_id": own, "peers": [
+ {"id": pc, "port": 24820, "left_out": True, "paired_with": [phone, box]},
+ {"id": laptop, "port": 24820, "paired_with": [old_pc]},
+ ], "zones": [], "layout": {
+ own: self.tile(0, 0, 160, 100), pc: {**self.tile(172, 0, 160, 100), "vouched_by": laptop},
+ laptop: self.tile(344, 0, 160, 100),
+ phone: {**self.tile(516, 0, 160, 100), "vouched_by": pc},
+ box: {**self.tile(688, 0, 160, 100), "vouched_by": pc},
+ old_pc: {**self.tile(860, 0, 160, 100), "vouched_by": laptop},
+ }, "layout_set_at": 5, "layout_by": "before"}
+
+ self.assertTrue(ways.prune_layout(settings, now=10))
+ self.assertTrue({phone, box, old_pc}.isdisjoint(settings["layout"]))
+ self.assertNotIn("vouched_by", settings["layout"][pc])
+ self.assertFalse({phone, box, old_pc} & set(ways.derive_layout(settings)))
+ incoming = {own: self.tile(0, 0, 160, 100), pc: self.tile(172, 0, 160, 100)}
+ retained = ways.retain_held_peer_tiles(settings, incoming, settings["layout"])
+ self.assertTrue({phone, box, old_pc}.isdisjoint(retained))
+ received = {**incoming, **{ghost: self.tile(900, 0, 160, 100) for ghost in (phone, box, old_pc)}}
+ retained = ways.retain_held_peer_tiles(settings, incoming, settings["layout"], received)
+ self.assertEqual(set(retained), {own, pc, laptop})
+
+ def test_named_third_party_tile_requires_a_live_non_shelved_peer(self):
+ own, pc, box = "M", "PC", "BOX"
+ settings = {"machine_id": own, "peers": [
+ {"id": pc, "port": 24820, "paired_with": [box]},
+ ], "zones": [], "layout": {
+ own: self.tile(0, 0, 160, 100), pc: self.tile(172, 0, 160, 100),
+ box: {**self.tile(344, 0, 160, 100), "name": "Test box"},
+ }}
+
+ self.assertIn(box, ways.derive_layout(settings))
+ settings["peers"][0]["paired_with"] = []
+ self.assertNotIn(box, ways.derive_layout(settings))
+ settings["peers"][0]["paired_with"] = [box]
+ settings["peers"][0]["in_use"] = False
+ self.assertNotIn(box, ways.derive_layout(settings))
+ settings["peers"][0]["in_use"] = True
+ settings["peers"][0]["dormant"] = True
+ self.assertNotIn(box, ways.derive_layout(settings))
+ settings["peers"][0]["dormant"] = False
+ settings["peers"][0]["left_out"] = True
+ self.assertNotIn(box, ways.derive_layout(settings))
+
+ def test_pruning_strips_vouch_metadata_without_restamping(self):
+ settings = self.settings(A)
+ own = settings["machine_id"]
+ settings["layout"][own]["vouched_by"] = A
+ settings["layout_set_at"] = 5
+
+ self.assertTrue(ways.prune_layout(settings, now=10))
+ self.assertNotIn("vouched_by", settings["layout"][own])
+ self.assertEqual(settings["layout_set_at"], 5)
+ self.assertNotIn("layout_by", settings)
+
+ def test_compile_layout_drops_an_unvouched_stale_tile_before_contact_checks(self):
+ settings = self.settings(A)
+ layout = self.picture(settings, A, self.tile(160, 0, 160, 100),
+ D, self.tile(160, 0, 160, 100))
+
+ result = ways.compile_layout(settings, layout, now=10)
+
+ self.assertTrue(result["accepted"])
+ self.assertNotIn(D, result["tiles"])
+ self.assertNotIn(D, result["settings"]["layout"])
+
+ def test_pruning_stamps_the_cleaned_shared_picture(self):
+ settings = self.settings(A)
+ own = settings["machine_id"]
+ settings["peers"][0]["paired_with"] = [C]
+ settings["layout"] = {own: self.tile(0, 0, 160, 100),
+ A: self.tile(160, 0, 160, 100),
+ C: {**self.tile(320, 0, 160, 100), "name": "Test box"},
+ D: self.tile(480, 0, 160, 100)}
+ settings["layout_set_at"] = 5
+
+ self.assertTrue(ways.prune_layout(settings, now=10))
+
+ self.assertEqual(set(settings["layout"]), {own, A, C})
+ self.assertGreater(settings["layout_set_at"], 5)
+ self.assertEqual(settings["layout_by"], own)
+
+ def test_named_third_party_tile_survives_while_its_direct_peer_lists_it(self):
+ own, pc, laptop, box = "BQUFBQUFBQUFBQUFBQUFBQ", "BgYGBgYGBgYGBgYGBgYGBg", \
+ "CAgICAgICAgICAgICAgICA", "BwcHBwcHBwcHBwcHBwcHBw"
+ settings = {"machine_id": own, "peers": [
+ {"id": pc, "port": 24820, "paired_with": [box]},
+ ], "layout_set_at": 5, "layout": {
+ own: self.tile(0, 0, 160, 100), pc: self.tile(172, 0, 160, 100),
+ box: {**self.tile(344, 0, 160, 100), "name": "Test box"},
+ laptop: {**self.tile(516, 0, 160, 100), "name": "Laptop"},
+ }}
+
+ ways.prune_layout(settings, now=10)
+
+ self.assertEqual(set(settings["layout"]), {own, pc, box})
+
+ def test_named_third_party_is_dropped_when_its_peer_no_longer_lists_it(self):
+ own, mac, laptop, fedora = "BgYGBgYGBgYGBgYGBgYGBg", "BQUFBQUFBQUFBQUFBQUFBQ", \
+ "CAgICAgICAgICAgICAgICA", "BwcHBwcHBwcHBwcHBwcHBw"
+ settings = {"machine_id": own, "peers": [
+ {"id": mac, "port": 24820, "paired_with": [laptop]},
+ {"id": fedora, "port": 24820, "paired_with": [mac]},
+ ], "layout": {ident: self.tile(index * 172, 0, 160, 100)
+ for index, ident in enumerate((own, mac, fedora, laptop))}}
+ settings["layout"][laptop]["name"] = "Laptop"
+
+ ways.prune_layout(settings, now=10)
+ self.assertIn(laptop, settings["layout"])
+ settings["peers"][0]["paired_with"] = []
+ ways.prune_layout(settings, now=11)
+ self.assertNotIn(laptop, settings["layout"])
+
+ def test_received_layout_restores_missing_locally_held_peer_tiles(self):
+ own, pc, fedora = "BQUFBQUFBQUFBQUFBQUFBQ", "BgYGBgYGBgYGBgYGBgYGBg", "BwcHBwcHBwcHBwcHBwcHBw"
+ settings = {"machine_id": own, "peers": [
+ {"id": pc, "port": 24820, "side": "right", "paired_with": [fedora]},
+ ], "zones": [], "layout": {
+ own: self.tile(0, 0, 160, 100), pc: self.tile(172, 0, 160, 100),
+ fedora: {**self.tile(344, 0, 160, 100), "name": "Test box"},
+ }}
+ incoming = {own: self.tile(0, 0, 160, 100), pc: self.tile(172, 0, 160, 100)}
+
+ merged = ways.retain_held_peer_tiles(settings, incoming, settings["layout"])
+
+ self.assertEqual(merged[fedora], settings["layout"][fedora])
+
+ def test_received_layout_places_a_missing_held_peer_by_its_default_side(self):
+ own, peer = self.ident(50), self.ident(1)
+ settings = {"machine_id": own, "peers": [
+ {"id": peer, "port": 24820, "side": "right", "paired_with": []},
+ ], "zones": [], "layout": {own: self.tile(0, 0, 160, 100)}}
+
+ merged = ways.retain_held_peer_tiles(settings, {own: self.tile(0, 0, 160, 100)}, settings["layout"])
+
+ # Flush, so it touches and keeps crossing; a 12 gap left it with no contact and no side.
+ self.assertEqual(merged[peer], self.tile(160, 0, 160, 100))
+
+ def test_received_layout_keeps_a_present_shelved_peer_tile_exactly(self):
+ own, peer, shelf = self.ident(50), self.ident(1), self.ident(2)
+ received = {shelf: {**self.tile(160, 0, 160, 100), "name": "Shelf"}}
+ settings = {"machine_id": own, "peers": [
+ {"id": peer, "port": 24820, "side": "right", "paired_with": []},
+ {"id": shelf, "port": 24820, "side": "right", "left_out": True, "paired_with": []},
+ ], "zones": [], "layout": {
+ own: self.tile(0, 0, 160, 100), peer: self.tile(172, 0, 160, 100),
+ shelf: self.tile(344, 0, 160, 100),
+ }}
+
+ merged = ways.retain_held_peer_tiles(
+ settings, {own: self.tile(0, 0, 160, 100), peer: self.tile(160, 0, 160, 100)},
+ settings["layout"], received)
+
+ self.assertEqual(merged[shelf], received[shelf])
+
+ def test_rc7_shared_picture_keeps_only_named_thirds_in_the_current_paired_list(self):
+ own, peer, third = "M", "PC", "BOX"
+ settings = {"machine_id": own, "peers": [
+ {"id": peer, "port": 24820, "side": "left", "paired_with": [third]},
+ ], "zones": [], "layout": {own: self.tile(0, 0, 100, 100)}}
+ layout = {own: self.tile(0, 0, 100, 100), peer: self.tile(112, 0, 100, 100),
+ third: {**self.tile(224, 0, 100, 100), "name": "Test box"}}
+
+ result = ways.compile_layout(settings, layout, capable={own, peer, third}, now=10)
+
+ self.assertTrue(result["accepted"])
+ self.assertIn(third, result["layout"])
+ self.assertNotIn("vouched_by", result["layout"][third])
+ result["settings"]["peers"][0]["paired_with"] = []
+ ways.prune_layout(result["settings"], now=11)
+ self.assertNotIn(third, result["settings"]["layout"])
+
+ def test_arrangement_inverse_repositions_peer_from_new_side(self):
+ settings = self.settings(A)
+ layout = self.picture(settings, A, self.tile(160, 0, 160, 33))
+ settings = ways.compile_layout(settings, layout, now=10)["settings"]
+ settings["layout"][settings["machine_id"]]["x"] = 500
+ changed = ways.arrangement(settings, A, "left", 20, self.ident(8), "this PC")
+ self.assertTrue(changed[0])
+ updated = settings["layout"]
+ self.assertEqual(updated[A]["x"], 660)
+ self.assertIsNotNone(ways._rect_contact(updated[settings["machine_id"]], updated[A]))
+
+ def test_inverse_repositions_all_peers_on_old_and_new_sides_without_overlap(self):
+ settings = self.settings(A, B, C)
+ settings["peers"][0]["side"] = "right"
+ settings["peers"][1]["side"] = "right"
+ settings["peers"][2]["side"] = "top"
+ layout = self.picture(settings, A, self.tile(172, 0, 160, 100), B, self.tile(172, 112, 160, 100),
+ C, self.tile(0, -112, 160, 100))
+ settings["layout"] = layout
+ settings["peers"][0]["side"] = "left"
+ updated = ways.inverse_layout(settings, layout, peer=A)
+ for one, tile in updated.items():
+ for two, other in updated.items():
+ if one < two:
+ self.assertFalse(ways._overlaps(tile, other), (one, two, tile, other))
+ self.assertEqual(updated[B], layout[B])
+ self.assertEqual(updated[C], layout[C])
+
+ def test_set_elsewhere_only_when_a_peer_lacks_layout_capability(self):
+ settings = self.settings(A, B)
+ layout = self.picture(settings, A, self.tile(320, 0, 160, 100), B, self.tile(480, 0, 160, 100))
+ result = ways.compile_layout(settings, layout, capable={A, B}, now=10)
+ self.assertEqual(result["tiles"][A]["state"], "between")
+ self.assertEqual(result["tiles"][B]["state"], "between")
+ self.assertEqual(result["tiles"][A]["sentence_keys"], ["between"])
+ self.assertEqual(ways.ATLAS_SENTENCES["between"], "Crosses between {first} and {second}.")
+ self.assertEqual(ways.ATLAS_SENTENCES["set_elsewhere"], "Set on {first} or {second}.")
+
+ def test_single_tile_model_has_no_second_contact_sentence(self):
+ self.assertNotIn("second_contact", ways.ATLAS_SENTENCES)
+
+ def test_compiled_layout_stamp_round_trips_as_base64_by(self):
+ settings = self.settings(A)
+ layout = self.picture(settings, A, self.tile(160, 0, 160, 100))
+ result = ways.compile_layout(settings, layout, moved=A, now=10)
+ self.assertEqual(result["settings"]["layout_by"], result["settings"]["machine_id"])
+ state = {"set_at": result["settings"]["layout_set_at"],
+ "by": result["settings"]["layout_by"], "tiles": result["settings"]["layout"]}
+ data = settings_sync.message_data(False, 5, by=self.ident(2), layout_state=state)
+ self.assertEqual(settings_sync.read_layout_state(data, now=10), state)
+
+ def test_layout_settings_sync_newest_clock_relay_and_capability(self):
+ state = {"set_at": 10, "by": self.ident(1), "tiles": {A: self.tile(1, 2, 160, 100)}}
+ data = settings_sync.message_data(False, 5, by=self.ident(2), layout_state=state)
+ self.assertEqual(settings_sync.read_layout_state(data, now=10)["set_at"], 10)
+ self.assertIsNone(settings_sync.read_layout_state(data, now=10 - settings_sync.DAY - 1))
+ self.assertTrue(settings_sync.layout_arrived(state, 9, self.ident(2)))
+ self.assertFalse(settings_sync.layout_arrived(state, 10, self.ident(2)))
+ same_time_later_author = dict(state, by=self.ident(3))
+ self.assertTrue(settings_sync.layout_arrived(same_time_later_author, 10, self.ident(2)))
+ self.assertEqual(settings_sync.layout_recipients({A: {"settings", "layout"}, B: {"settings"}}), [A])
+ self.assertNotIn("layout", settings_sync.for_capabilities(data, {"settings"}))
+ self.assertIn("layout", settings_sync.for_capabilities(data, {"settings", "layout"}))
+
+ def test_layout_state_carries_validated_display_rectangles(self):
+ displays = {"panel-left": {"x": -1280, "y": 0, "w": 1280, "h": 800},
+ "panel-right": {"x": 0, "y": 0, "w": 1920, "h": 1080}}
+ tiles = {A: dict(self.tile(0, 0, 160, 100), displays=displays)}
+ state = {"set_at": 10, "by": self.ident(1), "tiles": tiles}
+ data = settings_sync.message_data(False, 5, by=self.ident(2), layout_state=state)
+ self.assertEqual(settings_sync.read_layout_state(data, now=10)["tiles"][A]["displays"], displays)
+ malformed_tiles = {A: dict(self.tile(0, 0, 160, 100),
+ displays={"panel-left": {"x": -1280, "y": 0, "w": 0, "h": 800}})}
+ malformed = dict(state, tiles=malformed_tiles)
+ self.assertIsNone(settings_sync.read_layout_state(
+ settings_sync.message_data(False, 5, by=self.ident(2), layout_state=malformed), now=10))
+ newer = settings_sync.for_capabilities(data, {"settings", "layout", "displays"})
+ older = settings_sync.for_capabilities(data, {"settings", "layout"})
+ self.assertIn("displays", newer["layout"]["tiles"][A])
+ self.assertNotIn("displays", older["layout"]["tiles"][A])
+
+ def test_layout_state_carries_the_machine_name_for_third_party_tiles(self):
+ settings = self.settings(A)
+ tiles = self.picture(settings, A, {**self.tile(160, 0, 160, 100), "name": "Test box"})
+ data = settings_sync.message_data(False, 5, by=self.ident(2),
+ layout_state={"set_at": 5, "by": self.ident(2), "tiles": tiles})
+
+ parsed = settings_sync.read_layout_state(data, now=10)
+
+ self.assertEqual(parsed["tiles"][A]["name"], "Test box")
+
+ def test_blank_optional_tile_name_is_dropped_without_rejecting_other_tiles(self):
+ tiles = {A: {**self.tile(0, 0, 160, 100), "name": " "},
+ B: self.tile(160, 0, 160, 100)}
+ data = settings_sync.message_data(False, 5, by=self.ident(2),
+ layout_state={"set_at": 5, "by": self.ident(2), "tiles": tiles})
+
+ parsed = settings_sync.read_layout_state(data, now=10)
+
+ self.assertEqual(set(parsed["tiles"]), {A, B})
+ self.assertNotIn("name", parsed["tiles"][A])
+
+ def test_a_peer_between_two_displays_compiles_two_local_edges(self):
+ settings = self.settings(A)
+ layout = {
+ settings["machine_id"]: {
+ "x": 0, "y": 0, "w": 300, "h": 100,
+ "displays": {
+ "panel-left": {"x": 0, "y": 0, "w": 100, "h": 100},
+ "panel-right": {"x": 200, "y": 0, "w": 100, "h": 100},
+ },
+ },
+ A: self.tile(100, 0, 100, 100),
+ }
+ result = ways.compile_layout(settings, layout, now=10)
+ zones = [zone for zone in result["settings"]["zones"] if zone["peer"] == A and zone["kind"] == "edge"]
+ self.assertEqual([(zone["display"], zone["side"]) for zone in zones],
+ [("panel-left", "right"), ("panel-right", "left")])
+ self.assertEqual(result["settings"]["peers"][0]["side"], "right")
+
+ def test_rc6_saved_display_layout_keeps_the_mac_and_pc_edge_and_the_laptop_edge(self):
+ own, pc, laptop, fedora = "BQUFBQUFBQUFBQUFBQUFBQ", "BgYGBgYGBgYGBgYGBgYGBg", \
+ "CAgICAgICAgICAgICAgICA", "BwcHBwcHBwcHBwcHBwcHBw"
+ settings = {"machine_id": own, "peers": [
+ {"id": pc, "port": 24820, "side": "left", "name": "Studio PC"},
+ {"id": laptop, "port": 24820, "side": "bottom", "name": "Laptop"},
+ ], "zones": [
+ {"peer": pc, "kind": "edge", "display": "0", "side": "left", "target_side": "right", "off": True},
+ {"peer": pc, "kind": "part", "parts": ["middle", "end"], "display": "0", "side": "left", "target_side": "right"},
+ {"peer": laptop, "kind": "edge", "display": "0", "side": "bottom", "target_side": "top", "off": True},
+ {"peer": laptop, "kind": "part", "parts": ["middle", "end"], "display": "0", "side": "bottom", "target_side": "top"},
+ ]}
+ settings["peers"][0]["paired_with"] = [fedora]
+ layout = {
+ own: {"x": 332, "y": 0, "w": 160, "h": 100,
+ "displays": {"0": {"x": 0, "y": 0, "w": 1728, "h": 1117}}},
+ pc: self.tile(172, 17, 160, 100),
+ laptop: self.tile(359, 100, 160, 100),
+ fedora: {**self.tile(359, -100, 160, 100), "name": "Test box"},
+ }
+
+ result = ways.compile_layout(settings, layout, capable={own, pc, laptop, fedora}, now=10)
+
+ self.assertTrue(result["accepted"])
+ self.assertIn(result["tiles"][pc]["state"], ("edge", "part"))
+ self.assertIn(result["tiles"][laptop]["state"], ("edge", "part"))
+ self.assertTrue(ways.has_way(result["settings"], pc))
+ self.assertTrue(ways.has_way(result["settings"], laptop))
+ self.assertEqual(result["layout"][fedora]["name"], "Test box")
+
+ def test_shared_picture_accepts_named_third_party_in_current_paired_list(self):
+ own, peer, third = "BQUFBQUFBQUFBQUFBQUFBQ", "BgYGBgYGBgYGBgYGBgYGBg", "BwcHBwcHBwcHBwcHBwcHBw"
+ settings = {"machine_id": own, "peers": [{"id": peer, "port": 24820, "side": "left",
+ "paired_with": [third]}], "zones": []}
+ layout = {
+ own: self.tile(0, 0, 100, 100),
+ peer: self.tile(112, 0, 100, 100),
+ third: {**self.tile(224, 0, 100, 100), "name": "Test box"},
+ }
+
+ result = ways.compile_layout(settings, layout, capable={own, peer, third}, now=10)
+
+ self.assertTrue(result["accepted"])
+ self.assertIn(third, result["layout"])
+ self.assertNotIn("vouched_by", result["layout"][third])
+
+ saved = result["settings"]
+ saved["layout"] = result["layout"]
+ self.assertIn(third, ways.derive_layout(saved))
+ saved["peers"] = []
+ ways.prune_layout(saved, now=11)
+ self.assertNotIn(third, saved["layout"])
+
+ def test_new_layout_peers_are_placed_touching_the_local_machine(self):
+ settings = self.settings(A)
+ settings["peers"][0]["side"] = ""
+
+ layout = ways.derive_layout(settings)
+
+ self.assertIsNotNone(ways._rect_contact(layout[settings["machine_id"]], layout[A]))
+
+ def test_reporting_a_display_change_updates_the_shared_layout_stamp_once(self):
+ settings = self.settings(A)
+ settings["layout"] = {settings["machine_id"]: self.tile(0, 0, 160, 100),
+ A: self.tile(172, 0, 160, 100)}
+ displays = {"0": ways.return_edge.Rect(-100, 0, 100, 100),
+ "1": ways.return_edge.Rect(0, 0, 200, 100)}
+ self.assertTrue(ways.refresh_displays(settings, displays, now=10))
+ self.assertEqual(settings["layout"][settings["machine_id"]]["displays"],
+ {key: {"x": rect.x, "y": rect.y, "w": rect.width, "h": rect.height}
+ for key, rect in displays.items()})
+ stamp = settings["layout_set_at"]
+ self.assertFalse(ways.refresh_displays(settings, displays, now=11))
+ self.assertEqual(settings["layout_set_at"], stamp)
+
+ def test_split_display_offsets_move_one_panel_without_changing_its_reported_geometry(self):
+ tile = {
+ "x": 10, "y": 20, "w": 300, "h": 100,
+ "displays": {
+ "left": {"x": 0, "y": 0, "w": 100, "h": 100},
+ "right": {"x": 100, "y": 0, "w": 200, "h": 100},
+ },
+ "display_offsets": {"right": {"x": 25, "y": -10}},
+ }
+ frames = {frame["display"]: frame for frame in ways._display_frames(tile)}
+ self.assertEqual((frames["left"]["x"], frames["left"]["y"]), (10, 20))
+ self.assertEqual((frames["right"]["x"], frames["right"]["y"]), (135, 10))
+ self.assertEqual(tile["displays"]["right"], {"x": 100, "y": 0, "w": 200, "h": 100})
+
+ def test_display_offsets_must_name_reported_displays_and_use_integer_offsets(self):
+ valid = {"x": 0, "y": 0, "w": 300, "h": 100,
+ "displays": {"left": {"x": 0, "y": 0, "w": 100, "h": 100}},
+ "display_offsets": {"left": {"x": 1, "y": -2}}}
+ self.assertTrue(ways._valid_tile_displays(valid))
+ for offsets in ({"missing": {"x": 0, "y": 0}}, {"left": {"x": 0, "y": 0.5}}, []):
+ self.assertFalse(ways._valid_tile_displays(dict(valid, display_offsets=offsets)))
+
+ def test_design_sync_remains_optional_without_a_capability_gate(self):
+ design = {"set_at": 10, "by": self.ident(1), "values": {"effect_length": "long"}}
+ data = settings_sync.message_data(False, 5, design_state=design)
+ filtered = settings_sync.for_capabilities(data, {"settings"})
+ self.assertEqual(filtered["design_sync"], design)
+
+ def test_layout_receiver_compiles_its_own_zones(self):
+ settings = self.settings(A)
+ tiles = self.picture(settings, A, self.tile(160, 0, 160, 100))
+ received = {"set_at": 10, "by": self.ident(2), "tiles": tiles}
+ data = settings_sync.message_data(False, 5, by=self.ident(2), layout_state=received)
+ parsed = settings_sync.read_layout_state(data, now=10)
+ self.assertEqual(parsed["tiles"], tiles)
+ result = ways.compile_layout(settings, parsed["tiles"], now=10)
+ self.assertTrue(result["accepted"])
+ self.assertEqual(ways.ways(result["settings"], A)["methods"], ["edge"])
+
+ def test_layout_receiver_preserves_split_display_offsets(self):
+ settings = self.settings(A)
+ tiles = self.picture(settings, A, self.tile(160, 0, 300, 100))
+ tiles[A]["displays"] = {"left": {"x": 0, "y": 0, "w": 100, "h": 100},
+ "right": {"x": 100, "y": 0, "w": 200, "h": 100}}
+ tiles[A]["display_offsets"] = {"right": {"x": 24, "y": -8}}
+ data = settings_sync.message_data(False, 5, layout_state={"set_at": 10, "by": self.ident(2), "tiles": tiles})
+ parsed = settings_sync.read_layout_state(data, now=10)
+ self.assertEqual(parsed["tiles"][A]["display_offsets"], tiles[A]["display_offsets"])
+ old_peer = settings_sync.for_capabilities(data, {"settings", "layout"})
+ self.assertNotIn("display_offsets", old_peer["layout"]["tiles"][A])
+ malformed = copy.deepcopy(data)
+ malformed["layout"]["tiles"][A]["display_offsets"]["ghost"] = {"x": 0, "y": 0}
+ self.assertIsNone(settings_sync.read_layout_state(malformed, now=10))
+
+ @staticmethod
+ def tile(x, y, w, h):
+ return {"x": x, "y": y, "w": w, "h": h}
+
+ @staticmethod
+ def ident(n):
+ import base64
+ return base64.urlsafe_b64encode(bytes([n]) * 16).decode().rstrip("=")
+
+ def settings(self, *peers):
+ own = self.ident(50)
+ entries = [{"id": peer, "side": "", "side_set_at": 0, "side_by": "", "port": 24820,
+ "name": peer, "in_use": True} for peer in peers]
+ return {"machine_id": own, "peers": entries, "zones": [], "layout": {own: self.tile(0, 0, 160, 100)}}
+
+ def picture(self, settings, *items):
+ layout = dict(settings["layout"])
+ layout.update({items[i]: items[i + 1] for i in range(0, len(items), 2)})
+ return layout
+
+
+A = settings_id = "AQEBAQEBAQEBAQEBAQEBAQ"
+B = "AgICAgICAgICAgICAgICAg"
+C = "AwMDAwMDAwMDAwMDAwMDAw"
+D = "BAQEBAQEBAQEBAQEBAQEBA"
+
+
+if __name__ == "__main__":
+ unittest.main()
+
+
+class CrossingStretchTests(unittest.TestCase):
+ own = {"x": 0, "y": 0, "w": 160, "h": 90}
+
+ def test_whole_edge_and_no_thirds_light_the_whole_contact(self):
+ contact = ("right", 0, 90)
+ self.assertEqual(ways.crossing_stretches(contact, self.own, []), [contact])
+ self.assertEqual(ways.crossing_stretches(contact, self.own, ["start", "middle", "end"]), [contact])
+
+ def test_only_the_picked_thirds_light(self):
+ self.assertEqual(ways.crossing_stretches(("right", 0, 90), self.own, ["start"]), [("right", 0, 30)])
+ self.assertEqual(ways.crossing_stretches(("bottom", 0, 160), self.own, ["start", "end"]),
+ [("bottom", 0, 160 / 3), ("bottom", 320 / 3, 160)])
+
+ def test_a_third_outside_the_contact_lights_nothing(self):
+ self.assertEqual(ways.crossing_stretches(("right", 0, 30), self.own, ["end"]), [])
+
+ def test_a_corner_is_untouched(self):
+ contact = ("corner", "top_right", None)
+ self.assertEqual(ways.crossing_stretches(contact, self.own, ["start"]), [contact])
diff --git a/core/tests/test_colour_packs.py b/core/tests/test_colour_packs.py
index 04e0fd0..f964cd8 100644
--- a/core/tests/test_colour_packs.py
+++ b/core/tests/test_colour_packs.py
@@ -1,4 +1,5 @@
"""Colour choices stay stable across platforms and mixed-version links."""
+import colorsys
import unittest
from core import effects, settings_sync
@@ -37,8 +38,12 @@ class ColourPacksTests(unittest.TestCase):
self.assertEqual(effects.pack(value), expected)
self.assertEqual(effects.legible(MONO['mono_graphite'][1], True),
['#6d7278', '#6b727b', '#868c94'])
- self.assertEqual(effects.legible(MONO['mono_ink'][1], True),
- ['#69717d', '#637082', '#69717c'])
+ # Ink stays a deep blue-black on dark: lifted like the rest it became a steel grey lighter
+ # than Graphite, which reads as white once added as light (06-10 and 10-10).
+ self.assertEqual(effects.legible(MONO['mono_ink'][1], True), ['#2c3e66', '#1f2d4d', '#3b5287'])
+ lightness = lambda colour: colorsys.rgb_to_hls(*effects.parse_colour(colour)[:3])[1]
+ ink, graphite = (effects.legible(MONO[value][1], True) for value in ('mono_ink', 'mono_graphite'))
+ self.assertLess(max(map(lightness, ink)), min(map(lightness, graphite)))
self.assertEqual(effects.legible(MONO['mono'][1], False, effects.effect('aperture')),
['#999999', '#969696', '#999999'])
diff --git a/core/tests/test_crossing_e2e.py b/core/tests/test_crossing_e2e.py
new file mode 100644
index 0000000..ed98155
--- /dev/null
+++ b/core/tests/test_crossing_e2e.py
@@ -0,0 +1,555 @@
+"""Crossing end to end (crossing_harness.py): desks paired on loopback, their maps and Crossing pages
+driven as the apps drive them, and every way across pushed through, asserting where input lands.
+
+Every case asserts twice where a change travels: at once, on the machine where it was made, and once
+the desks have exchanged what they send, on both. `SETTLE_LIMIT` bounds how long that may take.
+
+On release/1.5.3 40a0f29 (rc12) 19 of these fail, among them an rc12 report from both machines'
+logs (switch_v6 raising "display and side go together" on the first push back, which disarms the
+way home), display metadata lost from the shared picture, and an endless `arrangement` exchange
+between two PCs diagonal to each other. docs/crossing-model-1.5.2.md has the list."""
+
+import copy
+import itertools
+import time
+import unittest
+from unittest import mock
+
+from core import return_edge, ways
+from core.return_edge import Rect
+from core.tests.crossing_harness import THIRD_AT, Net
+from core.tests.crossing_shells import SHELLS
+
+MAC_DISPLAYS = {"0": Rect(0, 0, 1728, 1117)}
+PC_DISPLAYS = {"0": Rect(0, 0, 3840, 2160)}
+SIDES = ("left", "right", "top", "bottom")
+OPPOSITE = return_edge.OPPOSITE
+SETTLE_LIMIT = 1.0
+THIRD_SETS = [list(combo) for size in (1, 2, 3) for combo in itertools.combinations(return_edge.PARTS, size)]
+
+
+class Desks(unittest.TestCase):
+ DESKS = () # (name, platform, displays, seed)
+
+ def setUp(self):
+ grace = mock.patch.object(return_edge, "ARRIVAL_GRACE_SECONDS", 0.0)
+ grace.start()
+ self.addCleanup(grace.stop)
+ self.net = Net(self, SHELLS)
+ self.desk = {}
+ for name, platform, displays, seed in self.DESKS:
+ self.desk[name] = self.net.add(name, platform, displays, seed)
+ self.net.pair_all()
+ self.net.start()
+
+ def place(self, on, moved, side, shift=0):
+ """`on`'s map: `moved`'s tile dropped centred on `side` of `on`'s own tile, `shift` along it."""
+ own = on.settings["layout"][on.id]
+ tile = on.settings["layout"].get(moved.id) or {"w": moved.tile_size[0], "h": moved.tile_size[1]}
+ w, h = tile["w"], tile["h"]
+ x, y = {"left": (own["x"] - w, own["y"] + (own["h"] - h) // 2 + shift),
+ "right": (own["x"] + own["w"], own["y"] + (own["h"] - h) // 2 + shift),
+ "top": (own["x"] + (own["w"] - w) // 2 + shift, own["y"] - h),
+ "bottom": (own["x"] + (own["w"] - w) // 2 + shift, own["y"] + own["h"])}[side]
+ return on.shell.drop(moved, x, y)
+
+ def settled(self):
+ started = time.monotonic()
+ self.assertTrue(self.net.settle(SETTLE_LIMIT), "the desks did not settle")
+ return time.monotonic() - started
+
+ def assert_agree(self):
+ self.assertEqual(self.net.views_agree(), [])
+ self.assertEqual(self.net.bad_zones(), [])
+
+ def assert_cross(self, holder, side, to, label="", along=0.5, display=None):
+ here = self.net.at(holder)
+ landed = self.net.push(holder, side, along, display)
+ self.assertIs(landed, to, f"{label}: {holder.name}'s pointer on {here.name} through {side} at {along:.2f} "
+ f"went to {landed.name}, not {to.name}")
+ return landed
+
+ def assert_round_trip(self, holder, other, side, label="", along=0.5, back=None):
+ """`holder`'s pointer at home goes through `side` to `other`, lands on the facing side, and comes
+ back through it at `back` of the way along (`along` when the two tiles' contact is the same
+ stretch of both)."""
+ facing = OPPOSITE[side]
+ self.assertIs(self.net.at(holder), holder, label)
+ self.assert_cross(holder, side, other, label, along)
+ self.assertEqual(self.net.landed(other)[1], facing, f"{label}: landed on {other.name}")
+ self.assert_cross(holder, facing, holder, f"{label}, back", along if back is None else back)
+
+
+class Pair(Desks):
+ """A Mac and a PC on one desk: This Mac and DESK-WIN11. The Mac's id is the larger."""
+
+ DESKS = (("This Mac", "mac", MAC_DISPLAYS, 90), ("DESK-WIN11", "pc", PC_DISPLAYS, 60))
+
+ def setUp(self):
+ super().setUp()
+ self.mac, self.pc = self.desk["This Mac"], self.desk["DESK-WIN11"]
+
+
+class Rc12Report(Pair):
+ """10-10, rc12, from both machines' logs: the Mac crossed up to the rig and the rig's first push back
+ raised in switch_v6 ("display and side go together"), leaving its zones disarmed; the user then moved
+ This Mac to the rig's right and back below on the rig's map, and neither crossed until a shortcut
+ re-armed it."""
+
+ def test_the_first_crossing_back_after_pairing_lands_home(self):
+ self.assert_round_trip(self.mac, self.pc, "right", "default side")
+
+ def test_moved_on_the_driven_rigs_map_and_back_every_way_still_crosses(self):
+ self.assertTrue(self.place(self.mac, self.pc, "top"))
+ self.settled()
+ self.assert_cross(self.mac, "top", self.pc, "Mac up to the rig")
+ self.assert_cross(self.mac, "bottom", self.mac, "rig's first push back")
+ self.assert_cross(self.mac, "top", self.pc, "Mac up again")
+ self.assertTrue(self.place(self.pc, self.mac, "right"), "rig's map: Mac to its right")
+ self.assert_cross(self.mac, "right", self.mac, "rig: pushed right at once")
+ self.assert_cross(self.mac, "left", self.pc, "Mac: rig now on its left")
+ self.assertTrue(self.place(self.pc, self.mac, "bottom"), "rig's map: Mac back below")
+ self.assert_cross(self.mac, "bottom", self.mac, "rig: pushed down at once")
+ self.settled()
+ self.assert_agree()
+ self.assert_round_trip(self.mac, self.pc, "top", "after settling")
+ self.assert_round_trip(self.pc, self.mac, "bottom", "the rig's own pointer")
+
+
+class Sides(Pair):
+ """The peer on each side, set on either machine's map; both pointers both ways, at once and after
+ the exchange."""
+
+ def test_each_side_from_the_macs_map(self):
+ for side in SIDES:
+ with self.subTest(side=side):
+ self.assertTrue(self.place(self.mac, self.pc, side))
+ self.assert_round_trip(self.mac, self.pc, side, f"Mac's map, {side}, at once")
+ took = self.settled()
+ self.assert_agree()
+ self.assert_round_trip(self.mac, self.pc, side, f"Mac's map, {side}, settled in {took:.2f}s")
+ self.assert_round_trip(self.pc, self.mac, OPPOSITE[side], f"Mac's map, {side}, the PC's pointer")
+
+ def test_each_side_from_the_pcs_map(self):
+ for side in SIDES:
+ with self.subTest(side=side):
+ self.assertTrue(self.place(self.pc, self.mac, side))
+ self.assert_round_trip(self.pc, self.mac, side, f"PC's map, {side}, at once")
+ took = self.settled()
+ self.assert_agree()
+ self.assert_round_trip(self.pc, self.mac, side, f"PC's map, {side}, settled in {took:.2f}s")
+ self.assert_round_trip(self.mac, self.pc, OPPOSITE[side], f"PC's map, {side}, the Mac's pointer")
+
+
+class Moves(Pair):
+ """A peer moved from side to side and back, on the driving machine's map and on the driven one's
+ while it is driven, each push made at once after the drop."""
+
+ ROUTE = ("top", "left", "top", "bottom", "right", "bottom", "top")
+
+ def test_moved_on_the_drivers_map(self):
+ for index, side in enumerate(self.ROUTE):
+ with self.subTest(step=index, side=side):
+ self.assertTrue(self.place(self.mac, self.pc, side))
+ self.assert_round_trip(self.mac, self.pc, side, f"step {index}, at once")
+ self.settled()
+ self.assert_agree()
+
+ def test_moved_on_the_driven_machines_map_while_driven(self):
+ self.assertTrue(self.place(self.mac, self.pc, "top"))
+ self.settled()
+ for index, side in enumerate(self.ROUTE):
+ with self.subTest(step=index, side=side):
+ facing = OPPOSITE[side]
+ # Drive the PC through the side it is on now, then move the Mac on the PC's map.
+ held = ways.ways(self.mac.settings, self.pc.id)["side"]
+ self.assert_cross(self.mac, held, self.pc, f"step {index}: onto the PC by {held}")
+ self.assertTrue(self.place(self.pc, self.mac, facing), f"step {index}: PC's map, Mac to its {facing}")
+ self.assert_cross(self.mac, facing, self.mac, f"step {index}: back home at once by the PC's {facing}")
+ self.assert_cross(self.mac, side, self.pc, f"step {index}: Mac to the PC by {side}")
+ self.assert_cross(self.mac, facing, self.mac, f"step {index}: and home")
+ self.settled()
+ self.assert_agree()
+
+
+class Thirds(Pair):
+ """Whole edge and every combination of thirds, picked on the page; a third crosses only when
+ picked, and the pick survives drops on either machine's map (rc12: thirds lost on drop)."""
+
+ def test_every_combination_of_thirds(self):
+ self.assertTrue(self.place(self.mac, self.pc, "right"))
+ self.settled()
+ for picked in THIRD_SETS:
+ with self.subTest(picked=picked):
+ methods = ["edge"] if len(picked) == 3 else ["part"]
+ self.assertTrue(self.mac.shell.edit(self.pc, methods, picked))
+ for third, along in THIRD_AT.items():
+ if third in picked:
+ self.assert_round_trip(self.mac, self.pc, "right", f"{picked}, {third}", along)
+ else:
+ self.assertIs(self.net.push(self.mac, "right", along), self.mac, f"{picked}: {third} is a wall")
+
+ def test_a_pick_survives_drops_on_both_maps(self):
+ self.assertTrue(self.place(self.mac, self.pc, "right"))
+ self.settled()
+ self.assertTrue(self.mac.shell.edit(self.pc, ["part"], ["start", "end"]))
+ for label, drop in (("Mac's map, same place", lambda: self.place(self.mac, self.pc, "right")),
+ ("Mac's map, away and back", lambda: self.place(self.mac, self.pc, "bottom")
+ and self.place(self.mac, self.pc, "right")),
+ ("PC's map", lambda: self.place(self.pc, self.mac, "left"))):
+ with self.subTest(label=label):
+ self.assertTrue(drop())
+ self.settled()
+ self.assertEqual(ways.ways(self.mac.settings, self.pc.id)["parts"], ["start", "end"], label)
+ self.assertIs(self.net.push(self.mac, "right", THIRD_AT["middle"]), self.mac, f"{label}: middle")
+ self.assert_round_trip(self.mac, self.pc, "right", f"{label}: start", THIRD_AT["start"])
+
+
+class Corners(Pair):
+ """A corner beside the edge and on its own; brackets are the page's business, crossing is ours."""
+
+ def test_corner_with_the_edge_and_alone(self):
+ self.assertTrue(self.place(self.mac, self.pc, "right"))
+ self.settled()
+ for corner in ("top_right", "bottom_right"):
+ with self.subTest(corner=corner, edge=True):
+ self.assertTrue(self.mac.shell.edit(self.pc, ["edge", "corner"], corner=corner))
+ self.assertIs(self.net.push_corner(self.mac, corner), self.pc, f"{corner} with the edge")
+ self.assertIs(self.net.push(self.mac, "left"), self.mac)
+ self.assert_round_trip(self.mac, self.pc, "right", f"edge beside {corner}")
+ with self.subTest(corner=corner, edge=False):
+ self.assertTrue(self.mac.shell.edit(self.pc, ["corner"], corner=corner))
+ self.assertIs(self.net.push(self.mac, "right"), self.mac, f"{corner} alone: the edge is a wall")
+ self.assertIs(self.net.push_corner(self.mac, corner), self.pc, f"{corner} alone")
+ self.assertIs(self.net.push(self.mac, "left"), self.mac)
+
+
+class Ledger(Pair):
+ """Ledger clicks update both the local engine and a visiting pointer's responder."""
+
+ def assert_ledger_thirds(self, on, other, side, picked, label):
+ for third, along in THIRD_AT.items():
+ with self.subTest(third=third, pointer="own", label=label):
+ self.assertIs(self.net.at(on), on)
+ if third in picked:
+ self.assert_round_trip(on, other, side, label, along)
+ else:
+ self.assertIs(self.net.push(on, side, along), on, f"{label}: {third} is a wall")
+ with self.subTest(third=third, pointer="visiting", label=label):
+ self.assertIs(self.net.shortcut(other, on), on)
+ self.assertIs(self.net.push(other, side, along), other if third in picked else on,
+ f"{label}: visiting pointer, {third}")
+ self.assertIs(self.net.shortcut(other), other)
+
+ def test_every_thirds_combination_by_clicks_on_both_platforms_and_every_side(self):
+ for on, other in ((self.mac, self.pc), (self.pc, self.mac)):
+ for side in SIDES:
+ for phase in ("at once", "settled"):
+ for picked in THIRD_SETS:
+ with self.subTest(platform=on.platform, side=side, phase=phase, picked=picked):
+ self.assertTrue(self.place(on, other, side))
+ if phase == "settled":
+ self.settled()
+ for third in ("start", "middle", "end"):
+ if third not in picked:
+ self.assertTrue(on.shell.click_third(other, third))
+ self.assert_ledger_thirds(on, other, side, picked, phase)
+ self.settled()
+ self.assert_agree()
+ self.assertTrue(on.shell.click_edge_text(other))
+ self.assertTrue(on.shell.click_edge_text(other))
+
+ def test_last_lit_third_off_and_any_third_on_alone_keep_the_shortcut(self):
+ for on, other in ((self.mac, self.pc), (self.pc, self.mac)):
+ for phase, side in (("at once", "right"), ("settled", "top")):
+ with self.subTest(platform=on.platform, phase=phase):
+ self.assertTrue(self.place(on, other, side))
+ if phase == "settled":
+ self.settled()
+ self.assertTrue(on.shell.click_third(other, "start"))
+ self.assertTrue(on.shell.click_third(other, "end"))
+ self.assertTrue(on.shell.click_third(other, "middle"))
+ self.assert_ledger_thirds(on, other, side, [], "last lit third off")
+ self.assertEqual(ways.ways(on.settings, other.id)["parts"], ["middle"])
+ self.assertIs(self.net.shortcut(on, other), other)
+ self.assertIs(self.net.shortcut(on), on)
+ for third in ("start", "middle", "end"):
+ self.assertTrue(on.shell.click_third(other, third))
+ self.assert_ledger_thirds(on, other, side, [third], "one third from off")
+ self.assertTrue(on.shell.click_third(other, third))
+ self.assertTrue(on.shell.click_edge_text(other))
+
+ def test_edge_text_turns_any_on_form_off_and_restores_the_whole_edge(self):
+ for on, other in ((self.mac, self.pc), (self.pc, self.mac)):
+ for phase, side in (("at once", "right"), ("settled", "top")):
+ for picked in THIRD_SETS:
+ with self.subTest(platform=on.platform, phase=phase, picked=picked):
+ self.assertTrue(self.place(on, other, side))
+ if phase == "settled":
+ self.settled()
+ for third in ("start", "middle", "end"):
+ if third not in picked:
+ self.assertTrue(on.shell.click_third(other, third))
+ self.assertTrue(on.shell.click_edge_text(other))
+ self.assert_ledger_thirds(on, other, side, [], "Edge text off")
+ self.assertTrue(on.shell.click_edge_text(other))
+ self.assert_ledger_thirds(on, other, side, ["start", "middle", "end"],
+ "Edge text restores whole edge")
+
+ def test_corner_click_moves_only_the_corner_and_lit_dot_turns_it_off(self):
+ for on, other in ((self.mac, self.pc), (self.pc, self.mac)):
+ self.assertTrue(on.shell.click_third(other, "start"))
+ self.assertTrue(on.shell.click_third(other, "end"))
+ for phase, side in (("at once", "right"), ("settled", "top")):
+ for corner in ("top_left", "top_right", "bottom_left", "bottom_right"):
+ with self.subTest(platform=on.platform, phase=phase, corner=corner):
+ self.assertTrue(self.place(on, other, side))
+ if phase == "settled":
+ self.settled()
+ self.assertTrue(on.shell.click_corner(other, corner))
+ for pushed in ("top_left", "top_right", "bottom_left", "bottom_right"):
+ with self.subTest(pointer="own", pushed=pushed):
+ landed = self.net.push_corner(on, pushed)
+ self.assertIs(landed, other if pushed == corner else on,
+ f"{corner}: own diagonal push at {pushed} went to {landed.name}")
+ self.assertIs(self.net.shortcut(on), on)
+ self.assertIs(self.net.shortcut(other, on), on)
+ with self.subTest(pointer="visiting", pushed=pushed):
+ landed = self.net.push_corner(other, pushed)
+ self.assertIs(landed, other if pushed == corner else on,
+ f"{corner}: visiting diagonal push at {pushed} went to {landed.name}")
+ self.assertIs(self.net.shortcut(other), other)
+ self.assert_ledger_thirds(on, other, side, ["middle"], "edge beside the corner")
+ self.assertTrue(on.shell.click_edge_text(other))
+ with self.subTest(edit="Edge text", corner=corner):
+ self.assertIs(self.net.push_corner(on, corner), other, "Edge off keeps Corner")
+ self.assertIs(self.net.shortcut(on), on)
+ self.assertTrue(on.shell.click_third(other, "middle"))
+ with self.subTest(edit="third", corner=corner):
+ self.assertIs(self.net.push_corner(on, corner), other, "third click keeps Corner")
+ self.assertIs(self.net.shortcut(on), on)
+ self.assertTrue(on.shell.click_corner(other, "bottom_right"))
+ for corner in ("top_left", "top_right", "bottom_left", "bottom_right"):
+ self.assertIs(self.net.push_corner(on, corner), on, "lit dot off leaves no corner")
+ self.assert_ledger_thirds(on, other, side, ["middle"], "Corner off keeps Edge")
+
+ def test_left_out_controls_are_inert_and_put_back_keeps_the_choices(self):
+ for on, other in ((self.mac, self.pc), (self.pc, self.mac)):
+ with self.subTest(platform=on.platform):
+ self.assertTrue(self.place(on, other, "right"))
+ self.assertTrue(on.shell.click_third(other, "start"))
+ self.assertTrue(on.shell.click_corner(other, "top_left"))
+ on.shell.leave_out(other)
+ self.settled()
+ with on.shell.lock:
+ before = copy.deepcopy(on.settings)
+ sent = on.shell.sent_count
+ saves = on.machine.settings.saves
+ self.assertFalse(on.shell.click_third(other, "middle"))
+ self.assertFalse(on.shell.click_edge_text(other))
+ self.assertFalse(on.shell.click_corner(other, "bottom_right"))
+ self.assertEqual(on.settings, before)
+ self.assertEqual(on.shell.sent_count, sent)
+ self.assertEqual(on.machine.settings.saves, saves)
+ self.assert_ledger_thirds(on, other, "right", [], "left out")
+ on.shell.put_back(other)
+ self.assert_ledger_thirds(on, other, "right", ["middle", "end"], "put back")
+ self.assertIs(self.net.push_corner(on, "top_left"), other, "put back keeps Corner")
+ self.assertIs(self.net.shortcut(on), on)
+
+ def test_clicks_rearm_the_responder_while_a_visiting_pointer_is_already_there(self):
+ for on, other in ((self.mac, self.pc), (self.pc, self.mac)):
+ for phase in ("at once", "settled"):
+ with self.subTest(platform=on.platform, phase=phase):
+ self.assertTrue(self.place(on, other, "right"))
+ self.assertIs(self.net.shortcut(other, on), on)
+ self.assertTrue(self.place(on, other, "right"))
+ if phase == "settled":
+ self.settled()
+ for third in ("start", "end", "middle"):
+ self.assertTrue(on.shell.click_third(other, third))
+ self.assertIs(self.net.push(other, "right", THIRD_AT[third]), on,
+ f"{phase}: clicked third must become a wall while driven")
+ self.assertTrue(on.shell.click_edge_text(other))
+ self.assertIs(self.net.push(other, "right"), other, "Edge text re-arms while driven")
+ self.assertIs(self.net.shortcut(other, on), on)
+ self.assertTrue(on.shell.click_corner(other, "top_right"))
+ self.assertTrue(on.shell.click_edge_text(other))
+ self.assertIs(self.net.push(other, "right"), on, "Edge off applies while driven")
+ self.assertIs(self.net.push_corner(other, "top_right"), other,
+ "Corner on applies while driven and survives Edge off")
+ self.assertIs(self.net.shortcut(other, on), on)
+ self.assertTrue(on.shell.click_corner(other, "top_right"))
+ self.assertIs(self.net.push_corner(other, "top_right"), on,
+ "lit dot off applies while driven")
+ self.assertTrue(on.shell.click_edge_text(other))
+ self.assertIs(self.net.shortcut(other), other)
+
+
+class EdgeOff(Pair):
+ """Edge off and on again, with a drop in place between (rc11: Edge off did not reach the map)."""
+
+ def test_off_holds_through_a_drop_and_on_again_crosses(self):
+ self.assertTrue(self.place(self.mac, self.pc, "right"))
+ self.settled()
+ self.assertTrue(self.mac.shell.edit(self.pc, []))
+ self.assertFalse(ways.crosses_on_map(self.mac.settings, self.pc.id))
+ self.assertIs(self.net.push(self.mac, "right"), self.mac, "off")
+ self.assertTrue(self.place(self.mac, self.pc, "right"))
+ self.settled()
+ self.assertIs(self.net.push(self.mac, "right"), self.mac, "off, after a drop in place")
+ self.assertIs(self.net.shortcut(self.mac, self.pc), self.pc, "the shortcut still reaches it")
+ self.assertIs(self.net.shortcut(self.mac), self.mac)
+ self.assertTrue(self.mac.shell.edit(self.pc, ["edge"]))
+ self.assertTrue(ways.crosses_on_map(self.mac.settings, self.pc.id))
+ self.assert_round_trip(self.mac, self.pc, "right", "on again")
+
+
+class Shortcut(Pair):
+ def test_the_shortcut_goes_and_comes_back_whatever_the_edges(self):
+ self.assertIs(self.net.shortcut(self.mac, self.pc), self.pc)
+ self.assertIs(self.net.shortcut(self.mac), self.mac)
+ self.assertIs(self.net.shortcut(self.pc, self.mac), self.mac)
+ self.assertIs(self.net.shortcut(self.pc), self.pc)
+
+
+class TwoDisplays(Desks):
+ """A Mac with an external display to the right of its own; the PC placed above the external one
+ only: only that display's top edge crosses, and the way back lands on it."""
+
+ DESKS = (("This Mac", "mac", {"0": Rect(0, 0, 1728, 1117), "1": Rect(1728, 0, 2560, 1440)}, 90),
+ ("DESK-WIN11", "pc", PC_DISPLAYS, 60))
+
+ def test_per_display_edges(self):
+ mac, pc = self.desk["This Mac"], self.desk["DESK-WIN11"]
+ self.settled()
+ own = mac.settings["layout"][mac.id]
+ tile = mac.settings["layout"][pc.id]
+ # Over the external display only: its frame is the right 60% of the Mac's tile, so the PC's
+ # tile starts 90 units in from the Mac's right edge and overhangs it.
+ x = own["x"] + own["w"] - 90
+ self.assertTrue(mac.shell.drop(pc, x, own["y"] - tile["h"]))
+ self.settled()
+ self.assertIs(self.net.push(mac, "top", display="1"), pc, "the external display's top")
+ self.assertEqual(self.net.landed(pc)[1], "bottom")
+ self.assertIs(self.net.push(mac, "bottom"), mac, "back")
+ self.assertEqual(self.net.landed(mac), ("1", "top"), "lands on the display it left")
+ self.assertIs(self.net.push(mac, "top", display="0"), mac, "the built-in display's top is a wall")
+
+
+class Three(Desks):
+ """This Mac, the rig and a Linux PC: two peers sharing one side by thirds, chains, and a third
+ machine dropped and moved (rc12: the split undone by a compile)."""
+
+ DESKS = (("This Mac", "mac", MAC_DISPLAYS, 90), ("DESK-WIN11", "pc", PC_DISPLAYS, 60),
+ ("Fedora", "pc", {"0": Rect(0, 0, 2560, 1600)}, 120))
+
+ def setUp(self):
+ super().setUp()
+ self.mac, self.pc, self.linux = (self.desk[name] for name in ("This Mac", "DESK-WIN11", "Fedora"))
+
+ def test_one_above_one_left_every_way_and_the_chain(self):
+ self.assertTrue(self.place(self.mac, self.pc, "top"))
+ self.assertTrue(self.place(self.mac, self.linux, "left"))
+ self.settled()
+ self.assert_agree()
+ self.assert_round_trip(self.mac, self.pc, "top", "rig above")
+ self.assert_round_trip(self.mac, self.linux, "left", "Fedora left")
+ self.assert_round_trip(self.pc, self.mac, "bottom", "the rig's own pointer")
+ self.assert_round_trip(self.linux, self.mac, "right", "Fedora's own pointer")
+
+ def test_two_on_one_side_split_by_the_map_and_kept_through_a_drop(self):
+ # Pairing leaves the default tiles wherever the winning picture put them; clear the right side
+ # first, so neither drop below lands on a tile and is snapped elsewhere.
+ self.assertTrue(self.place(self.mac, self.pc, "top"))
+ self.assertTrue(self.place(self.mac, self.linux, "left"))
+ self.settled()
+ own = self.mac.settings["layout"][self.mac.id]
+ half = own["h"] // 2
+ self.assertTrue(self.mac.shell.drop(self.pc, own["x"] + own["w"], own["y"] - half))
+ self.assertTrue(self.mac.shell.drop(self.linux, own["x"] + own["w"], own["y"] + half + 1))
+ self.settled()
+ self.assert_round_trip(self.mac, self.pc, "right", "upper", THIRD_AT["start"], back=THIRD_AT["end"])
+ self.assert_round_trip(self.mac, self.linux, "right", "lower", THIRD_AT["end"], back=THIRD_AT["start"])
+ self.assertTrue(self.place(self.mac, self.pc, "top"))
+ self.assertTrue(self.mac.shell.drop(self.pc, own["x"] + own["w"], own["y"] - half))
+ self.settled()
+ self.assert_round_trip(self.mac, self.pc, "right", "upper again", THIRD_AT["start"], back=THIRD_AT["end"])
+ self.assert_round_trip(self.mac, self.linux, "right", "lower kept", THIRD_AT["end"], back=THIRD_AT["start"])
+
+ def test_moving_one_peer_leaves_the_other_alone(self):
+ self.assertTrue(self.place(self.mac, self.pc, "top"))
+ self.assertTrue(self.place(self.mac, self.linux, "left"))
+ self.settled()
+ for side in ("right", "bottom", "top"):
+ with self.subTest(side=side):
+ self.assertTrue(self.place(self.mac, self.pc, side))
+ self.settled()
+ self.assert_round_trip(self.mac, self.pc, side, f"rig {side}")
+ self.assert_round_trip(self.mac, self.linux, "left", f"Fedora still left, rig {side}")
+
+
+class Rc14Corner(Three):
+ """10-10, rc14, from the Mac's and the rig's logs: the rig's corner for the Mac (top left, edges
+ off) sent input home onto the very end of the Mac's bottom edge, which is also its left edge, and
+ the hand still moving left crossed the Mac's left zone to the machine there 14 ms later."""
+
+ def test_a_corner_crossing_home_lands_clear_of_the_edge_beside_it(self):
+ self.assertTrue(self.place(self.mac, self.pc, "bottom"))
+ self.assertTrue(self.place(self.mac, self.linux, "left"))
+ self.settled()
+ for corner in ("top_left", "top_right"):
+ with self.subTest(corner=corner):
+ self.assertTrue(self.pc.shell.edit(self.mac, ["corner"], corner=corner))
+ self.assert_cross(self.mac, "bottom", self.pc, "Mac down to the rig")
+ self.assertIs(self.net.push_corner(self.mac, corner), self.mac, f"the rig's {corner} corner home")
+ display, side = self.net.landed(self.mac)
+ self.assertEqual(side, "bottom", "landed on the Mac's bottom edge")
+ x, y = self.mac.screen.placed[-1]
+ rect = self.mac.screen.displays[display]
+ clear = return_edge.LANDING_CLEAR_PX
+ self.assertTrue(rect.x + clear <= x <= rect.right - clear,
+ f"landed at x {x}, inside {clear} px of an end of {rect}")
+ self.assertTrue(rect.x + return_edge.CORNER_PX < x < rect.right - return_edge.CORNER_PX,
+ "landed inside a corner box")
+ self.assert_round_trip(self.mac, self.linux, "left", "Fedora on the left still crosses")
+
+
+class LedgerThree(Three):
+ def test_another_machines_held_corner_is_refused_without_a_write(self):
+ for on, holder, refused in ((self.mac, self.pc, self.linux),
+ (self.pc, self.mac, self.linux)):
+ self.assertTrue(self.place(on, holder, "top"))
+ self.assertTrue(self.place(on, refused, "left"))
+ self.settled()
+ self.assertTrue(on.shell.click_corner(holder, "top_left"))
+ self.assertTrue(on.shell.click_corner(refused, "bottom_left"))
+ for phase, side in (("at once", "right"), ("settled", "top")):
+ with self.subTest(platform=on.platform, phase=phase):
+ self.assertTrue(self.place(on, holder, side))
+ if phase == "settled":
+ self.settled()
+ with on.shell.lock:
+ before = copy.deepcopy(on.settings)
+ sent = on.shell.sent_count
+ saves = on.machine.settings.saves
+ self.assertFalse(on.shell.click_corner(refused, "top_left"))
+ self.assertEqual(on.settings, before, "a held dot must write nothing")
+ self.assertEqual(on.shell.sent_count, sent, "a refused click must send nothing")
+ self.assertEqual(on.machine.settings.saves, saves, "a refused click must save nothing")
+ with self.subTest(pointer="own"):
+ self.assertIs(self.net.push_corner(on, "top_left"), holder, "B keeps its corner")
+ self.assertIs(self.net.shortcut(on), on)
+ self.assertIs(self.net.shortcut(refused, on), on)
+ with self.subTest(pointer="visiting"):
+ self.assertIs(self.net.push_corner(refused, "top_left"), holder,
+ "B keeps its corner for a visiting pointer")
+ self.assertIs(self.net.shortcut(refused), refused)
+ self.settled()
+ self.assert_agree()
+ self.assertTrue(on.shell.click_corner(holder, "top_left"))
+ self.assertTrue(on.shell.click_corner(refused, "bottom_left"))
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/core/tests/test_crossing_state.py b/core/tests/test_crossing_state.py
new file mode 100644
index 0000000..d808cff
--- /dev/null
+++ b/core/tests/test_crossing_state.py
@@ -0,0 +1,402 @@
+"""The saved picture and local intent, exercised without either desktop toolkit."""
+
+import copy
+import unittest
+from types import SimpleNamespace
+
+from core import owner, protocol, return_edge, ways
+from core.tests.crossing_harness import Hand, Screen
+from core.tests.responder_harness import ident
+
+
+OWN, A, B = [protocol.id_text(ident(seed)) for seed in (90, 60, 120)]
+ALL = ["start", "middle", "end"]
+DISPLAYS = {"0": return_edge.Rect(0, 0, 1728, 1117)}
+
+
+def tile(x=0, y=0, w=160, h=100, displays=None):
+ result = dict(x=x, y=y, w=w, h=h)
+ if displays:
+ result["displays"] = displays
+ return result
+
+
+def settings():
+ return {"machine_id": OWN, "peers": [{"id": A, "port": 24820, "side": "right"}],
+ "zones": [], "layout": {OWN: tile(), A: tile(160)},
+ "layout_set_at": 1, "layout_by": OWN}
+
+
+class CrossingStateTests(unittest.TestCase):
+ def state(self):
+ from core import crossing_state
+ return crossing_state
+
+ def args(self):
+ return dict(platform="mac", live=lambda _: True, gone=lambda _: False, now=100)
+
+ def test_paired_defaults_and_own_displays_are_pure(self):
+ held = settings()
+ held["layout"] = {}
+ original = copy.deepcopy(held)
+ out = self.state().paired(held, platform="mac", own_displays=DISPLAYS, now=100)
+ self.assertEqual(held, original)
+ self.assertEqual(out["settings"]["peers"][0]["ways"],
+ dict(edge=True, thirds=ALL, corner=False, corner_at="top_left", notch=False))
+ self.assertEqual(out["settings"]["layout"][A]["x"], 160)
+ self.assertEqual(out["settings"]["layout"][OWN]["displays"]["0"]["w"], 1728)
+
+ def test_edit_remembers_thirds_off_and_drop_cannot_revive_them(self):
+ out = self.state().edit_ways(settings(), A, thirds=["start"], edge=False, **self.args())
+ held = out["settings"]
+ self.assertEqual(ways.ways(held, A)["parts"], ["start"])
+ self.assertEqual(ways.ways(held, A)["methods"], [])
+ dropped = self.state().drop(held, held["layout"], A, capable={OWN, A}, snap_radius=12, **self.args())
+ self.assertTrue(dropped["accepted"])
+ self.assertFalse(ways.has_way(dropped["settings"], A))
+ enabled = self.state().edit_ways(dropped["settings"], A, edge=True, thirds=[], **self.args())
+ self.assertEqual(ways.ways(enabled["settings"], A)["parts"], ["start"])
+ self.assertEqual(enabled["tell"], [A])
+
+ def test_arrangement_from_picture_peer_never_moves_or_echoes(self):
+ held = self.state().paired(settings(), platform="mac", own_displays=DISPLAYS, now=100)["settings"]
+ picture = copy.deepcopy(held["layout"])
+ read = dict(edge="top", set_at=200, by=ident(60), way_back=False, way_back_by=ident(120))
+ out = self.state().receive_arrangement(held, A, read, capable={OWN, A}, **self.args())
+ self.assertEqual(out["settings"]["layout"], picture)
+ self.assertEqual(out["settings"]["peers"][0]["side"], "right")
+ self.assertFalse(out["settings"]["peers"][0]["way_back"])
+ self.assertEqual(out["settings"]["peers"][0]["way_back_by"], B)
+ self.assertEqual(out["tell"], [])
+ self.assertFalse(out["send_picture"])
+ again = self.state().receive_arrangement(out["settings"], A, read, capable={OWN, A}, **self.args())
+ self.assertFalse(again["changed"])
+
+ def test_old_peer_moves_once_and_answers_once(self):
+ held = settings()
+ read = dict(edge="top", set_at=20, by=ident(60), way_back=True)
+ out = self.state().receive_arrangement(held, A, read, capable={OWN}, **self.args())
+ self.assertEqual(out["settings"]["peers"][0]["side"], "bottom")
+ self.assertEqual(out["settings"]["layout"][A]["y"], 100)
+ self.assertIn(A, out["tell"])
+ self.assertFalse(self.state().receive_arrangement(out["settings"], A, read,
+ capable={OWN}, **self.args())["changed"])
+
+ def test_receive_merges_owner_displays_and_corrects_own_once(self):
+ held = self.state().paired(settings(), platform="mac", own_displays=DISPLAYS, now=100)["settings"]
+ peer_displays = {"0": dict(x=0, y=0, w=3840, h=2160)}
+ incoming = copy.deepcopy(held["layout"])
+ incoming[OWN]["displays"] = {"wrong": dict(x=0, y=0, w=10, h=10)}
+ incoming[A]["displays"] = peer_displays
+ state = dict(set_at=200, by=A, tiles=incoming)
+ out = self.state().receive_picture(held, state, source=A, capable={OWN, A},
+ own_displays=DISPLAYS, **self.args())
+ self.assertTrue(out["send_picture"])
+ self.assertTrue(out["forward_picture"])
+ self.assertEqual(out["settings"]["layout"][A]["displays"], peer_displays)
+ self.assertEqual(out["settings"]["layout"][OWN]["displays"]["0"]["w"], 1728)
+ self.assertGreater(out["settings"]["layout_set_at"], 200)
+ stale = self.state().receive_picture(out["settings"], state, source=A, capable={OWN, A},
+ own_displays=DISPLAYS, **self.args())
+ self.assertFalse(stale["changed"])
+ self.assertFalse(stale["forward_picture"])
+ state = dict(set_at=300, by=B, tiles={OWN: tile(), A: tile(160)})
+ merged = self.state().receive_picture(out["settings"], state, source=B, capable={OWN, A, B},
+ own_displays=DISPLAYS, **self.args())
+ self.assertEqual(merged["settings"]["layout"][A]["displays"], peer_displays)
+ self.assertTrue(merged["send_picture"], "a picture missing our geometry needs the owner correction")
+
+ def test_link_and_display_changes_stamp_only_geometry_changes(self):
+ out = self.state().link_up(settings(), A, platform="mac", own_displays=DISPLAYS, now=100)
+ self.assertEqual(out["tell"], [A])
+ self.assertTrue(out["send_picture"])
+ held = out["settings"]
+ out = self.state().displays_changed(held, platform="mac", own_displays=DISPLAYS, now=200)
+ self.assertFalse(out["changed"])
+ self.assertFalse(out["send_picture"])
+ self.assertEqual(out["settings"]["layout_set_at"], held["layout_set_at"])
+
+ def test_displays_changed_persists_a_missing_zoned_peer_tile_on_its_side(self):
+ held = settings()
+ held["layout"] = {OWN: tile(displays={"0": {"x": 0, "y": 0, "w": 1728, "h": 1117}})}
+ held["layout_set_at"] = 20
+
+ out = self.state().displays_changed(held, platform="mac", own_displays=DISPLAYS, now=100,
+ capable={OWN, A})
+
+ self.assertEqual(out["settings"]["layout"][A], tile(160))
+ self.assertEqual(out["settings"]["peers"][0]["side"], "right")
+ self.assertEqual(out["settings"]["layout_set_at"], 20)
+ self.assertFalse(out["send_picture"])
+
+ def test_displays_changed_gives_an_old_peer_no_tile_and_keeps_its_side(self):
+ # An old peer's tile comes only from an arriving arrangement (crossing model, "Old peers"); a
+ # filled one made the Mac count it as a picture machine until its link said otherwise.
+ held = settings()
+ held["layout"] = {OWN: tile(displays={"0": {"x": 0, "y": 0, "w": 1728, "h": 1117}})}
+ held["layout_set_at"] = 20
+
+ out = self.state().displays_changed(held, platform="mac", own_displays=DISPLAYS, now=100,
+ capable={OWN})
+
+ self.assertNotIn(A, out["settings"]["layout"])
+ self.assertEqual(out["settings"]["peers"][0]["side"], "right")
+ self.assertEqual(out["settings"]["layout_set_at"], 20)
+ self.assertFalse(out["send_picture"])
+
+ def test_a_picture_omitting_two_peers_places_the_tileless_one_clear_of_the_kept_one(self):
+ held = settings()
+ held["peers"].append({"id": B, "port": 24820, "side": "right"})
+ state = dict(set_at=200, by=A, tiles={OWN: tile()})
+ held["layout"] = {OWN: tile(), A: tile(160)}
+ held["peers"][0]["side"] = "right"
+ out = self.state().receive_picture(held, state, source=A, capable={OWN, A, B},
+ own_displays={}, **self.args())
+ layout = out["settings"]["layout"]
+ self.assertEqual(layout[A], tile(160))
+ self.assertFalse(ways._overlaps(layout[A], layout[B]))
+
+ def test_an_old_peers_arrangement_shares_a_side_another_machine_holds(self):
+ held = settings()
+ held["peers"][0]["side"] = "left"
+ held["peers"].append({"id": B, "port": 24820, "side": "right"})
+ held["layout"] = {OWN: tile(), A: tile(-160)}
+ out = self.state().receive_arrangement(held, B, dict(edge="right", by=ident(120), set_at=50),
+ capable={OWN}, **self.args())
+ layout, sides = out["settings"]["layout"], {p["id"]: p["side"] for p in out["settings"]["peers"]}
+ self.assertEqual((layout[A]["x"], layout[A]["y"], layout[B]["x"], layout[B]["y"]), (-160, -50, -160, 50))
+ self.assertEqual((sides[A], sides[B]), ("left", "left"))
+
+ def test_put_back_moves_the_returning_tile_off_an_active_one(self):
+ held = settings()
+ held["peers"][0]["left_out"] = True
+ held["peers"].append({"id": B, "port": 24820, "side": "right"})
+ held["layout"] = {OWN: tile(), A: tile(160), B: tile(160)}
+ out = self.state().put_back(held, A, platform="mac", live=lambda _: True, gone=lambda _: False, now=100)
+ layout, sides = out["settings"]["layout"], {p["id"]: p["side"] for p in out["settings"]["peers"]}
+ self.assertEqual((layout[B]["y"], layout[A]["y"], layout[A]["x"]), (-50, 50, 160))
+ self.assertEqual((sides[A], sides[B]), ("right", "right"))
+ self.assertEqual(out["settings"]["layout_set_at"], 100)
+ self.assertTrue(out["send_picture"])
+
+ def test_put_back_of_a_machine_still_not_in_use_moves_nobody(self):
+ held = settings()
+ held["peers"][0].update(left_out=True, in_use=False)
+ held["peers"].append({"id": B, "port": 24820, "side": "right"})
+ held["layout"] = {OWN: tile(), A: tile(160), B: tile(160)}
+ out = self.state().put_back(held, A, platform="mac", live=lambda _: True, gone=lambda _: False, now=100)
+ self.assertEqual(out["settings"]["layout"][B], tile(160))
+ self.assertFalse(out["send_picture"])
+
+ def test_share_side_refuses_to_break_a_moved_tiles_other_contact(self):
+ layout = {OWN: tile(), A: tile(-160), "C": tile(-320, 60), B: tile(500)}
+ self.assertEqual(ways.share_side(layout, OWN, B, "left"), {})
+
+ def test_a_picture_omitting_a_tileless_peer_places_it_against_the_arriving_layout(self):
+ held = settings()
+ held["layout"] = {OWN: tile()}
+ state = dict(set_at=200, by=A, tiles={OWN: tile(160)})
+ out = self.state().receive_picture(held, state, source=A, capable={OWN, A},
+ own_displays={}, **self.args())
+ layout = out["settings"]["layout"]
+ self.assertEqual((layout[OWN]["x"], layout[A]["x"], layout[A]["y"]), (160, 320, 0))
+ self.assertEqual(out["settings"]["peers"][0]["side"], "right")
+
+ def test_relay_applies_owner_displays_in_a_newer_picture(self):
+ held = self.state().paired(settings(), platform="mac", own_displays=DISPLAYS, now=100)["settings"]
+ held["layout"][A]["displays"] = {"0": dict(x=0, y=0, w=3840, h=2160)}
+ incoming = copy.deepcopy(held["layout"])
+ incoming[A]["displays"]["0"]["w"] = 100
+ state = dict(set_at=200, by=B, tiles=incoming)
+ out = self.state().receive_picture(held, state, source=B, capable={OWN, A, B},
+ own_displays=DISPLAYS, **self.args())
+ self.assertEqual(out["settings"]["layout"][A]["displays"]["0"]["w"], 100)
+ state["by"] = A
+ out = self.state().receive_picture(held, state, source=B, capable={OWN, A, B},
+ own_displays=DISPLAYS, **self.args())
+ self.assertEqual(out["settings"]["layout"][A]["displays"]["0"]["w"], 100)
+
+ def test_old_peer_keeps_arrangement_side_through_page_and_display_events(self):
+ held = settings()
+ held["peers"][0]["side"] = "left"
+ out = self.state().edit_ways(held, A, thirds=["start"], capable={OWN}, **self.args())
+ self.assertEqual(out["settings"]["peers"][0]["side"], "left")
+ self.assertEqual(out["settings"]["zones"], [dict(peer=A, kind="part", parts=["start"])])
+ out = self.state().displays_changed(out["settings"], platform="mac", own_displays=DISPLAYS,
+ capable={OWN}, now=100)
+ self.assertEqual(out["settings"]["peers"][0]["side"], "left")
+ self.assertEqual(out["settings"]["zones"], [dict(peer=A, kind="part", parts=["start"])])
+
+ def test_shelf_preserves_intent_and_shelved_drop_is_rejected(self):
+ held = self.state().edit_ways(settings(), A, thirds=["end"], **self.args())["settings"]
+ out = self.state().leave_out(held, A, **self.args())
+ self.assertFalse(ways.has_way(out["settings"], A))
+ self.assertEqual(out["settings"]["peers"][0]["ways"], held["peers"][0]["ways"])
+ dropped = self.state().drop(out["settings"], held["layout"], A, capable={OWN, A},
+ snap_radius=12, **self.args())
+ self.assertFalse(dropped["accepted"])
+ self.assertEqual(dropped["settings"], out["settings"])
+ restored = self.state().put_back(out["settings"], A, **self.args())
+ self.assertTrue(ways.has_way(restored["settings"], A))
+ self.assertEqual(ways.ways(restored["settings"], A)["parts"], ["end"])
+
+ def test_majority_and_tie_have_one_owner_before_intent_narrows(self):
+ held = settings()
+ held["peers"].append(dict(id=B, port=24820))
+ held["layout"] = {OWN: tile(h=120), A: tile(160, -60, h=120), B: tile(160, 60, h=120)}
+ out = ways.compile_layout(held, held["layout"], platform="mac", capable={OWN, A, B}, now=100)
+ zones = out["settings"]["zones"]
+ self.assertEqual([(z["peer"], z.get("parts")) for z in zones], [(A, ["start"]), (B, ["middle", "end"])])
+ held["layout"][B]["y"] = 61
+ out = ways.compile_layout(held, held["layout"], platform="mac", capable={OWN, A, B}, now=100)
+ self.assertEqual(out["settings"]["zones"][0]["parts"], ["start", "middle"])
+
+ def test_a_shifted_contact_only_crosses_its_own_contacting_thirds(self):
+ held = settings()
+ held["layout"][A]["y"] = -50
+ on_upper = copy.deepcopy(held)
+ on_upper["machine_id"] = A
+ on_upper["peers"] = [dict(id=OWN, port=24820)]
+ out = ways.compile_layout(on_upper, on_upper["layout"], platform="pc", now=100)
+ self.assertEqual(out["settings"]["zones"], [
+ dict(peer=OWN, kind="part", side="left", parts=["middle", "end"])])
+
+ def test_peer_spanning_two_display_tops_compiles_both_contacts(self):
+ held = settings()
+ held["layout"][OWN]["displays"] = {
+ "1": dict(x=0, y=0, w=1728, h=1117),
+ "2": dict(x=1728, y=0, w=2560, h=1440)}
+ held["layout"][A].update(x=0, y=-100)
+ out = ways.compile_layout(held, held["layout"], platform="mac", now=100)
+ self.assertEqual([(zone["display"], zone["side"]) for zone in out["settings"]["zones"]],
+ [("1", "top"), ("2", "top")])
+
+ def test_invalid_drop_is_rejected_without_changing_held_settings(self):
+ held = settings()
+ original = copy.deepcopy(held)
+ bad = copy.deepcopy(held["layout"])
+ bad[A]["w"] = 0
+ out = self.state().drop(held, bad, A, capable={OWN, A}, snap_radius=12, **self.args())
+ self.assertFalse(out["accepted"])
+ self.assertFalse(out["changed"])
+ self.assertEqual(held, original)
+ self.assertIsNot(out["settings"], held)
+
+ def test_corners_and_notch_use_first_peer_and_notch_is_mac_only(self):
+ held = settings()
+ held["peers"].append(dict(id=B, port=24820))
+ for peer in held["peers"]:
+ peer["ways"] = dict(edge=False, thirds=ALL, corner=True, corner_at="top_left", notch=True)
+ held["layout"][B] = tile(-160)
+ out = ways.compile_layout(held, held["layout"], platform="mac", now=100)
+ self.assertEqual([(z["peer"], z["kind"]) for z in out["settings"]["zones"]],
+ [(A, "corner"), (A, "notch")])
+ out = ways.compile_layout(held, held["layout"], platform="pc", now=100)
+ self.assertEqual([(z["peer"], z["kind"]) for z in out["settings"]["zones"]], [(A, "corner")])
+
+ def test_old_peer_thirds_give_priority_to_picture_contacts(self):
+ held = settings()
+ held["peers"].insert(0, dict(id=B, port=24820, side="right", caps=[]))
+ held["peers"][1]["caps"] = ["layout"]
+ held["layout"][A] = tile(160, 0, h=33)
+ held["layout"][B] = tile(400)
+ out = ways.compile_layout(held, held["layout"], platform="pc", now=100)
+ self.assertEqual(out["settings"]["zones"], [
+ dict(peer=B, kind="part", parts=["middle", "end"]),
+ dict(peer=A, kind="part", parts=["start"], side="right")])
+
+ def test_target_fields_are_written_together_and_side_is_derived(self):
+ held = settings()
+ held["layout"][OWN]["displays"] = {"0": dict(x=0, y=0, w=100, h=100)}
+ out = ways.compile_layout(held, held["layout"], platform="mac", now=100)
+ zone = out["settings"]["zones"][0]
+ self.assertNotIn("target_side", zone)
+ held["layout"][A]["displays"] = {"other": dict(x=0, y=0, w=100, h=100)}
+ held["peers"][0]["side"] = "left"
+ out = ways.compile_layout(held, held["layout"], platform="mac", now=100)
+ self.assertEqual(out["settings"]["zones"][0]["target_display"], "other")
+ self.assertEqual(out["settings"]["zones"][0]["target_side"], "left")
+ self.assertEqual(out["settings"]["peers"][0]["side"], "right")
+
+ def test_harness_carries_out_the_owners_home_landing(self):
+ screen = Screen({"1": return_edge.Rect(0, 0, 100, 100),
+ "2": return_edge.Rect(100, 0, 200, 100)})
+ hand = Hand(SimpleNamespace(own=ident(90), screen=screen))
+ hand.carry_out([owner.Moved(None, A, "switch", "bottom", 0.5,
+ display="2", side="top")])
+ self.assertEqual(screen.placed[-1], (200, 0))
+
+ def test_rc12_migration_reads_once_and_removes_old_marks(self):
+ own, rig = "TnY4DcwqoBkkPubq9P00QA", "GRMYVCd7dKksFjy5FejD4Q"
+ held = {"machine_id": own, "peers": [dict(id=rig, side="left", port=24820)], "zones": [
+ dict(peer=rig, kind="edge", contact_parts=ALL),
+ dict(peer=rig, kind="part", parts=ALL, off=True, contact_parts=ALL),
+ dict(peer=rig, kind="corner", corner="top_left", edge="left", off=True),
+ dict(peer=rig, kind="edge", display="0", side="right", target_side="left", off=True),
+ dict(peer=rig, kind="notch"),
+ dict(peer=rig, kind="edge", display="0", side="bottom", target_side="top", off=True)],
+ "layout": {own: tile(-169, 241, displays={"0": dict(x=0, y=0, w=1728, h=1117)}),
+ rig: tile(-329, 241, displays={"0": dict(x=0, y=0, w=3840, h=2160)})}}
+ out = self.state().migrate(held, "mac")
+ saved = out["settings"]
+ self.assertEqual(saved["peers"][0]["ways"], dict(edge=True, thirds=ALL, corner=False,
+ corner_at="top_left", notch=True))
+ self.assertEqual(saved["zones"], [dict(peer=rig, kind="edge", display="0", side="left",
+ target_display="0", target_side="right"),
+ dict(peer=rig, kind="notch")])
+ self.assertFalse(self.state().migrate(saved, "mac")["changed"])
+ held["zones"][0].update(off=True, page_off=True, aside=True)
+ held["zones"][1]["page_parts"] = ["end"]
+ saved = self.state().migrate(held, "mac")["settings"]
+ self.assertFalse(saved["peers"][0]["ways"]["edge"])
+ self.assertEqual(saved["peers"][0]["ways"]["thirds"], ["end"])
+ self.assertEqual(saved["zones"], [dict(peer=rig, kind="notch")])
+
+ def test_migration_keeps_a_left_out_machines_ways_for_put_back(self):
+ # Codex review, 10-10: rc12 kept the kinds in use in left_out_ways and turned every zone off.
+ held = settings()
+ held["peers"][0].update(left_out=True, left_out_ways=["edge", "corner", "notch"])
+ held["zones"] = [dict(peer=A, kind="edge", off=True), dict(peer=A, kind="corner", corner="top_right",
+ edge="right", off=True),
+ dict(peer=A, kind="notch", off=True)]
+ saved = self.state().migrate(held, "mac")["settings"]
+ self.assertEqual(saved["peers"][0]["ways"], dict(edge=True, thirds=ALL, corner=True,
+ corner_at="top_right", notch=True))
+ self.assertEqual(saved["zones"], [])
+ back = self.state().put_back(saved, A, platform="mac", now=100)["settings"]
+ self.assertIn("edge", [zone["kind"] for zone in back["zones"]])
+ self.assertIn("notch", [zone["kind"] for zone in back["zones"]])
+
+ def test_migration_keeps_a_pick_that_touches_no_contact_on(self):
+ # Codex review, 10-10: rc12 marked a picked third with no contact `unpicked`, still on.
+ held = settings()
+ held["zones"] = [dict(peer=A, kind="edge", off=True),
+ dict(peer=A, kind="part", parts=["start"], off=True, unpicked=True, page_parts=["start"])]
+ saved = self.state().migrate(held, "mac")["settings"]
+ self.assertEqual(saved["peers"][0]["ways"]["edge"], True)
+ self.assertEqual(saved["peers"][0]["ways"]["thirds"], ["start"])
+
+ def test_dragging_an_old_peer_sets_its_side_and_tells_it(self):
+ # Codex review, 10-10: a 1.5.1 peer crosses by its side; the map is how its side is set.
+ held = settings()
+ held["peers"][0]["side_set_at"] = 50
+ tiles = dict(held["layout"], **{A: tile(-160)})
+ out = self.state().drop(held, tiles, A, platform="mac", capable={OWN}, live=lambda _: True,
+ gone=lambda _: False, now=100, snap_radius=12)
+ self.assertTrue(out["accepted"])
+ self.assertEqual(out["settings"]["peers"][0]["side"], "left")
+ self.assertIn(A, out["tell"])
+ self.assertTrue(ways.has_way(out["settings"], A))
+
+ def test_migration_keeps_a_whole_edge_in_use_over_a_pick_left_on_an_off_part_zone(self):
+ # AGY review, 10-10: the page showed the whole edge, so migration must not shrink it to the pick.
+ held = settings()
+ held["zones"] = [dict(peer=A, kind="edge"), dict(peer=A, kind="part", parts=["start"], off=True,
+ page_parts=["start"])]
+ saved = self.state().migrate(held, "mac")["settings"]
+ self.assertEqual(saved["peers"][0]["ways"]["thirds"], ALL)
+ self.assertTrue(saved["peers"][0]["ways"]["edge"])
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/core/tests/test_dormant_repair.py b/core/tests/test_dormant_repair.py
new file mode 100644
index 0000000..f4c1731
--- /dev/null
+++ b/core/tests/test_dormant_repair.py
@@ -0,0 +1,186 @@
+import copy
+import base64
+import unittest
+
+from core import pairing, peerlist, protocol, receiver, ways
+
+
+PEER = protocol.id_text(bytes(range(20, 36)))
+OWN = protocol.id_text(bytes(range(1, 17)))
+TOKEN = base64.urlsafe_b64encode(bytes(range(32))).decode().rstrip("=")
+
+
+def entry(**fields):
+ return {"id": PEER, "name": "Desk", "token": TOKEN, "linked": True, "from_1_4": False,
+ "side": "left", **fields}
+
+
+class DormantPeerTests(unittest.TestCase):
+ def setUp(self):
+ self.settings = {"machine_id": OWN, "peers": [entry()], "zones": [{"peer": PEER, "kind": "edge"}],
+ "layout": {PEER: {"x": 20, "y": 30, "w": 160, "h": 100}}}
+ self.book = receiver.PeerBook(lambda: self.settings, self.save)
+
+ def save(self, settings):
+ self.settings.clear()
+ self.settings.update(copy.deepcopy(settings))
+
+ def test_wrong_id_marks_the_peer_dormant_with_a_reason(self):
+ self.book.mark_dormant(TOKEN, "wrong_id")
+ peer = self.settings["peers"][0]
+ self.assertTrue(peer["dormant"])
+ self.assertEqual(peer["dormant_reason"], "wrong_id")
+ self.assertEqual(peerlist.dormant_reason(peer), "The saved pairing now identifies a different machine.")
+
+ def test_forgotten_marks_the_peer_dormant_with_a_reason(self):
+ self.book.mark_dormant(TOKEN, "forgotten")
+ self.assertEqual(peerlist.dormant_reason(self.settings["peers"][0]),
+ "The other machine no longer has this pairing.")
+
+ def test_dormant_without_a_reason_still_needs_repair(self):
+ self.assertEqual(peerlist.dormant_reason(entry(dormant=True)), "This pairing needs to be set up again.")
+
+ def test_layout_compilation_keeps_dormant_zones_and_saved_position(self):
+ self.settings["peers"][0].update(dormant=True, dormant_reason="forgotten")
+ self.settings["layout"][OWN] = {"x": 0, "y": 0, "w": 160, "h": 100}
+ before = copy.deepcopy(self.settings)
+ result = ways.compile_layout(self.settings, self.settings["layout"], now=100)
+ self.assertTrue(result["accepted"])
+ self.assertEqual(result["settings"]["zones"], [])
+ self.assertEqual(ways.ways(result["settings"], PEER)["methods"], ["edge"])
+ self.assertEqual(result["settings"]["layout"], before["layout"])
+ self.assertEqual(result["tiles"][PEER]["state"], "dormant")
+
+ def test_dormant_tile_does_not_block_another_tile(self):
+ other = protocol.id_text(bytes(range(40, 56)))
+ self.settings["peers"][0].update(dormant=True, dormant_reason="forgotten")
+ self.settings["peers"].append(entry(id=other, token="other"))
+ layout = {OWN: {"x": 0, "y": 0, "w": 160, "h": 100},
+ PEER: {"x": 160, "y": 0, "w": 160, "h": 100},
+ other: {"x": 160, "y": 0, "w": 160, "h": 100}}
+ result = ways.compile_layout(self.settings, layout, moved=other, now=100)
+ self.assertTrue(result["accepted"])
+ self.assertEqual(result["tiles"][other]["state"], "edge")
+
+ def test_successful_link_clears_dormant_state(self):
+ self.book.mark_dormant(TOKEN, "wrong_id")
+ outcome, _ = self.book.admit(protocol.key_id(TOKEN), bytes(range(1, 17)), bytes(range(20, 36)), {})
+ self.assertEqual(outcome, receiver.ADMITTED)
+ self.assertNotIn("dormant", self.settings["peers"][0])
+ self.assertNotIn("dormant_reason", self.settings["peers"][0])
+
+ def test_successful_link_keeps_intent_and_compile_allocates_the_shared_stretch(self):
+ other_id = protocol.id_text(bytes(range(40, 56)))
+ self.settings["peers"].append({**entry(id=other_id, token="other"), "side": "left"})
+ self.settings["peers"][0].update(dormant=True, dormant_reason="forgotten")
+ self.settings["peers"][0].update(side="left", side_set_at=42, side_by=OWN)
+ self.settings["zones"].append({"peer": other_id, "kind": "edge"})
+ self.settings["layout"] = {
+ OWN: {"x": 0, "y": 0, "w": 160, "h": 100},
+ PEER: {"x": -160, "y": 0, "w": 160, "h": 50},
+ other_id: {"x": -160, "y": 50, "w": 160, "h": 50},
+ }
+
+ outcome, _ = self.book.admit(protocol.key_id(TOKEN), bytes(range(1, 17)), bytes(range(20, 36)), {})
+ ways.ensure_zones(self.settings)
+
+ self.assertEqual(outcome, receiver.ADMITTED)
+ self.assertEqual(self.settings["zones"], [
+ {"peer": PEER, "kind": "part", "parts": ["start"], "side": "left"},
+ {"peer": other_id, "kind": "part", "parts": ["middle", "end"], "side": "left"},
+ ])
+ self.assertEqual(ways.ways(self.settings, PEER)["methods"], ["edge"])
+ self.assertTrue(all("off" not in zone for zone in self.settings["zones"]))
+
+ def test_repair_replaces_the_entry_and_keeps_local_machine_fields(self):
+ old = self.settings["peers"][0]
+ old.update(label="Office", left_out=True, left_out_ways=["edge"], dormant=True, dormant_reason="forgotten")
+ old.update(side="left", side_set_at=42, side_by=OWN)
+ repaired = {"id": PEER, "name": "Desk 2", "token": "new", "side": "", "linked": False}
+ peerlist.add_peer(self.settings, repaired, copy.deepcopy(old))
+ self.assertEqual(self.settings["peers"][0]["id"], PEER)
+ self.assertEqual((repaired["label"], repaired["left_out"], repaired["left_out_ways"]),
+ ("Office", True, ["edge"]))
+ self.assertEqual((repaired["side"], repaired["side_set_at"], repaired["side_by"]), ("left", 42, OWN))
+ self.assertEqual(self.settings["zones"], [])
+ self.assertEqual(ways.ways(self.settings, PEER)["methods"], ["edge"])
+ self.assertEqual(self.settings["layout"][PEER], {"x": 20, "y": 30, "w": 160, "h": 100})
+ self.assertNotIn("dormant", repaired)
+
+ def test_repaired_peer_with_retained_side_and_intent_crosses_at_its_picture_contact(self):
+ old = self.settings["peers"][0]
+ old.update(side="left", side_set_at=42, side_by=OWN)
+ repaired = {"id": PEER, "name": "Desk 2", "token": "new", "side": "", "linked": False}
+ self.settings["layout"] = {
+ OWN: {"x": 0, "y": 0, "w": 160, "h": 100},
+ PEER: {"x": -160, "y": 0, "w": 160, "h": 100},
+ }
+
+ peerlist.add_peer(self.settings, repaired, copy.deepcopy(old))
+
+ self.assertTrue(ways.has_way(self.settings, PEER))
+ self.assertEqual(ways.ways(self.settings, PEER)["methods"], ["edge"])
+ self.assertEqual(self.settings["zones"], [{"peer": PEER, "kind": "edge", "side": "left"}])
+
+ def test_qr_known_check_allows_a_dormant_same_id_peer(self):
+ service = pairing.PairingService.__new__(pairing.PairingService)
+ service.identity = bytes(range(1, 17))
+ service._peer_entries = lambda: [entry(dormant=True, dormant_reason="forgotten")]
+
+ service._not_paired_already(PEER)
+
+ def test_pairing_client_allows_capacity_when_a_peer_might_be_repaired(self):
+ peers = [entry(id=protocol.id_text(bytes([i]) * 16), dormant=True) for i in range(pairing.MAX_PEERS)]
+ pairing.PairingClient("pair", "123456", "Desk", bytes(range(1, 17)), version=pairing.PAIRING_V3,
+ platform="windows", port=24820, peers=lambda: peers)
+
+ def test_host_rejects_a_distinct_addition_at_capacity(self):
+ peers = [entry(id=protocol.id_text(bytes([i]) * 16)) for i in range(pairing.MAX_PEERS)]
+ host = pairing.PairingHost(lambda: 0, "Host", bytes(range(1, 17)), version=pairing.PAIRING_V3,
+ platform="windows", port=24820, peers=lambda: peers,
+ store=lambda *_: self.fail("full host stored an additional peer"))
+ bound = {"identity": bytes(range(60, 76)), "name": "New", "platform": "windows", "port": 24820,
+ "token": base64.urlsafe_b64encode(bytes(range(100, 132))).decode().rstrip("="),
+ "address": "192.0.2.5", "done_tag": b"done"}
+
+ host._keep(bound, [], "pair")
+
+ self.assertEqual(host.outcome, "full")
+
+ def test_host_replaces_a_dormant_peer_at_capacity(self):
+ repaired_id = bytes(range(60, 76))
+ peers = [entry(id=protocol.id_text(bytes([i + 1]) * 16), token=f"peer-{i}")
+ for i in range(pairing.MAX_PEERS)]
+ peers[0].update(id=protocol.id_text(repaired_id), dormant=True, dormant_reason="forgotten")
+ stored = []
+ host = pairing.PairingHost(lambda: 0, "Host", bytes(range(1, 17)), version=pairing.PAIRING_V3,
+ platform="windows", port=24820, peers=lambda: peers,
+ store=lambda item, old: stored.append((item, old)))
+ bound = {"identity": repaired_id, "name": "Desk", "platform": "windows", "port": 24820,
+ "token": base64.urlsafe_b64encode(bytes(range(100, 132))).decode().rstrip("="),
+ "address": "192.0.2.5", "done_tag": b"done"}
+
+ host._keep(bound, [], "pair")
+
+ self.assertEqual(host.outcome, "paired")
+ self.assertEqual(stored[0][1], peers[0])
+
+ def test_a_dormant_id_is_replaceable_by_the_pairing_service(self):
+ old = entry(dormant=True, dormant_reason="forgotten")
+ refused, replaced = pairing._find_known(
+ [old], bytes(range(1, 17)), bytes(range(20, 36)), "Desk", "windows", 2_000_000_000)
+ self.assertIsNone(refused)
+ self.assertEqual(replaced, old)
+
+ def test_dormant_peer_does_not_hold_or_block_a_zone_stretch(self):
+ stretch = ways._stretch({"peer": PEER, "kind": "edge"}, {PEER: "left"}, [entry(dormant=True)])
+ self.assertEqual(stretch, set())
+
+ def test_dormant_state_is_saved_by_peer_book(self):
+ self.book.mark_dormant(TOKEN, "forgotten")
+ reopened = receiver.PeerBook(lambda: self.settings, self.save)
+ self.assertEqual(peerlist.dormant_reason(reopened.peers()[0]), "The other machine no longer has this pairing.")
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/core/tests/test_effect_detent_pace.py b/core/tests/test_effect_detent_pace.py
new file mode 100644
index 0000000..c33ffae
--- /dev/null
+++ b/core/tests/test_effect_detent_pace.py
@@ -0,0 +1,72 @@
+import math
+import unittest
+from unittest import mock
+
+from core import effects
+from core.fx_instrument import detent
+
+
+class InstrumentDetentPaceTests(unittest.TestCase):
+ def test_pace_one_keeps_the_original_detent_values(self):
+ for n, slide in ((3, 0.4), (4, 0.25), (4, 0.4), (5, 0.4)):
+ for step in range(1001):
+ u = step / 1000
+ if u <= 0:
+ expected = 0.0
+ elif u >= 1:
+ expected = 1.0
+ else:
+ k = math.floor(u * n)
+ f = u * n - k
+ expected = min(1.0, (k + min(1.0, max(0.0, f / slide))) / n)
+ for pace in (0.5, 1.0):
+ self.assertEqual(detent(u, n, slide, pace=pace), expected)
+
+ def test_longer_pace_keeps_each_move_end_and_rises_monotonically(self):
+ # Gauge and Rangefinder lock against the end of their last move; it must not move later.
+ for n, slide in ((3, 0.4), (4, 0.25), (4, 0.4), (5, 0.4)):
+ for pace in (1.5, 2.0, 2.5):
+ with self.subTest(n=n, slide=slide, pace=pace):
+ for move in range(n):
+ self.assertAlmostEqual(detent((move + slide) / n, n, slide, pace=pace), (move + 1) / n)
+ values = [detent(step / 2000, n, slide, pace=pace) for step in range(2001)]
+ self.assertEqual(values, sorted(values))
+ self.assertEqual((values[0], values[-1]), (0.0, 1.0))
+
+ def test_crossing_and_switch_previews_forward_pace_to_timed_states(self):
+ fx = effects.effect("rule")
+ with mock.patch.object(effects, "state", wraps=effects.state) as make_state:
+ effects.preview_scene(fx, 2.4, "edge", ("#58c8f0", "#a673ec", "#f05e8a"), pace=2.5)
+ effects.preview_switch_scene(fx, 0.5, ("#58c8f0", "#a673ec", "#f05e8a"), pace=2.5)
+ self.assertEqual([call.kwargs["pace"] for call in make_state.call_args_list], [2.5, 2.5, 2.5])
+
+ def test_player_instrument_frames_do_not_hold_for_more_than_fifty_ms_at_pace_2_5(self):
+ for effect_id in ("rule", "gauge", "rangefinder"):
+ with self.subTest(effect=effect_id):
+ player = effects.Player(pace=2.5)
+ player.effect_size_fraction = 0.02
+ region = {"kind": "edge", "edge": "right", "x": 1199.0,
+ "y": 0.0, "w": 1.0, "h": 800.0}
+ player.push(0.0, "edge", region, (1199.0, 360.0), 1.0)
+ player.cross(0.0)
+ player.arrive(0.0, "edge", (1.0, 360.0), "left")
+ fx = effects.effect(effect_id)
+ palette = effects.legible(("#58c8f0", "#a673ec", "#f05e8a"), True, fx)
+ previous = None
+ repeated_for = 0.0
+ for frame_index in range(91):
+ now = frame_index / 60.0
+ pens = player.frames(now, fx, (1200.0, 800.0, "windows"), palette, False, True)
+ current = tuple(tuple(pen.ops) for pen in pens)
+ if current == previous:
+ repeated_for += 1.0 / 60.0
+ else:
+ repeated_for = 0.0
+ # Rangefinder's locked rest before its fade is 20ms at pace 1 and stretches with
+ # the pace by design; every detent hold stays at its pace 1 length.
+ self.assertLessEqual(repeated_for, 0.07, f"identical frame held {repeated_for:.3f}s")
+ previous = current
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/core/tests/test_keytable.py b/core/tests/test_keytable.py
index aab34df..7d534b4 100644
--- a/core/tests/test_keytable.py
+++ b/core/tests/test_keytable.py
@@ -135,6 +135,10 @@ class EvdevTests(unittest.TestCase):
self.assertEqual(keytable.evdev_physical(194), "f24")
self.assertEqual(keytable.evdev_physical(111), "delete")
self.assertEqual(keytable.evdev_physical(113), "volume_mute")
+ self.assertEqual(keytable.evdev_physical(217), "search")
+ self.assertEqual(keytable.evdev_physical(224), "brightness_down")
+ self.assertEqual(keytable.evdev_physical(225), "brightness_up")
+ self.assertEqual(keytable.evdev_physical(248), "mic_mute")
def test_every_name_it_returns_is_in_the_spec_and_no_name_twice_but_enter(self):
names = list(keytable.EVDEV_NAMES.values())
diff --git a/core/tests/test_length_size_sliders.py b/core/tests/test_length_size_sliders.py
new file mode 100644
index 0000000..f5c3619
--- /dev/null
+++ b/core/tests/test_length_size_sliders.py
@@ -0,0 +1,111 @@
+import base64
+import unittest
+from types import SimpleNamespace
+
+from core import effects, settings_sync
+
+
+class LengthSizeSliderTests(unittest.TestCase):
+ def test_continuous_values_map_to_nearest_legacy_presets(self):
+ self.assertEqual([effects.length_preset(value) for value in (0.5, 1.0, 2.0)],
+ ["short", "normal", "long"])
+ self.assertEqual([effects.size_preset(value) for value in (0.03, 0.045, 0.06)],
+ ["small", "medium", "large"])
+ self.assertEqual(effects.length_preset(0.25), "short")
+ self.assertEqual(effects.size_preset(0.08), "large")
+
+ def test_fractional_size_scales_against_short_edge_and_keeps_clamp(self):
+ self.assertEqual(effects.edge_depth(1920, 1080, size_fraction=0.03), 32.4)
+ self.assertEqual(effects.edge_depth(640, 480, size_fraction=0.02), 24)
+ self.assertEqual(effects.edge_depth(3840, 2160, size_fraction=0.08), 144)
+
+ def test_each_style_play_time_uses_shared_effect_timing_and_pace(self):
+ self.assertEqual(effects.play_through_seconds("beam", 2.0), 1.2)
+ self.assertEqual(effects.play_through_seconds("aperture", 0.5), 0.31)
+
+ def test_switch_arrival_readout_uses_arrival_timing_when_there_is_no_departure(self):
+ self.assertEqual(effects.play_through_seconds("locator", 1.0), 0.72)
+
+ def test_shared_slider_readouts_use_core_timing_and_depth(self):
+ self.assertEqual(effects.design_slider_readouts("beam", 2.0, 0.06, 1920, 1080),
+ ("1.2 s", "65 pt"))
+
+ def test_preset_only_values_migrate_to_both_forms(self):
+ pace, fraction, length, size = effects.design_values(
+ length="long", size="small")
+ self.assertEqual((pace, fraction, length, size), (2.0, 0.03, "long", "small"))
+
+ def test_valid_continuous_values_take_precedence_and_invalid_values_fall_back(self):
+ self.assertEqual(effects.design_values(1.35, 0.052, "normal", "medium"),
+ (1.35, 0.052, "normal", "medium"))
+ self.assertEqual(effects.design_values(1.35, 0.052), (1.35, 0.052, "normal", "medium"))
+
+ def test_a_preset_that_disagrees_with_its_slider_value_was_set_later_and_wins(self):
+ self.assertEqual(effects.design_values(1.35, 0.052, "short", "small"),
+ (0.5, 0.03, "short", "small"))
+ self.assertEqual(effects.design_values(99, 0.9, "short", "large"),
+ (0.5, 0.06, "short", "large"))
+
+ def test_same_on_and_direct_design_sync_carry_both_forms(self):
+ values = {
+ "glow_style": "beam", "glow_colour": "signal", "effect_length": "normal",
+ "effect_size": "medium", "effect_pace": 1.35, "effect_size_fraction": 0.052,
+ "shortcut_arrival": True, "shortcut_arrival_style": "match",
+ }
+ state = {"set_at": 50, "by": base64.b64encode(bytes([1]) * 16).decode(), "values": values}
+ message = settings_sync.message_data(True, 50, values, design_state=state)
+ self.assertEqual(message["design"]["effect_pace"], 1.35)
+ self.assertEqual(message["design"]["effect_size_fraction"], 0.052)
+ received = settings_sync.read_design_state(
+ {"on": True, "set_at": 50, "by": state["by"], "design_sync": state}, set(), now=50)
+ self.assertEqual(received["values"]["effect_pace"], 1.35)
+ self.assertEqual(received["values"]["effect_size_fraction"], 0.052)
+
+ def test_152_shaped_state_uses_legacy_presets(self):
+ peer = base64.b64encode(bytes([1]) * 16).decode()
+ data = {"on": True, "set_at": 50, "by": peer,
+ "design": {"effect_length": "long", "effect_size": "small"}}
+ _on, _stamp, values = settings_sync.read(data, set(), now=50)
+ self.assertEqual((values["effect_pace"], values["effect_size_fraction"],
+ values["effect_length"], values["effect_size"]),
+ (2.0, 0.03, "long", "small"))
+ mac = settings_sync.apply_mac({"crossing": {"effect_length": "normal", "effect_size": "medium",
+ "methods": []}}, values)["crossing"]
+ self.assertEqual((mac["effect_pace"], mac["effect_size_fraction"]), (2.0, 0.03))
+ pc = SimpleNamespace(effect_length="normal", effect_size="medium", effect_pace=1.0,
+ effect_size_fraction=0.045, crossing_methods=[])
+ settings_sync.apply_pc(pc, values)
+ self.assertEqual((pc.effect_length, pc.effect_size, pc.effect_pace, pc.effect_size_fraction),
+ ("long", "small", 2.0, 0.03))
+
+ def test_152_direct_design_state_fills_both_legacy_and_continuous_values(self):
+ peer = base64.b64encode(bytes([1]) * 16).decode()
+ state = {"on": True, "set_at": 50, "by": peer,
+ "design_sync": {"set_at": 50, "by": peer,
+ "values": {"effect_length": "long"}}}
+ values = settings_sync.read_design_state(state, set(), now=50)["values"]
+ self.assertEqual((values["effect_pace"], values["effect_length"],
+ values["effect_size_fraction"], values["effect_size"]),
+ (2.0, "long", 0.045, "medium"))
+
+
+if __name__ == "__main__":
+ unittest.main()
+
+
+class PresetOnlyApplyTests(unittest.TestCase):
+ def test_a_preset_without_its_slider_value_replaces_the_held_one_on_both_apps(self):
+ raw = settings_sync.apply_mac({"crossing": {"effect_pace": 1.0, "effect_size_fraction": 0.045}},
+ {"effect_length": "long", "effect_size": "small"})
+ self.assertEqual((raw["crossing"]["effect_pace"], raw["crossing"]["effect_size_fraction"]), (2.0, 0.03))
+ config = SimpleNamespace(effect_pace=1.0, effect_size_fraction=0.045, effect_length="normal",
+ effect_size="medium")
+ settings_sync.apply_pc(config, {"effect_length": "short"})
+ self.assertEqual((config.effect_pace, config.effect_length), (0.5, "short"))
+
+ def test_a_followed_preset_replaces_the_followers_held_slider_value(self):
+ current = {"effect_length": "short", "effect_pace": 0.5}
+ state = {"set_at": 100, "by": "", "values": {"effect_length": "long"}}
+ taken = settings_sync.followed_design(current, state, "p", "p", False, -1, "", force=True)
+ self.assertEqual((taken["values"]["effect_length"], taken["values"]["effect_pace"]), ("long", 2.0))
+
diff --git a/core/tests/test_link.py b/core/tests/test_link.py
index 2c1361c..d07e8dd 100644
--- a/core/tests/test_link.py
+++ b/core/tests/test_link.py
@@ -58,6 +58,81 @@ def machine_with_peer(**kwargs):
return Machine([make(B, "Peer")], **kwargs).start()
+class ResponseTimeLinkTests(unittest.TestCase):
+ def test_capable_initiator_keeps_legacy_peer_pings_empty(self):
+ pings = []
+
+ def script(connection):
+ session, _hello = scripted_session(connection, TOKENS[B])
+ protocol.send_msg(connection, session, protocol.welcome_v6(HERE, "Here", "windows", "1.5.1", CAPS, True))
+ connection.settimeout(3)
+ while len(pings) < 2:
+ message = protocol.recv_msg(connection, session)
+ if message["type"] == protocol.MSG_PING:
+ pings.append(message)
+ protocol.send_msg(connection, session, protocol.ack_v6(0, 0))
+
+ server = Scripted(script)
+ self.addCleanup(server.stop)
+ side = Side(None)
+ side.peer()["port"] = server.port
+ identity = side.identity
+ side.identity = lambda: identity(caps=list(CAPS) + ["ping_rtt"])
+ link = side.link(reconnect_seconds=30)
+ self.addCleanup(link.stop)
+ link.start()
+ self.assertTrue(wait_for(lambda: len(pings) >= 2, 4.0), pings)
+ self.assertTrue(side.ups)
+ self.assertTrue(all(message["data"] == {} for message in pings))
+ self.assertIsNone(link.response_time_ms)
+
+ def test_ping_responses_do_not_credit_or_acknowledge_stalled_input(self):
+ now = [10.0]
+ link = Side(None).link(clock=lambda: now[0])
+ link._live = True
+ link._response_time_enabled = True
+ link._written_seq = 1
+ link._sent_at.append((1, now[0]))
+ probe = link._response_time.new_probe()
+ link._response_time.sent(probe)
+ now[0] += 0.02
+ link._handle_ping(protocol.ping_msg(echo=probe))
+ self.assertEqual(link.response_time_ms, 20)
+ self.assertEqual(link._last_ack_seq, -1)
+ self.assertIsNone(link.last_ack_at)
+ self.assertEqual(link._ack_stall_credit, {})
+ now[0] = 10.0 + link_module.ACK_STALL_SECONDS + 0.01
+ with self.assertRaisesRegex(link_module.LinkEnded, "stopped acknowledging input"):
+ link._tick(now[0])
+
+ def test_negotiated_probes_measure_both_link_directions_and_clear_on_close(self):
+ caps = tuple(CAPS) + ("ping_rtt",)
+ machine = machine_with_peer(caps=caps)
+ self.addCleanup(machine.stop)
+ side = Side(machine)
+ side.identity = lambda: {
+ "id": side.own, "name": "Near", "platform": "macos", "app": "1.5.2",
+ "caps": list(caps), "port": 24820,
+ }
+ link = side.link()
+ self.addCleanup(link.stop)
+ link.start()
+
+ self.assertTrue(wait_for(lambda: link.response_time_ms is not None, 5.0))
+ self.assertIsNotNone(machine.responder.response_time_ms(B))
+
+ deadline = time.monotonic() + 3.2
+ while time.monotonic() < deadline:
+ self.assertTrue(link.send_input(protocol.mousemove_msg(1, 0)))
+ time.sleep(0.02)
+ self.assertIsNotNone(link.response_time_ms)
+ self.assertIsNotNone(machine.responder.response_time_ms(B))
+
+ link.stop()
+ self.assertIsNone(link.response_time_ms)
+ self.assertTrue(wait_for(lambda: machine.responder.response_time_ms(B) is None))
+
+
class Scripted:
"""A listener that runs `script(connection)` for each connection."""
@@ -320,7 +395,8 @@ class LinkRefusalTests(unittest.TestCase):
side.peer()["port"] = server.port
link = self.link(side)
self.assertTrue(wait_for(lambda: side.states))
- self.assertIn("under another machine: remove it on both and pair again", side.last_text())
+ self.assertIn("under another machine: use Re-pair on Overview", side.last_text())
+ self.assertEqual(side.peer().get("dormant_reason"), "wrong_id")
seen = server.connections
time.sleep(0.5)
self.assertEqual(server.connections, seen)
@@ -351,7 +427,8 @@ class LinkRefusalTests(unittest.TestCase):
self.assertIn("may have removed this machine", side.states[0][1])
now[0] += link_module.FORGOTTEN_AFTER_SECONDS
self.assertTrue(wait_for(lambda: "no longer has this pairing" in (side.last_text() or ""), 5.0), side.states)
- self.assertEqual(side.last_text(), "Far no longer has this pairing: remove Far here and pair the two again")
+ self.assertEqual(side.last_text(), "Far no longer has this pairing: use Re-pair on Overview")
+ self.assertEqual(side.peer().get("dormant_reason"), "forgotten")
seen = server.connections
time.sleep(0.5)
self.assertEqual(server.connections, seen)
@@ -447,6 +524,26 @@ class LinkLiveTests(unittest.TestCase):
self.assertIn(("key", "a", True), self.machine.injected())
self.assertEqual(self.link.last_sent_seq, 2)
+ def test_a_slow_injection_logs_the_input_type_and_injection_call(self):
+ self.take()
+ original = self.machine.injector.inject_mouse_move
+
+ def slow_move(dx, dy):
+ time.sleep(0.26)
+ original(dx, dy)
+
+ self.machine.injector.inject_mouse_move = slow_move
+ with self.assertLogs(receiver.LOGGER, level="WARNING") as said:
+ self.assertTrue(self.link.send_input(protocol.mousemove_msg(3, 4)))
+ self.assertTrue(wait_for(lambda: any("slow input injection" in line for line in said.output), 2.0), said.output)
+ self.assertTrue(any("mousemove" in line and "inject_mouse_move" in line for line in said.output), said.output)
+
+ def test_a_shortcut_arrival_without_an_edge_is_logged(self):
+ with self.assertLogs(receiver.LOGGER, level="INFO") as said:
+ self.assertTrue(self.link.post(protocol.focus_v6(1, HERE, resistance_px=120, reach=[])))
+ self.assertTrue(wait_for(lambda: any("input arrived by its shortcut" in line for line in said.output), 2.0), said.output)
+ self.assertTrue(any("pointer stays at" in line for line in said.output), said.output)
+
def test_acks_give_round_trip_samples_that_are_never_negative(self):
self.take()
for _ in range(5):
@@ -474,6 +571,16 @@ class LinkLiveTests(unittest.TestCase):
time.sleep(0.2)
self.assertEqual(self.machine.settings_seen, [])
+ def test_focus_display_target_is_stripped_for_a_peer_without_displays(self):
+ self.link._caps = frozenset()
+ queued = []
+ self.link._enqueue = lambda message, seq: queued.append(message) or True
+ self.assertTrue(self.link.post(protocol.focus_v6(1, HERE, resistance_px=120, reach=[],
+ display="panel-right", side="bottom")))
+ message = queued[0]
+ self.assertNotIn("display", message["data"])
+ self.assertNotIn("side", message["data"])
+
def test_the_link_reconnects_after_the_responder_closes_it(self):
first = len(self.side.ups)
self.machine.responder.peers_changed()
@@ -519,6 +626,7 @@ class LinkLivenessTests(unittest.TestCase):
self.assertGreaterEqual(time.monotonic() - began, 1.5)
self.assertFalse(link.live())
+
def test_an_idle_link_pings_each_second(self):
pings = []
@@ -612,6 +720,127 @@ class FakeClock:
return self.now
+class AckStallTests(unittest.TestCase):
+ def test_a_blocked_clipboard_callback_is_included_in_ack_stall_credit(self):
+ clock = FakeClock()
+
+ def script(connection):
+ session, _hello = scripted_session(connection, TOKENS[B])
+ protocol.send_msg(connection, session, protocol.welcome_v6(HERE, "Here", "windows", "1.5.2", CAPS, True))
+ connection.settimeout(5)
+ while True:
+ message = protocol.recv_msg(connection, session)
+ seq = message.get("data", {}).get("seq")
+ if seq:
+ break
+ clipboard = session.seal(protocol.clipboard_msg("c" * protocol.CLIPBOARD_MAX_BYTES))
+ acknowledgement = session.seal(protocol.ack_v6(seq, 0))
+ connection.sendall(clipboard + acknowledgement)
+ time.sleep(2)
+
+ server = Scripted(script)
+ self.addCleanup(server.stop)
+ side = Side(None)
+ side.peer()["port"] = server.port
+ link = side.link(clock=clock)
+ self.addCleanup(link.stop)
+ original_call = link._call
+ original_end = link._end_ack_pause
+
+ def advance_during_clipboard(index, *args):
+ if index == 2 and args[0].get("type") == protocol.MSG_CLIPBOARD:
+ clock.now += 2.0
+ original_call(index, *args)
+
+ def check_credit_before_the_queued_ack(ended):
+ original_end(ended)
+ link._tick(clock())
+
+ link._call = advance_during_clipboard
+ link._end_ack_pause = check_credit_before_the_queued_ack
+ link.start()
+ self.assertTrue(wait_for(lambda: side.ups))
+ self.assertTrue(link.send_input(protocol.key_msg("keydown", "a")))
+ self.assertTrue(wait_for(lambda: link._last_ack_seq == 1), side.states)
+ self.assertTrue(link.live())
+
+ def test_a_clipboard_trickling_in_does_not_count_as_an_ack_stall(self):
+ def script(connection):
+ session, _hello = scripted_session(connection, TOKENS[B])
+ protocol.send_msg(connection, session, protocol.welcome_v6(HERE, "Here", "windows", "1.5.2", CAPS, True))
+ connection.settimeout(5)
+ while True:
+ message = protocol.recv_msg(connection, session)
+ seq = message.get("data", {}).get("seq")
+ if seq:
+ break
+ frame = session.seal(protocol.clipboard_msg("c" * protocol.CLIPBOARD_MAX_BYTES))
+ for offset in range(0, len(frame), 8192):
+ connection.sendall(frame[offset:offset + 8192])
+ time.sleep(0.12)
+ protocol.send_msg(connection, session, protocol.ack_v6(seq, 0))
+ time.sleep(2)
+
+ server = Scripted(script)
+ self.addCleanup(server.stop)
+ side = Side(None)
+ side.peer()["port"] = server.port
+ link = side.link()
+ self.addCleanup(link.stop)
+ link.start()
+ self.assertTrue(wait_for(lambda: side.ups))
+ self.assertTrue(link.send_input(protocol.key_msg("keydown", "a")))
+ self.assertTrue(wait_for(lambda: link._last_ack_seq == 1, 6.0), side.states)
+ self.assertTrue(link.live())
+
+ def test_a_live_heartbeat_cannot_keep_unacknowledged_input_away(self):
+ machine = machine_with_peer()
+ self.addCleanup(machine.stop)
+ side = Side(machine)
+ now = [100.0]
+ link = side.link(clock=lambda: now[0], reconnect_seconds=30)
+ self.addCleanup(link.stop)
+ link.start()
+ self.assertTrue(wait_for(lambda: side.ups), side.states)
+ self.assertTrue(link.post(protocol.focus_v6(1, HERE, resistance_px=120, reach=[])))
+ self.assertTrue(wait_for(lambda: any(m["type"] == protocol.MSG_ACCEPT for m in side.messages)))
+
+ self.assertTrue(link.send_input(protocol.key_msg("keydown", "a")))
+ self.assertTrue(wait_for(lambda: ("key", "a", True) in machine.injected()))
+ self.assertTrue(wait_for(lambda: link._last_ack_seq == 1))
+
+ injecting = threading.Event()
+ release = threading.Event()
+ self.addCleanup(release.set)
+
+ def blocked_move(dx, dy):
+ injecting.set()
+ release.wait(5)
+ machine.injector._add("move", dx, dy)
+
+ machine.injector.inject_mouse_move = blocked_move
+ self.assertTrue(all(link.send_input(protocol.mousemove_msg(1, 1)) for _ in range(50)))
+ self.assertTrue(injecting.wait(2), "the responder never began the blocked injection")
+
+ acknowledgements = []
+ original_ack = link._ack
+
+ def record_ack(ack):
+ acknowledgements.append(ack["seq"])
+ original_ack(ack)
+
+ link._ack = record_ack
+ self.assertTrue(wait_for(lambda: 1 in acknowledgements), acknowledgements)
+ now[0] += 1.51
+ self.assertTrue(wait_for(lambda: side.states and not side.states[-1][0]), side.states)
+ self.assertTrue(any(seq == 1 for seq in acknowledgements), acknowledgements)
+ self.assertIn("stopped acknowledging input", side.last_text())
+
+ release.set()
+ self.assertTrue(wait_for(lambda: ("release_all",) in machine.injector.seen()))
+ self.assertFalse(machine.responder.driven)
+
+
class LinkFollowTests(unittest.TestCase):
def link(self, clock, tried):
side = Side(None)
@@ -653,6 +882,22 @@ class LinkFollowTests(unittest.TestCase):
link.follow(beacon)
self.assertTrue(wait_for(lambda: ("192.168.77.9", 24820) in tried), tried)
+ def test_discovery_matches_the_machine_name_not_its_local_label(self):
+ clock, tried = FakeClock(), []
+ side, link = self.link(clock, tried)
+ side.peer()["label"] = "Work Mac"
+ link.start()
+ self.assertTrue(wait_for(lambda: tried))
+ tried.clear()
+ clock.now += 11
+
+ link.follow([{"name": "Work Mac", "address": "192.168.77.9"}])
+ time.sleep(0.1)
+ self.assertNotIn(("192.168.77.9", 24820), tried)
+
+ link.follow([{"name": "Far", "address": "192.168.77.10"}])
+ self.assertTrue(wait_for(lambda: ("192.168.77.10", 24820) in tried), tried)
+
def test_a_beacon_that_names_another_machine_is_never_tried_and_one_at_its_address_is_tried_last(self):
clock, tried = FakeClock(), []
side, link = self.link(clock, tried)
@@ -1173,6 +1418,15 @@ class RoundTripLogTests(unittest.TestCase):
self.now[0] = 160.1
self.link._tick(160.1)
+ def test_a_minute_with_input_but_no_advancing_ack_logs_the_pending_input(self):
+ self.link._written_seq = 5
+ self.link._sent_at.extend((seq, 100.0) for seq in range(1, 6))
+ with self.assertLogs("Beamer", "INFO") as logged:
+ self.now[0] = 160.1
+ self.link._log_round_trips()
+ self.assertIn("sent 5, acknowledged 0", logged.output[-1])
+ self.assertIn("oldest unacknowledged seq 1 for 60.1 s", logged.output[-1])
+
def test_what_was_logged_is_not_counted_again(self):
self.acks(5)
self.now[0] = 160.1
diff --git a/core/tests/test_owner.py b/core/tests/test_owner.py
index 50c2be9..15679a6 100644
--- a/core/tests/test_owner.py
+++ b/core/tests/test_owner.py
@@ -78,6 +78,18 @@ class OwnerCase(unittest.TestCase):
def switch(self, frm, nxt, route=None, **where):
return self.o.switch(frm, {"route": self.o.route if route is None else route, "next": nxt, **where})
+ def test_the_active_chain_keeps_every_machine_in_an_onward_crossing(self):
+ self.o.go("B")
+ self.assertEqual(self.o.chain, ("A", "B"))
+ self.o.switch("B", {"route": self.o.route, "next": "C"})
+ self.o.accept("C", {"route": self.o.route})
+ self.assertEqual(self.o.chain, ("A", "B", "C"))
+
+ def test_a_busy_refusal_keeps_the_machine_in_the_way_in_the_chain(self):
+ self.o.go("B")
+ self.o.refuse("B", {"route": self.o.route, "why": "busy", "other": "C"})
+ self.assertEqual(self.o.chain, ("A", "B", "C"))
+
class TakeFromHomeTests(OwnerCase):
def test_a_take_by_a_zone_carries_the_route_the_landing_the_resistance_and_the_reach(self):
@@ -88,6 +100,12 @@ class TakeFromHomeTests(OwnerCase):
self.assertEqual(self.o.on, "B")
self.assertEqual(self.o.reach_sent, ["C", "D"])
+ def test_a_take_carries_the_receiving_display_and_side(self):
+ self.assertEqual(focuses(self.o.go("B", "left", 0.5, display="panel-right", side="bottom")),
+ [{"route": 1, "target": "B", "edge": "left", "offset": 0.5,
+ "display": "panel-right", "side": "bottom",
+ "resistance_px": 120, "reach": ["C", "D"]}])
+
def test_a_take_by_the_shortcut_has_no_landing(self):
self.assertEqual(focuses(self.o.go("B")), [{"route": 1, "target": "B", "resistance_px": 120, "reach": ["C", "D"]}])
diff --git a/core/tests/test_pairing_paths.py b/core/tests/test_pairing_paths.py
index e2cb0aa..9963b01 100644
--- a/core/tests/test_pairing_paths.py
+++ b/core/tests/test_pairing_paths.py
@@ -59,10 +59,13 @@ class InterfaceTests(unittest.TestCase):
network = ipaddress.IPv4Network(f"{address}/{netmask}", strict=False)
self.assertFalse(ipaddress.IPv4Address(address).is_loopback, address)
self.assertLess(network.prefixlen, 31, (address, netmask))
- # Checked against the routing table, which knows nothing of how the list was read.
- routed = pairing.pairing_address()
- if routed is not None:
- self.assertIn(routed, [address for address, _netmask in found])
+ # The default route can use a VPN excluded from this broadcast-interface list.
+ self.assertTrue(_can_bind(address), address)
+
+ def test_pairing_address_prefers_a_private_default_route_outside_broadcast_interfaces(self):
+ with mock.patch.object(pairing, "local_address_towards", return_value="10.8.0.4"), \
+ mock.patch.object(pairing, "_local_ipv4_addresses", return_value=["192.168.50.22"]):
+ self.assertEqual(pairing.pairing_address(), "10.8.0.4")
def test_a_platform_that_will_not_say_gives_none(self):
failing = mock.patch.object(pairing, "_posix_interfaces" if pairing.sys.platform != "win32" else "_windows_interfaces",
diff --git a/core/tests/test_pairing_service.py b/core/tests/test_pairing_service.py
index 1e64422..bbb7de5 100644
--- a/core/tests/test_pairing_service.py
+++ b/core/tests/test_pairing_service.py
@@ -268,6 +268,25 @@ class TcpTests(unittest.TestCase):
self.assertTrue(wait_until(lambda: self.pc.paired))
self.assertEqual(self.pc.paired[0]["token"], saved["token"])
+ def test_code_and_qr_repair_a_dormant_same_id_without_removing_it(self):
+ for use_qr in (False, True):
+ with self.subTest(qr=use_qr):
+ old = {**entry(PC_ID, name="TCP PC", paired_at=1_700_000_000),
+ "linked": True, "dormant": True, "dormant_reason": "forgotten"}
+ self.mac.book.entries[:] = [old]
+ self.pc.book.entries.clear()
+ paired_before = len(self.pc.paired)
+ code = self.pc.service.begin_pairing()
+ if use_qr:
+ saved = self.mac.service.pair_by_qr(self.pc.service.qr_text("127.0.0.1"))
+ else:
+ saved = self.mac.service.pair_by_address("127.0.0.1", code, port=self.pc.tcp_port)
+ self.assertTrue(wait_until(lambda: len(self.pc.paired) > paired_before))
+ self.assertEqual(self.mac.book.entries, [saved])
+ self.assertEqual(self.mac.book.stored[-1][1], old)
+ self.assertEqual(self.pc.paired[-1]["token"], saved["token"])
+ self.assertNotIn("dormant", saved)
+
def test_scanning_the_qr_of_a_machine_already_paired_does_not_pair(self):
self.mac.book.entries.append(entry(PC_ID, name="TCP PC", paired_at=1_700_000_000))
self.pc.service.begin_pairing()
diff --git a/core/tests/test_pairing_v3.py b/core/tests/test_pairing_v3.py
index b501625..86b2d4e 100644
--- a/core/tests/test_pairing_v3.py
+++ b/core/tests/test_pairing_v3.py
@@ -325,6 +325,27 @@ class KnownTests(unittest.TestCase):
class FullTests(unittest.TestCase):
+ def test_full_requester_repairs_the_matching_dormant_host(self):
+ peers = [entry(bytes([n]) * 16) for n in range(1, 32)]
+ peers.append({**entry(HOST_ID), "dormant": True, "dormant_reason": "forgotten"})
+ rig = Rig(requester_book=Book(peers))
+ rig.begin()
+ client, *_rest, token = rig.exchange()
+ self.assertEqual(client.replaces["id"], b64(HOST_ID))
+ self.assertEqual(client.entry("192.168.77.4")["token"], token)
+
+ def test_full_requester_with_a_dormant_peer_rejects_a_new_host_before_confirmation(self):
+ peers = [entry(bytes([n]) * 16) for n in range(1, 33)]
+ peers[0].update(dormant=True, dormant_reason="forgotten")
+ rig = Rig(requester_book=Book(peers))
+ rig.begin()
+ client = rig.client()
+ answer = rig.host.handle(client.start(), "192.168.77.5")
+ with self.assertRaises(PairingError) as caught:
+ client.accept(answer)
+ self.assertEqual(str(caught.exception), pairing.ERROR_FULL)
+ self.assertEqual(rig.host_book.stored, [])
+
def test_a_host_with_32_peers_shows_no_code(self):
rig = Rig(host_book=Book([entry(bytes([n]) * 16) for n in range(1, 33)]))
with self.assertRaises(PairingError) as caught:
diff --git a/core/tests/test_peerlist.py b/core/tests/test_peerlist.py
index 93df5de..e86989c 100644
--- a/core/tests/test_peerlist.py
+++ b/core/tests/test_peerlist.py
@@ -4,7 +4,7 @@ import copy
import time
import unittest
-from core import pairing, peerlist
+from core import pairing, peerlist, protocol, ways
A = "AAAAAAAAAAAAAAAAAAAAAA"
B = "BBBBBBBBBBBBBBBBBBBBBw"
@@ -26,6 +26,24 @@ class LabelTests(unittest.TestCase):
labels = peerlist.labels([peer(A, "Desk"), peer(B, "Laptop")])
self.assertEqual(labels, {A * 3: "Desk", B * 3: "Laptop"})
+ def test_a_set_label_wins_but_an_empty_label_uses_the_machine_name(self):
+ labelled = peer(A, "Discovered name", label=" Work Mac ")
+ cleared = peer(B, "This PC", label=" ")
+
+ self.assertEqual(peerlist.labels([labelled, cleared]),
+ {labelled["token"]: "Work Mac", cleared["token"]: "This PC"})
+
+ def test_a_label_is_trimmed_to_64_characters(self):
+ entry = peer(A, "Machine", label=" " + "X" * 70 + " ")
+
+ self.assertEqual(peerlist.labels([entry])[entry["token"]], "X" * 64)
+
+ def test_duplicate_labels_keep_the_existing_id_tail(self):
+ first, second = peer(A, "First", label="Desk"), peer(B, "Second", label="Desk")
+
+ self.assertEqual(peerlist.labels([first, second]),
+ {first["token"]: "Desk (AAAA)", second["token"]: "Desk (BBBw)"})
+
def test_two_machines_with_one_name_each_show_the_last_four_characters_of_their_id(self):
labels = peerlist.labels([peer(A, "Desk"), peer(B, "Desk"), peer(C, "Laptop")])
self.assertEqual(labels[A * 3], "Desk (AAAA)")
@@ -47,13 +65,29 @@ class LabelTests(unittest.TestCase):
self.assertEqual(labels[B * 3], "Unnamed machine")
def test_a_phone_without_a_token_is_not_labelled_as_a_machine(self):
- phone = {"id": "phone", "name": "Toby's phone", "port": 0}
+ phone = {"id": "phone", "name": "Sam's phone", "port": 0}
labels = peerlist.labels([peer(A, "Desk"), phone])
self.assertEqual(labels, {A * 3: "Desk"})
def test_a_paired_phone_keeps_its_label_for_input_sent_to_this_machine(self):
- phone = {"id": "phone", "name": "Toby's phone", "port": 0, "token": "phone-token"}
- self.assertEqual(peerlist.labels([phone]), {"phone-token": "Toby's phone"})
+ phone = {"id": "phone", "name": "Phone", "port": 0, "token": "phone-token"}
+ self.assertEqual(peerlist.labels([phone]), {"phone-token": "Phone"})
+
+
+class PairedIdsTests(unittest.TestCase):
+ def test_lists_only_live_desktops_and_excludes_the_receiver(self):
+ desktop = protocol.id_text(bytes([1]) * 16)
+ phone = protocol.id_text(bytes([2]) * 16)
+ dormant = protocol.id_text(bytes([3]) * 16)
+ receiver = protocol.id_text(bytes([4]) * 16)
+ peers = [
+ {"id": desktop, "port": 24820},
+ {"id": phone, "port": 0},
+ {"id": dormant, "port": 24820, "dormant": True, "dormant_reason": "forgotten"},
+ {"id": receiver, "port": 24820},
+ ]
+
+ self.assertEqual(peerlist.paired_ids(peers, exclude=receiver), [desktop])
class AddPeerTests(unittest.TestCase):
@@ -73,12 +107,16 @@ class AddPeerTests(unittest.TestCase):
# (the rig and the laptop, 01-10-2026).
held = settings(peer(A, side="left"), zones=[{"peer": A, "kind": "edge"}])
peerlist.add_peer(held, peer(B, token="second"))
- self.assertEqual(held["zones"], [{"peer": A, "kind": "edge"}, {"peer": B, "kind": "edge"}])
+ self.assertEqual(held["zones"], [{"peer": A, "kind": "edge", "side": "left"},
+ {"peer": B, "kind": "edge", "side": "bottom"}])
+ self.assertEqual(ways.ways(held, B)["methods"], ["edge"])
+ self.assertEqual(ways.ways(held, B)["parts"], list(ways.PARTS))
def test_the_replaced_entrys_zones_go_with_it_when_it_was_matched_by_name_alone(self):
held = settings(peer("", token="legacy", host="10.1.1.9", from_1_4=True), zones=[{"peer": "", "kind": "edge"}])
peerlist.add_peer(held, peer(A), replaced=copy.deepcopy(held["peers"][0]))
- self.assertEqual(held["zones"], [{"peer": A, "kind": "edge"}])
+ self.assertEqual(held["zones"], [{"peer": A, "kind": "edge", "side": "bottom"}])
+ self.assertEqual(ways.ways(held, A)["methods"], ["edge"])
def test_the_machine_at_the_1_4_entrys_host_takes_over_its_side_and_zones(self):
# Every 1.4.x upgrader pairs again (no token migrates), and the user is at the screen
@@ -88,35 +126,43 @@ class AddPeerTests(unittest.TestCase):
held = settings(old, zones=[{"peer": "", "kind": "edge"}, {"peer": "", "kind": "corner", "corner": "top_left",
"edge": "left", "off": True}])
peerlist.add_peer(held, peer(A, token="fresh"), replaced=copy.deepcopy(old))
- self.assertEqual(held["zones"], [{"peer": A, "kind": "edge"},
- {"peer": A, "kind": "corner", "corner": "top_left", "edge": "left", "off": True}])
+ self.assertEqual(held["zones"], [{"peer": A, "kind": "edge", "side": "left"}])
+ self.assertEqual(ways.ways(held, A)["methods"], ["edge"])
entry = held["peers"][0]
self.assertEqual((entry["side"], entry["side_set_at"], entry["side_by"]), ("left", 1_790_000_000, C))
self.assertEqual(entry["token"], "fresh")
- def test_a_machine_at_that_host_of_another_platform_takes_nothing(self):
+ def test_a_machine_at_that_host_of_another_platform_uses_its_derived_side(self):
old = peer("", token="legacy", platform="macos", from_1_4=True, side="left")
held = settings(old, zones=[{"peer": "", "kind": "edge"}])
peerlist.add_peer(held, peer(A, token="fresh"), replaced=copy.deepcopy(old))
- self.assertEqual(held["zones"], [{"peer": A, "kind": "edge"}])
- self.assertEqual(held["peers"][0]["side"], "")
+ self.assertEqual(held["zones"], [{"peer": A, "kind": "edge", "side": "bottom"}])
+ self.assertEqual(ways.ways(held, A)["methods"], ["edge"])
+ self.assertEqual(held["peers"][0]["side"], "bottom")
def test_an_entry_that_is_not_the_1_4_one_gives_nothing_by_host(self):
old = peer(B, token="legacy", linked=False, side="left")
held = settings(old, zones=[{"peer": B, "kind": "edge"}])
peerlist.add_peer(held, peer(A, token="fresh"), replaced=copy.deepcopy(old))
- self.assertEqual(held["zones"], [{"peer": A, "kind": "edge"}])
+ self.assertEqual(held["zones"], [{"peer": A, "kind": "edge", "side": "bottom"}])
+ self.assertEqual(ways.ways(held, A)["methods"], ["edge"])
def test_zones_of_a_machine_paired_again_under_its_own_id_stay(self):
held = settings(peer(A, linked=False), zones=[{"peer": A, "kind": "edge"}])
peerlist.add_peer(held, peer(A, token="fresh"), replaced=copy.deepcopy(held["peers"][0]))
- self.assertEqual(held["zones"], [{"peer": A, "kind": "edge"}])
+ self.assertEqual(held["zones"], [{"peer": A, "kind": "edge", "side": "bottom"}])
+ self.assertEqual(ways.ways(held, A)["methods"], ["edge"])
self.assertEqual(held["peers"][0]["token"], "fresh")
def test_other_machines_zones_are_left_alone(self):
held = settings(peer(A), peer("", token="legacy", from_1_4=True), zones=[{"peer": A, "kind": "edge"}])
peerlist.add_peer(held, peer(B), replaced=copy.deepcopy(held["peers"][1]))
- self.assertEqual(held["zones"], [{"peer": A, "kind": "edge"}, {"peer": B, "kind": "edge"}])
+ self.assertEqual(held["zones"], [
+ {"peer": A, "kind": "part", "parts": ["start"], "side": "bottom"},
+ {"peer": B, "kind": "part", "parts": ["middle", "end"], "side": "bottom"},
+ ])
+ self.assertEqual(ways.ways(held, A)["methods"], ["edge"])
+ self.assertEqual(ways.ways(held, B)["methods"], ["edge"])
def test_an_entry_replaced_by_token_is_found_though_the_caller_holds_a_copy(self):
held = settings(peer(A, token="one"))
@@ -127,10 +173,25 @@ class AddPeerTests(unittest.TestCase):
class RemovePeerTests(unittest.TestCase):
def test_the_entry_and_its_zones_go(self):
held = settings(peer(A), peer(B), zones=[{"peer": A, "kind": "edge"}, {"peer": B, "kind": "edge"}])
+ held["layout"] = {A: {"x": 0, "y": 0, "w": 160, "h": 100},
+ B: {"x": 160, "y": 0, "w": 160, "h": 100}}
removed = peerlist.remove_peer(held, A * 3)
self.assertEqual(removed["id"], A)
self.assertEqual([entry["id"] for entry in held["peers"]], [B])
self.assertEqual(held["zones"], [{"peer": B, "kind": "edge"}])
+ self.assertNotIn(A, held["layout"])
+
+ def test_forgetting_the_peer_that_lists_a_third_party_prunes_its_tile(self):
+ held = settings(peer(A, paired_with=[B]), peer(C))
+ held["machine_id"] = C
+ held["layout"] = {A: {"x": 160, "y": 0, "w": 160, "h": 100},
+ B: {"x": 320, "y": 0, "w": 160, "h": 100, "name": "Test box"},
+ C: {"x": 0, "y": 0, "w": 160, "h": 100}}
+
+ peerlist.remove_peer(held, A * 3)
+
+ self.assertNotIn(A, held["layout"])
+ self.assertNotIn(B, held["layout"])
def test_an_unknown_token_removes_nothing(self):
held = settings(peer(A))
@@ -209,9 +270,14 @@ class LabelForTests(unittest.TestCase):
self.assertIn("(", peerlist.label_for([first, second], token=first["token"]))
def test_a_phone_without_a_token_has_no_machine_label(self):
- phone = {"id": "phone", "name": "Toby's phone", "port": 0}
+ phone = {"id": "phone", "name": "Sam's phone", "port": 0}
self.assertEqual(peerlist.label_for([peer(A, "Desk"), phone], peer_id="phone"), "")
+ def test_a_known_desktop_name_does_not_require_a_pairing_token_to_be_displayed(self):
+ desktop = {"id": "mac", "name": "Sams-MacBook-Pro", "port": 24820}
+
+ self.assertEqual(peerlist.label_for([desktop], peer_id="mac"), "Sams-MacBook-Pro")
+
def test_a_machine_nobody_knows_has_no_label(self):
self.assertEqual(peerlist.label_for([peer(A, "Desk")], token="nope"), "")
self.assertEqual(peerlist.label_for([], peer_id="nope"), "")
@@ -247,6 +313,13 @@ class RefusalTextTests(unittest.TestCase):
for why in ("not_allowed", "sent_home", "malformed", "refused", "no_answer", "link_lost"):
self.assertIsNone(peerlist.refusal_text(why, "Bee", "Sea"))
+ def test_a_repeated_refusal_notice_is_suppressed_during_the_same_push(self):
+ throttle = peerlist.RefusalThrottle()
+ message = peerlist.refusal_text("busy", "Desk-PC", "Laptop-PC")
+ self.assertTrue(throttle.allow(message, 10.0))
+ self.assertFalse(throttle.allow(message, 20.0))
+ self.assertTrue(throttle.allow(message, 41.0))
+
if __name__ == "__main__":
unittest.main()
diff --git a/core/tests/test_protocol_v6.py b/core/tests/test_protocol_v6.py
index 789d668..034cb1a 100644
--- a/core/tests/test_protocol_v6.py
+++ b/core/tests/test_protocol_v6.py
@@ -502,6 +502,19 @@ class HelloAndWelcome(unittest.TestCase):
self.assertIsNone(read["hw"])
self.assertNotIn("port", welcome["data"])
+ def test_ping_metadata_is_optional_bounded_and_one_way(self):
+ self.assertEqual(protocol.ping_msg(), {"type": "ping", "data": {}})
+ probe = protocol.ping_msg(probe=7)
+ echo = protocol.ping_msg(echo=7)
+ self.assertEqual(protocol.read_ping(probe), {"probe": 7})
+ self.assertEqual(protocol.read_ping(echo), {"echo": 7})
+ for data in (
+ {"probe": True}, {"probe": 0}, {"probe": 2**31},
+ {"echo": "7"}, {"probe": 7, "echo": 8},
+ ):
+ with self.subTest(data=data):
+ self.assertIsNone(protocol.read_ping({"type": "ping", "data": data}))
+
def test_invalid_hellos(self):
cases = {
"version 5": _hello(version=5),
@@ -563,6 +576,13 @@ class Focus(unittest.TestCase):
self.assertEqual((read["edge"], read["offset"], read["resistance_px"], read["reach"], read["stay"]),
("left", 0.25, 90, [ID_C], False))
+ def test_take_can_name_a_display_edge_without_breaking_legacy_landing(self):
+ message = protocol.focus_v6(7, ID_B, edge="left", offset=0.25, display="panel-right", side="bottom")
+ read = protocol.read_focus(message, ID_B)
+ self.assertEqual((read["display"], read["side"], read["edge"], read["offset"]),
+ ("panel-right", "bottom", "left", 0.25))
+ self.assertFalse(read["malformed"])
+
def test_defaults_and_clamping(self):
read = protocol.read_focus({"type": "focus", "data": {"route": 1, "target": protocol.id_text(ID_B),
"edge": "top", "offset": 1.5}}, ID_B)
@@ -608,6 +628,14 @@ class Focus(unittest.TestCase):
self.assertEqual(read["route"], 4)
self.assertTrue(read["malformed"])
+ def test_display_and_side_must_be_a_valid_pair(self):
+ target = protocol.id_text(ID_B)
+ for extra in ({"display": "panel-right"}, {"side": "bottom"},
+ {"display": "", "side": "bottom"}, {"display": "panel-right", "side": "diagonal"}):
+ with self.subTest(extra=extra):
+ read = protocol.read_focus({"type": "focus", "data": dict({"route": 4, "target": target}, **extra)}, ID_B)
+ self.assertTrue(read["malformed"])
+
def test_strictness_marks_a_take_malformed(self):
initiator, responder, _, _ = _pair()
plain = ('{"type":"focus","data":{"route":4,"target":"%s","offset":NaN,"edge":"left"}}' % protocol.id_text(ID_B)).encode()
@@ -649,9 +677,13 @@ class Answers(unittest.TestCase):
def test_switch(self):
read = protocol.read_switch(protocol.switch_v6(3, ID_A, edge="right", offset=0.5))
- self.assertEqual(read, {"route": 3, "next": ID_A, "edge": "right", "offset": 0.5})
+ self.assertEqual(read, {"route": 3, "next": ID_A, "edge": "right", "offset": 0.5,
+ "display": None, "side": None})
read = protocol.read_switch(protocol.switch_v6(3, ID_A))
- self.assertEqual(read, {"route": 3, "next": ID_A, "edge": None, "offset": None})
+ self.assertEqual(read, {"route": 3, "next": ID_A, "edge": None, "offset": None,
+ "display": None, "side": None})
+ read = protocol.read_switch(protocol.switch_v6(3, ID_A, display="panel-left", side="right"))
+ self.assertEqual((read["display"], read["side"]), ("panel-left", "right"))
for data in ({"route": 3, "next": protocol.id_text(ID_A), "edge": "right"},
{"route": 3, "next": protocol.id_text(ID_A), "offset": 0.5},
{"route": 3, "next": "x"}, {"route": 0, "next": protocol.id_text(ID_A)}):
diff --git a/core/tests/test_responder_handshake.py b/core/tests/test_responder_handshake.py
index ba37839..325a10d 100644
--- a/core/tests/test_responder_handshake.py
+++ b/core/tests/test_responder_handshake.py
@@ -197,6 +197,7 @@ class TheIdsInHello(Case):
self.initiator(peer=D, key=TOKENS[B]).handshake()
self.assertEqual(refused.exception.error, protocol.ERROR_WRONG_ID)
self.assertEqual(self.machine.settings.peer(TOKENS[B])["id"], protocol.id_text(B))
+ self.assertEqual(self.machine.settings.peer(TOKENS[B]).get("dormant_reason"), "wrong_id")
def test_the_answer_is_followed_by_a_close(self):
link = self.initiator(peer=D, key=TOKENS[B])
diff --git a/core/tests/test_responder_ownership.py b/core/tests/test_responder_ownership.py
index 47a28d4..6c09276 100644
--- a/core/tests/test_responder_ownership.py
+++ b/core/tests/test_responder_ownership.py
@@ -517,6 +517,16 @@ class ZoneModels(unittest.TestCase):
self.assertEqual({model.resistance_px for _, model in found}, {150})
self.assertEqual(found[2][1].parts, frozenset({"start", "end"}))
+ def test_one_peer_can_hold_edges_on_multiple_displays(self):
+ zones = [
+ {"peer": protocol.id_text(B), "kind": "edge", "display": "panel-left", "side": "right"},
+ {"peer": protocol.id_text(B), "kind": "part", "parts": ["middle"],
+ "display": "panel-right", "side": "bottom"},
+ ]
+ found = self.models(zones, allowed=(B,))
+ self.assertEqual([(model.edge, model.display) for _, model in found],
+ [("right", "panel-left"), ("bottom", "panel-right")])
+
def test_what_is_left_out(self):
zones = [
{"peer": protocol.id_text(B), "kind": "edge", "off": True},
diff --git a/core/tests/test_responder_ported.py b/core/tests/test_responder_ported.py
index f74e602..55e0d65 100644
--- a/core/tests/test_responder_ported.py
+++ b/core/tests/test_responder_ported.py
@@ -11,6 +11,7 @@ import time
import unittest
from unittest import mock
+from core import return_edge
from core import protocol, receiver
from core.tests import pngs
from core.receiver import ServerState
@@ -39,6 +40,11 @@ class Case(unittest.TestCase):
caps = None
def setUp(self):
+ # These tests cross the moment input lands; the arrival grace is test_arrival_grace's
+ # subject, not theirs.
+ grace = mock.patch.object(return_edge, "ARRIVAL_GRACE_SECONDS", 0.0)
+ grace.start()
+ self.addCleanup(grace.stop)
self.machine = self.start()
def start(self, unlock=None):
@@ -201,6 +207,18 @@ class TheClipboardOnLettingGo(Case):
self.visit(link, "")
self.nothing_was_sent(link)
+ def test_a_visit_begun_before_the_clipboard_could_be_read_sends_nothing_back(self):
+ # A Wayland machine whose remote control session is held up by the desktop's consent dialog.
+ link = self.link()
+ self.machine.clipboard.stamp = None
+ route = link.take()
+ self.assertEqual(link.answer(route)[0], ACCEPT)
+ self.assertTrue(wait_for(lambda: self.machine.responder.owner == B))
+ self.machine.clipboard.stamp = 1
+ link.let_go()
+ self.assertTrue(wait_for(lambda: self.machine.responder.owner is None))
+ self.nothing_was_sent(link)
+
def test_text_over_the_limit_is_not_sent(self):
link = self.link()
self.visit(link, "z" * (protocol.CLIPBOARD_MAX_BYTES + 1))
diff --git a/core/tests/test_response_time.py b/core/tests/test_response_time.py
new file mode 100644
index 0000000..a238ab2
--- /dev/null
+++ b/core/tests/test_response_time.py
@@ -0,0 +1,62 @@
+import unittest
+from types import SimpleNamespace
+
+from core import protocol, receiver
+from core.response_time import ResponseTime
+
+
+class ResponseTimeTests(unittest.TestCase):
+ def test_responder_probe_is_not_starved_by_queued_traffic(self):
+ sent = []
+ sock = SimpleNamespace(send=lambda frame: len(frame))
+ def seal(message):
+ sent.append(message)
+ link.closed.set()
+ return b"frame"
+ link = receiver._Link(sock, SimpleNamespace(seal=seal), b"p" * 16, "key", "localhost",
+ "Peer", ["ping_rtt"], b"o" * 16, ["ping_rtt"], True)
+ link.next_response_probe = 0.0
+ queued = protocol.clipboard_msg("queued traffic")
+ link.outbox.append(queued)
+ receiver.LinkResponder._writer(SimpleNamespace(), link)
+ self.assertEqual(sent[0]["type"], protocol.MSG_PING)
+ self.assertIn("probe", sent[0]["data"])
+ self.assertEqual(list(link.outbox), [queued])
+
+ def test_only_a_live_matching_echo_produces_a_fresh_sample(self):
+ now = [10.0]
+ samples = ResponseTime(clock=lambda: now[0])
+
+ probe = samples.new_probe()
+ now[0] = 10.010
+ self.assertFalse(samples.echoed(probe))
+ samples.sent(probe)
+ now[0] = 11.210
+ self.assertIsNone(samples.new_probe())
+ self.assertFalse(samples.echoed(2))
+ self.assertTrue(samples.echoed(probe))
+ self.assertFalse(samples.echoed(probe))
+ self.assertEqual(samples.response_time_ms, 1200)
+
+ now[0] = 14.211
+ self.assertIsNone(samples.response_time_ms)
+
+ def test_late_echo_and_reset_do_not_restore_a_sample(self):
+ now = [1.0]
+ samples = ResponseTime(clock=lambda: now[0])
+ probe = samples.new_probe()
+ samples.sent(probe)
+ now[0] = 5.0
+ self.assertFalse(samples.echoed(probe))
+ self.assertIsNone(samples.response_time_ms)
+
+ next_probe = samples.new_probe()
+ samples.sent(next_probe)
+ samples.reset()
+ now[0] = 5.01
+ self.assertFalse(samples.echoed(next_probe))
+ self.assertIsNone(samples.response_time_ms)
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/core/tests/test_same_groups_network.py b/core/tests/test_same_groups_network.py
new file mode 100644
index 0000000..e22df61
--- /dev/null
+++ b/core/tests/test_same_groups_network.py
@@ -0,0 +1,86 @@
+"""Three synthetic desks synchronise and revert over encrypted loopback links."""
+
+import unittest
+
+from core import protocol, settings_sync
+from core.tests.responder_harness import Machine, Initiator, entry, ident, token, wait_for
+
+
+class ThreeDeskGroupsTests(unittest.TestCase):
+ def setUp(self):
+ self.ids = [ident(seed) for seed in (30, 60, 90)]
+ self.states = [{"on": False, "groups": [], "set_at": 0, "by": "",
+ "values": {"resistance_px": resistance, "glow_colour": colour}}
+ for resistance, colour in ((120, "signal"), (140, "ocean"), (160, "sunset"))]
+ self.machines = []
+ self.links = {}
+ for target, own in enumerate(self.ids):
+ peers = [entry(peer, "Synthetic desk", token=token(source * 3 + target))
+ for source, peer in enumerate(self.ids) if source != target]
+ machine = Machine(peers, own=own).start()
+ self.addCleanup(machine.stop)
+ self.machines.append(machine)
+ for source, own in enumerate(self.ids):
+ for target, machine in enumerate(self.machines):
+ if source == target:
+ continue
+ link = Initiator(machine, peer=own, key=token(source * 3 + target))
+ self.addCleanup(link.close)
+ link.handshake()
+ self.links[source, target] = link
+
+ def send(self, source, target, data):
+ machine = self.machines[target]
+ count = len(machine.settings_seen)
+ self.links[source, target].send(protocol.settings_msg(data))
+ self.assertTrue(wait_for(lambda: len(machine.settings_seen) > count))
+ peer, received = machine.settings_seen[-1]
+ self.assertEqual(peer, self.ids[source])
+ state = self.states[target]
+ taken = settings_sync.arrived(received, state["set_at"], {"alt_r"},
+ by_here=state["by"], current_groups=state["groups"])
+ if taken is None:
+ return False
+ snapshot = settings_sync.snapshot_for_arrival(received, state["set_at"], {"alt_r"},
+ state["by"], state["groups"], state["values"])
+ if snapshot is not None:
+ state["snapshot"] = snapshot
+ on, stamp, values = taken
+ state.update(on=on, set_at=stamp, by=received["by"],
+ groups=list(settings_sync.arrival_groups(received, state["groups"])))
+ if on:
+ state["values"].update(values)
+ return True
+
+ def test_crossing_and_revert_converge_while_design_stays_local(self):
+ author = protocol.id_text(self.ids[0])
+ data = settings_sync.message_data(True, 100, self.states[0]["values"],
+ by=author, groups=["crossing"])
+ self.states[0].update(on=True, groups=["crossing"], set_at=100, by=author)
+ self.assertTrue(self.send(0, 1, data))
+ self.assertTrue(self.send(1, 2, data))
+ self.assertFalse(self.send(2, 0, data))
+ self.assertEqual([state["values"]["resistance_px"] for state in self.states], [120] * 3)
+ before = self.states[1]["snapshot"]
+ restored = settings_sync.restore_snapshot(before)
+ self.states[1]["values"].update(restored["values"])
+ groups = settings_sync.revert_groups(before, self.states[1]["groups"])
+ author = protocol.id_text(self.ids[1])
+ stamp = settings_sync.next_stamp(100, 101)
+ self.states[1].update(groups=groups, set_at=stamp, by=author)
+ undo = settings_sync.message_data(True, stamp, self.states[1]["values"], by=author, groups=groups)
+ self.assertTrue(self.send(1, 2, undo))
+ self.assertTrue(self.send(2, 0, undo))
+ self.assertFalse(self.send(0, 1, undo))
+ self.assertEqual([state["values"]["resistance_px"] for state in self.states], [140] * 3)
+ self.assertTrue(all(state["on"] and state["groups"] == ["crossing"] for state in self.states))
+ self.assertEqual([state["values"]["glow_colour"] for state in self.states], ["signal", "ocean", "sunset"])
+ self.assertNotIn("same_before_sync", undo)
+
+ def test_legacy_state_keeps_each_selected_policy_and_filters_known_values(self):
+ self.states[1].update(on=True, groups=["crossing"])
+ data = settings_sync.message_data(True, 100, {"resistance_px": 60, "glow_colour": "mono"},
+ by=protocol.id_text(self.ids[0]))
+ self.assertTrue(self.send(0, 1, data))
+ self.assertEqual(self.states[1]["groups"], ["crossing"])
+ self.assertEqual(self.states[1]["values"], {"resistance_px": 60, "glow_colour": "ocean"})
diff --git a/core/tests/test_settings_mixed_groups.py b/core/tests/test_settings_mixed_groups.py
new file mode 100644
index 0000000..3d8e4c3
--- /dev/null
+++ b/core/tests/test_settings_mixed_groups.py
@@ -0,0 +1,281 @@
+"""Same on all machines past the per-key suite (rc16 bug hunt, 11-10-2026): a group holding a 1.5.1
+machine, two edits whose messages cross in flight, four desks, and a machine paired again, each
+through the apps' own arrival code (settings_behaviour's fixtures) and recipients()' routing."""
+
+import time
+import unittest
+
+from core import settings_sync
+from core.tests.settings_behaviour import IDS, fixture
+from core.tests.test_settings_per_key_desks import CHOICES
+from core.tests.test_settings_per_key_review import FOURTH, RoutedDesks
+
+# Beamer 1.5.1's shared keys (release/1.5.1 a4d36dfa, core/settings_sync.py): it reads nothing else.
+OLD_CROSSING = ("resistance_px", "block_while_dragging", "shortcut", "trigger_key", "trigger_style", "double_tap_ms")
+OLD_DESIGN = ("glow_style", "glow_colour", "effect_length", "effect_size", "shortcut_arrival",
+ "shortcut_arrival_style")
+OLD_KEYS = OLD_CROSSING + OLD_DESIGN
+TRIGGER_KEYS = {"cmd_r", "f13"}
+
+
+class OldPeer:
+ """A 1.5.1 desk, as its settings_sync.arrived and each app's apply_same behave: one stamp for the
+ whole state; a newer whole state is taken outright, its values only while on, and sent on
+ unchanged; groups and per-value stamps are unknown and ignored."""
+
+ def __init__(self, ident, values):
+ self.ident = ident
+ self.on, self.set_at, self.by = False, 0, ""
+ self.shared = {key: values[key] for key in OLD_KEYS if key in values}
+ self.routed = []
+
+ def state(self):
+ data = {"on": self.on, "set_at": self.set_at, "by": self.by}
+ if self.on:
+ data["crossing"] = {key: self.shared[key] for key in OLD_CROSSING}
+ data["design"] = {key: self.shared[key] for key in OLD_DESIGN}
+ return data
+
+ def receive(self, source, data):
+ if not settings_sync._valid_envelope(data):
+ return
+ by = settings_sync._id(data.get("by", ""))
+ mine = settings_sync._id(self.by) or b""
+ if not (data["set_at"] > self.set_at or (data["set_at"] == self.set_at and by > mine)):
+ return
+ self.on, self.set_at, self.by = data["on"], data["set_at"], data.get("by", "")
+ if self.on:
+ for section, keys in (("crossing", OLD_CROSSING), ("design", OLD_DESIGN)):
+ given = data.get(section) if isinstance(data.get(section), dict) else {}
+ self.shared.update({key: given[key] for key in keys
+ if key in given and settings_sync._valid(key, given[key], TRIGGER_KEYS)})
+ self.routed.append((dict(data), source))
+
+ def edit(self, **values):
+ self.shared.update(values)
+ self.set_at = settings_sync.next_stamp(self.set_at, time.time())
+ self.by = self.ident
+ self.routed.append((self.state(), None))
+
+ def values(self):
+ return dict(self.shared)
+
+
+class Group(RoutedDesks):
+ def __init__(self, test, platforms, old=()):
+ super().__init__(test, platforms)
+ for index in old:
+ self.apps[index] = OldPeer(IDS[index], self.apps[index].values())
+
+ def link_all(self):
+ for one in range(len(self.apps)):
+ for other in range(one + 1, len(self.apps)):
+ self.link(one, other)
+
+ def unlink(self, index):
+ self.links = {pair for pair in self.links if index not in pair}
+
+ def old_edit(self, index, **values):
+ app = self.apps[index]
+ app.edit(**values)
+ message, _source = app.routed.pop()
+ self.run([(index, message, set(range(len(self.apps))) - {index})])
+
+ def deliver_crossed(self, *indices):
+ """Each of `indices` announces its state to every other at once, as messages in flight cross."""
+ everyone = set(range(len(self.apps)))
+ self.run([(index, self.apps[index].state(), everyone - {index}) for index in indices])
+
+ def agree(self, keys, indices=None):
+ indices = range(len(self.apps)) if indices is None else indices
+ seen = [{key: self.apps[index].values().get(key) for key in keys} for index in indices]
+ self.test.assertTrue(all(item == seen[0] for item in seen), f"the desks disagree: {seen}")
+ return seen[0]
+
+
+class MixedWithOnePointFiveOne(unittest.TestCase):
+ """A Mac and a PC on 1.5.2 and a PC still on 1.5.1, every pair linked, Same on everywhere."""
+
+ def setUp(self):
+ self.group = Group(self, ("mac", "win", "win"), old=(2,))
+ self.mac, self.pc, self.old = self.group.apps
+ self.mac._set_same(True)
+ self.mac.routed.clear()
+ self.group.link_all()
+ self.assertTrue(self.old.on, "the 1.5.1 machine follows Same on")
+ self.group.edit(0, **CHOICES)
+
+ def test_a_new_machines_edit_reaches_the_old_one(self):
+ old_choices = {key: value for key, value in CHOICES.items() if key in OLD_KEYS}
+ self.assertEqual({key: self.old.values()[key] for key in old_choices}, old_choices)
+ self.group.agree(CHOICES, (0, 1))
+
+ def test_an_old_machines_edit_reaches_both_and_moves_nothing_else(self):
+ time.sleep(1.1)
+ self.group.old_edit(2, glow_colour="mono")
+ expected = dict(CHOICES, glow_colour="mono")
+ for index in (0, 1):
+ self.assertEqual(self.group.shared(index), expected, f"desk {index}")
+
+ def test_a_value_only_1_5_2_has_survives_an_old_machines_edit(self):
+ self.group.edit(1, shortcut_goes_to="ticked")
+ time.sleep(1.1)
+ self.group.old_edit(2, trigger_style="double_tap")
+ for index in (0, 1):
+ values = self.group.apps[index].values()
+ self.assertEqual(values["shortcut_goes_to"], "ticked", f"desk {index}")
+ self.assertEqual(values["trigger_style"], "double_tap", f"desk {index}")
+
+ def test_the_old_machine_away_for_an_edit_learns_it_when_its_links_come_back(self):
+ self.group.online.discard(2)
+ self.group.edit(0, glow_colour="aurora")
+ self.group.online.add(2)
+ self.group.link(2, 0)
+ self.group.link(2, 1)
+ self.assertEqual(self.old.values()["glow_colour"], "aurora")
+ self.group.agree(OLD_KEYS)
+
+ def test_a_new_machine_away_for_an_old_machines_edit_learns_it_when_back(self):
+ self.group.online.discard(1)
+ time.sleep(1.1)
+ self.group.old_edit(2, effect_length="short")
+ self.group.online.add(1)
+ self.group.link(1, 0)
+ self.group.link(1, 2)
+ self.assertEqual(self.pc.values()["effect_length"], "short")
+ self.group.agree(OLD_KEYS)
+
+
+class OldMachineTurnsItOn(unittest.TestCase):
+ """Same off everywhere; a person turns it on on the 1.5.1 machine, which sends no groups."""
+
+ def setUp(self):
+ self.group = Group(self, ("mac", "win", "win"), old=(2,))
+ self.mac, self.pc, self.old = self.group.apps
+ self.group.link_all()
+ self.assertFalse(any(app.cfg().same_on_both for app in (self.mac, self.pc)))
+
+ def test_both_new_machines_share_every_group_and_take_its_values(self):
+ time.sleep(1.1)
+ self.group.old_edit(2, glow_colour="mono", trigger_style="hold")
+ self.old.on = True
+ self.group.old_edit(2)
+ for index, app in ((0, self.mac), (1, self.pc)):
+ with self.subTest(desk=index):
+ self.assertTrue(app.cfg().same_on_both)
+ self.assertEqual(tuple(app.cfg().same_groups), settings_sync.ALL_GROUPS,
+ "on from a peer that sends no groups shares every group, as turning it on here does")
+ self.assertEqual(self.group.shared(index, ("glow_colour", "trigger_style")),
+ {"glow_colour": "mono", "trigger_style": "hold"})
+
+
+class TwoAtOnce(unittest.TestCase):
+ """A person on each of two machines changes a shared value in the same moment: both messages are
+ in flight before either lands."""
+
+ def setUp(self):
+ self.group = Group(self, ("mac", "win"))
+ self.group.apps[0]._set_same(True)
+ self.group.apps[0].routed.clear()
+ self.group.link_all()
+ self.group.edit(0, **CHOICES)
+
+ def edit_unheard(self, index, **values):
+ online = set(self.group.online)
+ self.group.online.clear()
+ self.group.edit(index, **values)
+ self.group.online |= online
+
+ def test_different_values_both_stand(self):
+ time.sleep(1.1)
+ self.edit_unheard(0, glow_colour="sunset")
+ self.edit_unheard(1, trigger_style="double_tap")
+ self.group.deliver_crossed(0, 1)
+ expected = dict(CHOICES, glow_colour="sunset", trigger_style="double_tap")
+ for index in (0, 1):
+ self.assertEqual(self.group.shared(index), expected, f"desk {index}")
+
+ def test_the_same_value_settles_on_one_choice_on_both(self):
+ time.sleep(1.1)
+ self.edit_unheard(0, glow_colour="sunset")
+ self.edit_unheard(1, glow_colour="mono")
+ self.group.deliver_crossed(0, 1)
+ settled = self.group.agree(("glow_colour",))
+ self.assertIn(settled["glow_colour"], ("sunset", "mono"))
+ self.assertEqual(self.group.shared(0, ("trigger_style",)), {"trigger_style": "hold"})
+
+
+class FourDesks(unittest.TestCase):
+ def setUp(self):
+ # A fourth desk for this case only: IDS is shared, and other suites assert on its length.
+ IDS.append(FOURTH)
+ self.addCleanup(IDS.remove, FOURTH)
+ self.group = Group(self, ("mac", "win", "win", "win"))
+ self.group.apps[0]._set_same(True)
+ self.group.apps[0].routed.clear()
+ self.group.link_all()
+
+ def test_edits_on_three_machines_while_one_is_away_all_land_everywhere(self):
+ self.group.edit(0, **CHOICES)
+ self.group.agree(CHOICES)
+ self.group.online.discard(3)
+ time.sleep(1.1)
+ self.group.edit(1, glow_colour="sunset")
+ self.group.edit(2, trigger_style="double_tap")
+ self.group.online.add(3)
+ for other in range(3):
+ self.group.link(3, other)
+ expected = dict(CHOICES, glow_colour="sunset", trigger_style="double_tap")
+ for index in range(4):
+ self.assertEqual(self.group.shared(index), expected, f"desk {index}")
+
+ def test_the_away_machines_own_edit_is_kept_and_it_takes_the_rest(self):
+ self.group.edit(0, **CHOICES)
+ self.group.online.discard(3)
+ time.sleep(1.1)
+ self.group.edit(1, glow_colour="sunset")
+ time.sleep(1.1)
+ online = set(self.group.online)
+ self.group.online.clear()
+ self.group.edit(3, effect_length="short")
+ self.group.online |= online | {3}
+ for other in range(3):
+ self.group.link(3, other)
+ expected = dict(CHOICES, glow_colour="sunset", effect_length="short")
+ for index in range(4):
+ self.assertEqual(self.group.shared(index), expected, f"desk {index}")
+
+
+class PairedAgain(unittest.TestCase):
+ def setUp(self):
+ self.group = Group(self, ("mac", "win", "win"))
+ self.group.apps[0]._set_same(True)
+ self.group.apps[0].routed.clear()
+ self.group.link_all()
+ self.group.edit(0, **CHOICES)
+
+ def test_a_machine_forgotten_and_paired_again_takes_what_changed_meanwhile(self):
+ self.group.unlink(2)
+ time.sleep(1.1)
+ self.group.edit(1, glow_colour="sunset")
+ self.group.link(2, 0)
+ self.group.link(2, 1)
+ for index in range(3):
+ self.assertEqual(self.group.shared(index), dict(CHOICES, glow_colour="sunset"), f"desk {index}")
+
+ def test_a_reinstalled_machine_adopts_the_group_and_changes_nobody(self):
+ self.group.unlink(2)
+ fresh = fixture("win", IDS[2])
+ self.group.apps[2] = fresh
+ fresh.routed = []
+ fresh._send_same = lambda data=None, source=None: fresh.routed.append(
+ (data if data is not None else fresh.state(), source))
+ self.group.link(2, 0)
+ self.group.link(2, 1)
+ for index in range(3):
+ self.assertEqual(self.group.shared(index), CHOICES, f"desk {index}")
+ self.assertTrue(fresh.cfg().same_on_both)
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/core/tests/test_settings_per_key.py b/core/tests/test_settings_per_key.py
new file mode 100644
index 0000000..5b7d687
--- /dev/null
+++ b/core/tests/test_settings_per_key.py
@@ -0,0 +1,106 @@
+"""Same on all machines, value by value (rc14, 10-10-2026): an edit carries only what a person
+changed, so a value a machine missed or never set no longer overwrites real choices everywhere."""
+
+import unittest
+
+from core import protocol, settings_sync
+
+A, B, C = (protocol.id_text(bytes([value]) * 16) for value in (1, 2, 3))
+KEYS = {"cmd_r", "alt_r"}
+GROUPS = list(settings_sync.ALL_GROUPS)
+NOW = 2_000_000_000
+
+
+def state(by, set_at, stamps, **values):
+ held = settings_sync.held_stamps(stamps, set_at, by)
+ return settings_sync.message_data(True, set_at, values, by=by, groups=GROUPS, stamps=held)
+
+
+class Merge(unittest.TestCase):
+ def merge(self, data, stamps, set_at, by, on=True, groups=GROUPS):
+ return settings_sync.merge(data, stamps, set_at, KEYS, by_here=by, on_here=on, now=NOW,
+ current_groups=groups)
+
+ def test_a_fresh_machine_adopts_every_value_the_group_holds(self):
+ sent = state(A, 500, {"trigger_style": [400, A]}, trigger_style="double_tap", trigger_key="cmd_r")
+ merged = self.merge(sent, {}, 0, "", on=False, groups=[])
+ self.assertIsNotNone(merged["policy"])
+ self.assertEqual(merged["values"], {"trigger_style": "double_tap", "trigger_key": "cmd_r"})
+ self.assertFalse(merged["answer"])
+
+ def test_an_edit_from_a_machine_that_missed_one_carries_only_its_own_change(self):
+ # A set the style at 300. C was offline, then changed the key at 400 still holding the old style.
+ sent = state(C, 400, {"trigger_key": [400, C], "trigger_style": [100, B]},
+ trigger_style="hold", trigger_key="alt_r")
+ merged = self.merge(sent, {"trigger_style": [300, A], "trigger_key": [100, B]}, 300, A)
+ self.assertEqual(merged["values"], {"trigger_key": "alt_r"})
+ self.assertTrue(merged["answer"], "A holds a newer style C has to learn")
+ # A's answer brings C the style, and C has nothing newer to send back.
+ answer = state(A, 400, {"trigger_style": [300, A], "trigger_key": [400, C]},
+ trigger_style="double_tap", trigger_key="alt_r")
+ back = self.merge(answer, {"trigger_key": [400, C], "trigger_style": [100, B]}, 400, C)
+ self.assertEqual(back["values"], {"trigger_style": "double_tap"})
+ self.assertFalse(back["answer"])
+ again = self.merge(answer, {"trigger_key": [400, C], "trigger_style": [300, A]}, 400, C)
+ self.assertEqual(again["values"], {})
+ self.assertFalse(again["answer"], "the same state twice changes nothing and is not answered")
+
+ def test_a_1_5_1_peer_without_stamps_counts_every_value_at_its_whole_stamp(self):
+ old = settings_sync.message_data(True, 500, {"trigger_style": "hold", "trigger_key": "cmd_r"},
+ by=B, groups=GROUPS)
+ self.assertNotIn("stamps", old)
+ merged = self.merge(old, {"trigger_style": [600, A], "trigger_key": [300, A]}, 600, A)
+ self.assertIsNone(merged["policy"])
+ self.assertEqual(merged["values"], {"trigger_key": "cmd_r"})
+ self.assertTrue(merged["answer"])
+
+ def test_values_wait_while_same_is_off_and_outside_the_selected_groups(self):
+ sent = state(A, 500, {}, trigger_style="hold", glow_colour="ocean")
+ older = settings_sync.message_data(True, 100, {"trigger_style": "hold", "glow_colour": "ocean"},
+ by=A, groups=GROUPS, stamps={"trigger_style": (100, A), "glow_colour": (100, A)})
+ held = {"trigger_style": [50, B], "glow_colour": [50, B]}
+ self.assertEqual(self.merge(older, held, 200, B, on=False)["values"], {})
+ merged = self.merge(older, held, 200, B, on=True, groups=["design"])
+ self.assertEqual(merged["values"], {"glow_colour": "ocean"})
+ self.assertEqual(self.merge(sent, {}, 0, "", on=False, groups=[])["groups"], tuple(GROUPS))
+
+ def test_a_value_changed_while_its_group_was_off_travels_newer_than_its_state(self):
+ sent = settings_sync.message_data(True, 100, {"trigger_style": "hold"}, by=A, groups=GROUPS,
+ stamps={"trigger_style": (900, A)})
+ self.assertEqual(self.merge(sent, {"trigger_style": [500, B]}, 600, B)["values"], {"trigger_style": "hold"})
+ ahead = settings_sync.message_data(True, 100, {"trigger_style": "hold"}, by=A, groups=GROUPS,
+ stamps={"trigger_style": (NOW + 2 * settings_sync.DAY, A)})
+ self.assertEqual(self.merge(ahead, {}, 50, B)["values"], {}, "a day ahead of this clock is refused")
+
+ def test_ties_break_on_the_larger_id_as_whole_states_do(self):
+ sent = state(B, 300, {"trigger_style": [300, B]}, trigger_style="hold")
+ self.assertEqual(self.merge(sent, {"trigger_style": [300, A]}, 300, A)["values"], {"trigger_style": "hold"})
+ self.assertEqual(self.merge(sent, {"trigger_style": [300, C]}, 300, C)["values"], {})
+
+
+class Stamping(unittest.TestCase):
+ def test_only_the_keys_a_person_changed_are_stamped_and_newer_than_any_held(self):
+ held = settings_sync.held_stamps({"glow_colour": [700, B]}, 500, A)
+ before = {"trigger_style": "double_tap", "glow_colour": "ocean"}
+ stamps, stamp = settings_sync.stamp_changes(held, before, {**before, "trigger_style": "hold"}, C, now=600)
+ self.assertEqual(stamp, 701)
+ self.assertEqual(stamps["trigger_style"], (701, C))
+ self.assertEqual(stamps["glow_colour"], (700, B))
+ self.assertEqual(settings_sync.stamp_changes(held, before, before, C, now=600), (held, None))
+
+ def test_a_fresh_machine_holds_nothing_newer_than_the_group(self):
+ self.assertEqual(set(settings_sync.held_stamps({}, 0, "").values()), {(0, "")})
+ held = settings_sync.held_stamps({"trigger_style": ["x", A], "trigger_key": [5, "not an id"]}, 9, A)
+ self.assertEqual(held["trigger_style"], (9, A))
+ self.assertEqual(held["trigger_key"], (9, A))
+
+ def test_stamps_travel_only_with_the_values_sent(self):
+ held = settings_sync.held_stamps({}, 5, A)
+ data = settings_sync.message_data(True, 5, {"glow_colour": "ocean", "trigger_style": "hold"}, by=A,
+ groups=["design"], stamps=held)
+ self.assertEqual(data["stamps"], {"glow_colour": [5, A]})
+ self.assertEqual(settings_sync.stored_stamps({"glow_colour": (5, A)}), {"glow_colour": [5, A]})
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/core/tests/test_settings_per_key_desks.py b/core/tests/test_settings_per_key_desks.py
new file mode 100644
index 0000000..4135b80
--- /dev/null
+++ b/core/tests/test_settings_per_key_desks.py
@@ -0,0 +1,125 @@
+"""Same on all machines across three desks, value by value, through each app's own arrival code
+(settings_behaviour's fixtures): a Mac and a PC sharing non-default choices, a fresh third machine
+pairing in, and a machine that missed an edit making one of its own (rc14, 10-10-2026)."""
+
+import time
+import unittest
+
+from core import settings_sync
+from core.tests.settings_behaviour import IDS, fixture, mac_adapter
+
+CHOICES = dict(trigger_style="hold", glow_colour="ocean", effect_length="long", resistance_px=300,
+ shortcut_goes_to="next")
+
+
+class Desks:
+ def __init__(self, test, platforms):
+ self.test = test
+ self.apps = [fixture(platform, IDS[index]) for index, platform in enumerate(platforms)]
+ self.platforms = platforms
+ self.online = set(range(len(self.apps)))
+ self.links = set()
+
+ def link(self, one, other):
+ """A link comes up: each end announces its state to the other."""
+ self.links |= {(one, other), (other, one)}
+ self.run([(one, self.apps[one].state(), {other}), (other, self.apps[other].state(), {one})])
+
+ def run(self, queue):
+ delivered = 0
+ while queue:
+ source, data, targets = queue.pop(0)
+ for target in sorted(targets):
+ if target == source or target not in self.online or (source, target) not in self.links:
+ continue
+ delivered += 1
+ self.test.assertLess(delivered, 60, "the desks kept announcing")
+ app = self.apps[target]
+ # Names have their own per-entry stamps, and the fixtures hold no name to rename.
+ app.receive(IDS[source], {key: value for key, value in data.items() if key != "names"})
+ queue.extend((target, message, set(range(len(self.apps))) - {target}) for message in app.sent)
+ app.sent.clear()
+
+ def edit(self, index, **values):
+ """A person changes `values` on desk `index`, as its settings page saves and sends them."""
+ app, cfg = self.apps[index], self.apps[index].cfg()
+ before = app.values()
+ held = settings_sync.held_stamps(cfg.same_stamps, cfg.same_set_at, cfg.same_by)
+ on = cfg.same_on_both
+ if self.platforms[index] == "mac":
+ config, to_raw = mac_adapter()
+ raw = settings_sync.apply_mac(to_raw(cfg), values)
+ after = settings_sync.mac_values(raw)
+ stamps, stamp = settings_sync.stamp_changes(held, before, after, IDS[index], floor=cfg.same_set_at,
+ now=time.time())
+ raw["same_stamps"] = settings_sync.stored_stamps(stamps)
+ if on:
+ raw.update(same_set_at=stamp, same_by=IDS[index])
+ app.controller.apply_settings(config.parse_config(raw))
+ else:
+ settings_sync.apply_pc(cfg, values)
+ stamps, stamp = settings_sync.stamp_changes(held, before, settings_sync.pc_values(cfg), IDS[index],
+ floor=cfg.same_set_at, now=time.time())
+ cfg.same_stamps = settings_sync.stored_stamps(stamps)
+ if on:
+ cfg.same_set_at, cfg.same_by = stamp, IDS[index]
+ # While Same is off a change is stamped for later but travels nowhere.
+ if on:
+ self.run([(index, app.state(), set(range(len(self.apps))) - {index})])
+
+ def shared(self, index, keys=tuple(CHOICES)):
+ values = self.apps[index].values()
+ return {key: values[key] for key in keys}
+
+
+class ThreeDesks(unittest.TestCase):
+ def setUp(self):
+ self.desks = Desks(self, ("mac", "win", "win"))
+ mac, pc, _fresh = self.desks.apps
+ mac._set_same(True)
+ mac.sent.clear()
+ self.desks.link(0, 1)
+ self.desks.edit(0, **CHOICES)
+ self.assertEqual(self.desks.shared(1), CHOICES)
+
+ def test_a_fresh_third_machine_adopts_the_groups_choices_and_changes_nobodys(self):
+ defaults = self.desks.shared(2)
+ self.assertNotEqual(defaults, CHOICES)
+ self.desks.link(2, 0)
+ self.desks.link(2, 1)
+ for index in range(3):
+ self.assertEqual(self.desks.shared(index), CHOICES, f"desk {index}")
+ self.assertTrue(all(app.cfg().same_on_both for app in self.desks.apps))
+
+ def test_a_machine_that_missed_an_edit_sends_only_its_own_change(self):
+ self.desks.link(2, 0)
+ self.desks.link(2, 1)
+ self.desks.online.discard(1)
+ self.desks.edit(0, glow_colour="sunset")
+ self.assertEqual(self.desks.shared(2)["glow_colour"], "sunset")
+ self.assertEqual(self.desks.shared(1)["glow_colour"], "ocean", "the PC was away")
+ self.desks.online.add(1)
+ # Back, still holding the old colour, someone changes its style before any link announces.
+ self.desks.edit(1, trigger_style="double_tap")
+ expected = dict(CHOICES, glow_colour="sunset", trigger_style="double_tap")
+ for index in range(3):
+ self.assertEqual(self.desks.shared(index), expected, f"desk {index}")
+
+ def test_an_edit_while_same_is_off_wins_when_it_is_turned_on(self):
+ mac, pc, _fresh = self.desks.apps
+ pc._set_same(False)
+ self.desks.run([(1, pc.state(), {0})])
+ pc.sent.clear()
+ self.assertFalse(mac.cfg().same_on_both)
+ self.desks.edit(1, glow_colour="mono")
+ self.assertEqual(self.desks.shared(0)["glow_colour"], "ocean", "off: nothing travels")
+ mac._set_same(True)
+ self.desks.run([(0, message, {1}) for message in mac.sent])
+ mac.sent.clear()
+ for index in (0, 1):
+ self.assertEqual(self.desks.shared(index)["glow_colour"], "mono", f"desk {index}")
+ self.assertEqual(self.desks.shared(index)["trigger_style"], "hold", f"desk {index}")
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/core/tests/test_settings_per_key_review.py b/core/tests/test_settings_per_key_review.py
new file mode 100644
index 0000000..63631f9
--- /dev/null
+++ b/core/tests/test_settings_per_key_review.py
@@ -0,0 +1,83 @@
+"""Review cases for per-key sync (10-10-2026): a trigger clash round four desks, and a slider stamped apart from its preset.
+"""
+
+import copy
+import time
+import unittest
+
+from core import protocol, settings_sync
+from core.tests import settings_behaviour
+from core.tests.settings_behaviour import IDS, fixture
+from core.tests.test_settings_per_key_desks import Desks
+
+FOURTH = protocol.id_text(bytes([4]) * 16)
+
+
+class RoutedDesks(Desks):
+ """Desks whose forwarding honours `source`, as recipients() does: a copy is never sent back to
+ the peer it came from."""
+
+ def __init__(self, test, platforms):
+ super().__init__(test, platforms)
+ for app in self.apps:
+ app.routed = []
+ app._send_same = (lambda app: lambda data=None, source=None: app.routed.append(
+ (copy.deepcopy(data if data is not None else app.state()), source)))(app)
+
+ def run(self, queue):
+ delivered = 0
+ while queue:
+ source, data, targets = queue.pop(0)
+ for target in sorted(targets):
+ if target == source or target not in self.online or (source, target) not in self.links:
+ continue
+ delivered += 1
+ self.test.assertLess(delivered, 200, "the desks kept announcing")
+ app = self.apps[target]
+ app.receive(IDS[source], {key: value for key, value in data.items() if key != "names"})
+ everyone = set(range(len(self.apps))) - {target}
+ for message, came_from in app.routed:
+ came_from = protocol.id_text(came_from) if isinstance(came_from, bytes) else came_from
+ skip = {IDS.index(came_from)} if came_from in IDS else set()
+ queue.append((target, message, everyone - skip))
+ app.routed.clear()
+
+
+class TriggerClashFlood(unittest.TestCase):
+ def setUp(self):
+ # A fourth desk for this case only: IDS is shared, and other suites assert on its length.
+ IDS.append(FOURTH)
+ self.addCleanup(IDS.remove, FOURTH)
+
+ def test_three_machines_that_keep_their_trigger_on_a_clash_stop_forwarding(self):
+ # Mac 0 chooses f13 as the trigger; PCs 1-3 each hold a jump chord using f13, so each keeps
+ # its own trigger and its older stamp, and every copy of the message counts as "taken" again.
+ desks = RoutedDesks(self, ("mac", "win", "win", "win"))
+ for index in (1, 2, 3):
+ peers = desks.apps[index].peers
+ peers[0] = dict(peers[0], jump_key="ctrl+f13")
+ desks.apps[0]._set_same(True)
+ desks.apps[0].routed.clear()
+ for one in range(4):
+ for other in range(one + 1, 4):
+ desks.link(one, other)
+ desks.edit(0, trigger_key="f13")
+
+
+class SliderAndPresetSplit(unittest.TestCase):
+ def test_the_latest_pace_choice_survives_a_machine_that_missed_a_length_change(self):
+ desks = Desks(self, ("mac", "win"))
+ desks.apps[0]._set_same(True)
+ desks.apps[0].sent.clear()
+ desks.link(0, 1)
+ desks.online.discard(1)
+ desks.edit(0, effect_length="long") # pace 2.0 and length long, stamped together
+ desks.online.add(1)
+ time.sleep(1.1)
+ desks.edit(1, effect_pace=1.3) # later; length on the PC stays "normal", so only pace is stamped
+ for index in (0, 1):
+ self.assertEqual(desks.apps[index].values()["effect_pace"], 1.3, f"desk {index}")
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/core/tests/test_settings_sync.py b/core/tests/test_settings_sync.py
index c80f3a4..7b273d5 100644
--- a/core/tests/test_settings_sync.py
+++ b/core/tests/test_settings_sync.py
@@ -20,6 +20,7 @@ def mac_raw(**crossing):
"corner": "top_right", "resistance_px": 120, "block_while_dragging": True, "glow": True,
"glow_style": "glow", "glow_colour": "signal", "effect_length": "normal", "effect_size": "medium",
"shortcut_arrival": True,
+ "shortcut_goes_to": "last",
"shortcut_arrival_style": "match", "notch_style": "beam", "notch_after_ms": 1200, "haptics": True,
"hold_full_screen": False,
}
@@ -32,6 +33,7 @@ def pc_config(**fields):
base = dict(
crossing_methods=["edge", "shortcut"], crossing_edge_parts=["middle"], crossing_corner="top_left",
crossing_resistance_px=120, block_while_dragging=True, trigger_key="cmd_r", trigger_style="double_tap",
+ shortcut_goes_to="last",
double_tap_ms=300, glow_style="glow", glow_colour="signal", effect_length="normal", effect_size="medium",
shortcut_arrival=True, shortcut_arrival_style="match", mac_return_edge="left", edge_glow=True,
appearance="light",
@@ -44,6 +46,11 @@ class MessageTests(unittest.TestCase):
def test_pc_modifier_style_is_local_and_not_part_of_same_on_all_machines(self):
self.assertNotIn("modifier_style", settings_sync.CROSSING_KEYS + settings_sync.DESIGN_KEYS)
+ def test_left_out_peer_fields_are_not_carried_by_same_on_all_machines(self):
+ data = settings_sync.message_data(True, 7, {"left_out": True, "left_out_ways": ["edge"]})
+
+ self.assertEqual(data, {"on": True, "set_at": 7, "by": "", "crossing": {}, "design": {}})
+
def test_new_design_choices_survive_the_settings_message_round_trip(self):
from core import effects
@@ -62,6 +69,102 @@ class MessageTests(unittest.TestCase):
self.assertEqual(received["shortcut_arrival_style"], style)
self.assertTrue(set(styles) <= set(effects.EFFECT_IDS))
self.assertTrue(set(colours) <= set(effects.PACK_IDS))
+
+ def test_names_keep_the_newest_stamp_per_machine(self):
+ first, second = b64(b"\x01" * 16), b64(b"\x02" * 16)
+ held = {first: {"label": "Old", "set_at": 20, "by": first}}
+ data = settings_sync.message_data(True, 10, names={
+ first: {"label": "Older", "set_at": 19, "by": second},
+ second: {"label": "New", "set_at": 21, "by": second},
+ })
+
+ self.assertEqual(settings_sync.names_arrived(data, held, now=NOW),
+ ({second: {"label": "New", "set_at": 21, "by": second}}, None))
+
+ def test_names_from_settings_includes_unlabelled_peers_for_revert(self):
+ own, peer = b64(b"\x01" * 16), b64(b"\x02" * 16)
+ settings = {"machine_id": own, "name": "", "peers": [{"id": peer}]}
+
+ names = settings_sync.names_from_settings(settings)
+
+ self.assertEqual(names[peer], {"label": "", "set_at": 0, "by": own})
+
+ def test_an_untouched_empty_own_name_cannot_be_attributed_to_a_peer(self):
+ own, peer = b64(b"\x01" * 16), b64(b"\x02" * 16)
+ settings = {"machine_id": own, "name": "", "name_set_at": 0, "name_by": peer, "peers": []}
+
+ self.assertEqual(settings_sync.names_from_settings(settings)[own],
+ {"label": "", "set_at": 0, "by": own})
+
+ def test_a_name_for_this_machine_is_returned_as_its_own_name(self):
+ own = b64(b"\x01" * 16)
+ settings = {"machine_id": own, "name": "", "peers": []}
+ data = settings_sync.message_data(True, 10, names={
+ own: {"label": "This Mac", "set_at": 21, "by": own},
+ })
+
+ updates, own_name = settings_sync.names_arrived(data, {}, own_id=own, now=NOW)
+ self.assertEqual((updates, own_name),
+ ({own: {"label": "This Mac", "set_at": 21, "by": own}}, "This Mac"))
+ self.assertTrue(settings_sync.apply_names(settings, updates))
+ self.assertEqual(settings["name"], "This Mac")
+
+ def test_names_are_ignored_when_same_is_off(self):
+ own = b64(b"\x01" * 16)
+ data = settings_sync.message_data(False, 10)
+ data["names"] = {
+ own: {"label": "Ignored", "set_at": 21, "by": own},
+ }
+
+ self.assertEqual(settings_sync.names_arrived(data, {}, own_id=own, now=NOW), ({}, None))
+
+ def test_names_follow_the_selected_group_and_legacy_peers_use_local_selection(self):
+ own = b64(b"\x01" * 16)
+ data = settings_sync.message_data(True, 10, names={
+ own: {"label": "Incoming", "set_at": 21, "by": own},
+ })
+
+ self.assertEqual(settings_sync.names_arrived(data, {}, own_id=own, now=NOW,
+ current_groups=["crossing"]), ({}, None))
+ legacy = {key: value for key, value in data.items() if key != "groups"}
+ self.assertEqual(settings_sync.names_arrived(legacy, {}, own_id=own, now=NOW,
+ current_groups=["names"])[1], "Incoming")
+
+ def test_name_entries_with_bad_stamps_or_authors_are_ignored(self):
+ ident = b64(b"\x01" * 16)
+ data = settings_sync.message_data(True, 10, names={
+ ident: {"label": "Too far", "set_at": NOW + 86401, "by": ident},
+ "bad-id": {"label": "Bad id", "set_at": 21, "by": ident},
+ b64(b"\x02" * 16): {"label": "Bad author", "set_at": 21, "by": "bad"},
+ })
+
+ self.assertEqual(settings_sync.names_arrived(data, {}, now=NOW), ({}, None))
+
+ def test_synced_name_is_trimmed_before_the_64_character_limit(self):
+ ident = b64(b"\x01" * 16)
+ label = " " + "x" * 64 + " "
+ data = settings_sync.message_data(True, 10, names={
+ ident: {"label": label, "set_at": 21, "by": ident},
+ })
+
+ updates, _own_name = settings_sync.names_arrived(data, {}, now=NOW)
+ self.assertEqual(updates[ident]["label"], "x" * 64)
+
+ def test_rename_peer_trims_limits_and_stamps_the_label(self):
+ peer = {"label": "Old", "label_set_at": 20}
+
+ renamed = settings_sync.rename_peer(peer, " " + "x" * 70 + " ", "author", now=19.8)
+
+ self.assertEqual(renamed, {"label": "x" * 64, "label_set_at": 21, "label_by": "author"})
+
+ def test_restored_names_get_new_stamps_for_peer_acceptance(self):
+ own = b64(b"\x01" * 16)
+ settings = {"machine_id": own, "name": "Current", "name_set_at": 40,
+ "name_by": own, "peers": []}
+ restored = settings_sync.restamp_names(settings,
+ {own: {"label": "Before sync", "set_at": 20, "by": own}}, own, now=30)
+
+ self.assertEqual(restored[own], {"label": "Before sync", "set_at": 41, "by": own})
def test_an_optional_design_state_keeps_its_own_stamp_and_effect_size(self):
values = {**settings_sync.mac_values(mac_raw()), "effect_size": "large"}
design_state = {"set_at": 63, "by": b64(b"\x03" * 16), "values": values}
@@ -82,7 +185,8 @@ class MessageTests(unittest.TestCase):
self.assertEqual(settings_sync.read_design_state(
{"on": False, "set_at": NOW, "by": b64(bytes(16)), "design_sync": state}, KEYS),
{"set_at": NOW, "by": state["by"],
- "values": {"effect_size": "medium", "glow_style": "beam"}})
+ "values": {"effect_size": "medium", "effect_size_fraction": 0.045,
+ "glow_style": "beam"}})
def test_an_invalid_effect_size_is_ignored_but_a_missing_one_defaults_to_medium(self):
state = {"set_at": NOW, "by": b64(bytes(16)),
@@ -132,11 +236,12 @@ class MessageTests(unittest.TestCase):
self.assertEqual((b["set_at"], b["by"], c["set_at"], c["by"]),
(100, a_id, 100, a_id))
- def test_explicit_follow_adopts_all_six_values_despite_a_newer_local_stamp(self):
+ def test_explicit_follow_adopts_all_design_values_despite_a_newer_local_stamp(self):
peer = b64(bytes([2]) * 16)
current = settings_sync.mac_values(mac_raw())
desired = dict(glow_style="beam", glow_colour="ocean", effect_length="long",
- effect_size="large", shortcut_arrival=False, shortcut_arrival_style="locator")
+ effect_size="large", effect_pace=2.0, effect_size_fraction=0.06,
+ shortcut_arrival=False, shortcut_arrival_style="locator")
state = {"set_at": 10, "by": peer, "values": desired}
taken = settings_sync.followed_design(current, state, peer, peer, False, 500, "", force=True)
self.assertEqual({key: taken["values"][key] for key in settings_sync.DESIGN_KEYS}, desired)
@@ -264,6 +369,105 @@ class MessageTests(unittest.TestCase):
"methods", "edge_parts", "corner"):
self.assertNotIn(own, flat)
+ def test_groups_filter_values_and_layout_always_travels(self):
+ values = settings_sync.mac_values(mac_raw())
+ groups = ("crossing", "shortcut")
+ data = settings_sync.message_data(True, 50, values, groups=groups,
+ layout_state={"set_at": 3, "by": "", "tiles": {"x": {}}})
+
+ self.assertEqual(data["groups"], list(groups))
+ self.assertEqual(set(data["crossing"]),
+ set(settings_sync.GROUP_KEYS["crossing"] + settings_sync.GROUP_KEYS["shortcut"]))
+ self.assertEqual(set(data["design"]), set())
+ self.assertEqual(set(settings_sync.read(data, KEYS)[2]),
+ set(settings_sync.GROUP_KEYS["crossing"] + settings_sync.GROUP_KEYS["shortcut"]))
+ self.assertIn("layout", data)
+
+ def test_old_peer_values_use_only_groups_selected_here_and_never_change_them(self):
+ data = settings_sync.message_data(True, 50, settings_sync.mac_values(mac_raw(glow_style="beam")))
+ data.pop("groups", None)
+
+ self.assertEqual(set(settings_sync.read(data, KEYS, current_groups=("design",))[2]),
+ set(settings_sync.GROUP_KEYS["design"]))
+ # None chosen here: Same was off, and a 1.5.1 peer turning it on means every group, as here.
+ self.assertEqual(set(settings_sync.read(data, KEYS, current_groups=())[2]),
+ set(settings_sync.CROSSING_KEYS + settings_sync.DESIGN_KEYS))
+ self.assertEqual(settings_sync.arrival_groups(data, ()), settings_sync.ALL_GROUPS)
+ self.assertEqual(settings_sync.arrival_groups(dict(data, on=False), ()), ())
+
+ def test_legacy_off_keeps_local_group_selection_and_transmitted_off_state(self):
+ data = {"on": False, "set_at": 50, "by": b64(bytes([1]) * 16)}
+
+ self.assertEqual(settings_sync.arrival_groups(data, ("design",)), ("design",))
+ self.assertEqual(settings_sync.read(data, KEYS, current_groups=("design",)), (False, 50, {}))
+
+ def test_everything_expands_to_all_four_groups(self):
+ self.assertEqual(settings_sync.groups_for_choice(("everything",)), settings_sync.ALL_GROUPS)
+
+ def test_snapshot_revert_and_expiry(self):
+ snapshot = settings_sync.same_snapshot(("crossing", "design"), {"resistance_px": 40}, now=100)
+
+ self.assertTrue(settings_sync.snapshot_available(snapshot, now=100 + settings_sync.SNAPSHOT_TTL))
+ self.assertFalse(settings_sync.snapshot_available(snapshot, now=101 + settings_sync.SNAPSHOT_TTL))
+ self.assertEqual(settings_sync.restore_snapshot(snapshot, now=200),
+ {"groups": ["crossing", "design"], "values": {"resistance_px": 40}})
+
+ def test_snapshot_is_taken_only_before_an_accepted_change(self):
+ groups = ("crossing",)
+ current = {"resistance_px": 120, "glow_style": "glow"}
+ data = settings_sync.message_data(True, 101, {"resistance_px": 60}, by=b64(bytes([1]) * 16),
+ groups=("crossing",))
+
+ saved = settings_sync.snapshot_for_arrival(data, 100, KEYS, "", groups, current, now=NOW)
+ stale = settings_sync.snapshot_for_arrival(data, 101, KEYS, data["by"], groups, current, now=NOW)
+ self.assertEqual(saved["values"], {"resistance_px": 120})
+ self.assertIsNone(stale)
+
+ def test_a_group_selection_only_update_still_saves_the_previous_selection(self):
+ current = {"resistance_px": 120, "glow_style": "glow"}
+ data = settings_sync.message_data(True, 101, current, by=b64(bytes([1]) * 16),
+ groups=("design",))
+
+ saved = settings_sync.snapshot_for_arrival(data, 100, KEYS, "", ("crossing",), current, now=NOW)
+
+ self.assertEqual(saved["groups"], ["crossing"])
+ self.assertEqual(saved["values"], {"glow_style": "glow"})
+
+ def test_snapshot_can_keep_the_local_names_group(self):
+ names = {b64(bytes([2]) * 16): {"label": "Old", "set_at": 2, "by": b64(bytes([1]) * 16)}}
+ snapshot = settings_sync.same_snapshot(("names",), {}, now=100, names=names)
+
+ self.assertEqual(settings_sync.restore_snapshot(snapshot, now=100)["names"], names)
+
+ def test_selection_only_revert_keeps_values_edited_since_the_update(self):
+ current = {"resistance_px": 120, "glow_style": "glow"}
+ data = settings_sync.message_data(True, 101, current, groups=["design"])
+ snapshot = settings_sync.snapshot_for_arrival(data, 100, KEYS, "", ["crossing"], current, now=NOW)
+ self.assertEqual(settings_sync.restore_snapshot(snapshot, now=NOW)["values"], {})
+ self.assertEqual(settings_sync.revert_groups(snapshot, ["design"]), ["crossing"])
+
+ def test_value_revert_keeps_the_current_policy_on(self):
+ data = settings_sync.message_data(True, 101, {"resistance_px": 60}, groups=["crossing"])
+ snapshot = settings_sync.snapshot_for_arrival(data, 100, KEYS, "", [], {"resistance_px": 120}, now=NOW)
+ self.assertEqual(settings_sync.revert_groups(snapshot, ["crossing"]), ["crossing"])
+
+ def test_a_refused_trigger_does_not_replace_a_previous_undo_snapshot(self):
+ data = settings_sync.message_data(True, 101, {"trigger_key": "f13"}, groups=["shortcut"])
+ self.assertIsNone(settings_sync.snapshot_for_arrival(
+ data, 100, KEYS, "", ["shortcut"], {"trigger_key": "alt_r"}, now=NOW, applied_values={}))
+
+ def test_an_update_without_design_values_does_not_advance_direct_design(self):
+ current = settings_sync.mac_values(mac_raw())
+ self.assertIsNone(settings_sync.design_change_stamp(current, {"resistance_px": 60}, 10, None, ""))
+ self.assertIsNone(settings_sync.design_change_stamp(current, {}, 10, None, ""))
+
+ def test_names_obey_the_accepted_policy_when_an_old_selection_arrives_late(self):
+ own = b64(b"\x01" * 16)
+ data = settings_sync.message_data(True, 10, groups=["names"],
+ names={own: {"label": "Delayed", "set_at": 30, "by": own}})
+ self.assertEqual(settings_sync.names_arrived(data, {}, own_id=own, now=NOW,
+ policy_groups=["crossing"]), ({}, None))
+
def test_jump_keys_are_not_sent_by_same_on_all_machines(self):
values = settings_sync.mac_values(mac_raw())
values["jump_key"] = "ctrl+alt+2"
@@ -358,6 +562,16 @@ class MessageTests(unittest.TestCase):
class AdapterTests(unittest.TestCase):
+ def test_left_out_fields_are_ignored_when_applying_synced_values(self):
+ raw = mac_raw()
+ applied = settings_sync.apply_mac(raw, {"left_out": True, "left_out_ways": ["edge"]})
+ config = pc_config()
+
+ settings_sync.apply_pc(config, {"left_out": True, "left_out_ways": ["edge"]})
+
+ self.assertEqual(applied, raw)
+ self.assertFalse(hasattr(config, "left_out"))
+
def test_size_is_read_applied_and_transmitted_on_both_machines(self):
mac = mac_raw(effect_size="large")
values = settings_sync.mac_values(mac)
@@ -397,6 +611,12 @@ class AdapterTests(unittest.TestCase):
self.assertIs(settings_sync.mac_values(mac_raw(methods=["edge"]))["shortcut"], False)
self.assertIs(settings_sync.pc_values(pc_config(crossing_methods=["edge", "shortcut"]))["shortcut"], True)
+ def test_older_pc_config_reads_presets_when_continuous_fields_are_absent(self):
+ config = pc_config(crossing_methods=["edge", "shortcut"])
+ values = settings_sync.pc_values(config)
+ self.assertEqual((values["effect_pace"], values["effect_size_fraction"], values["shortcut"]),
+ (1.0, 0.045, True))
+
def test_a_values_dict_has_no_zones(self):
for values in (settings_sync.mac_values(mac_raw()), settings_sync.pc_values(pc_config())):
for zone in ("methods", "edge_parts", "corner"):
diff --git a/core/tests/test_shortcut_cycle.py b/core/tests/test_shortcut_cycle.py
new file mode 100644
index 0000000..42132af
--- /dev/null
+++ b/core/tests/test_shortcut_cycle.py
@@ -0,0 +1,66 @@
+import unittest
+
+from core import settings_sync, ways
+
+
+HOME = "home"
+A, B, C = "a", "b", "c"
+
+
+def peer(ident, **values):
+ return {"id": ident, "send": True, "in_use": True, "port": 5000, **values}
+
+
+class ShortcutCycleTests(unittest.TestCase):
+ def test_order_sorts_rows_then_columns_and_rotates_after_this_machine(self):
+ peers = [peer(A), peer(B), peer(C)]
+ positions = {HOME: (100, 100, 100, 100), A: (0, 100, 100, 100),
+ B: (200, 130, 100, 100), C: (200, 220, 100, 100)}
+ self.assertEqual(ways.shortcut_order(peers, HOME, positions), [B, C, A, None])
+
+ def test_home_split_uses_the_same_row_tolerance_as_reading_order(self):
+ peers = [peer(A), peer(B)]
+ positions = {HOME: (100, 100, 100, 100), A: (0, 120, 100, 100),
+ B: (200, 100, 100, 100)}
+ self.assertEqual(ways.shortcut_order(peers, HOME, positions), [B, A, None])
+
+ def test_unplaced_peers_follow_in_peer_order_and_left_out_stays_in_cycle(self):
+ peers = [peer(A, left_out=True), peer(B), peer(C)]
+ positions = {HOME: (0, 0, 100, 100), B: (100, 0, 100, 100)}
+ self.assertEqual(ways.shortcut_order(peers, HOME, positions), [B, A, C, None])
+
+ def test_not_sendable_peers_are_excluded(self):
+ peers = [peer(A), peer(B, in_use=False), peer(C, send=False)]
+ self.assertEqual(ways.shortcut_order(peers, HOME, {HOME: (0, 0, 100, 100)}), [A, None])
+
+ def test_ticked_mode_omits_only_explicitly_unticked_peers(self):
+ peers = [peer(A, shortcut_cycle=False), peer(B), peer(C, shortcut_cycle=None)]
+ positions = {HOME: (0, 0, 100, 100)}
+ self.assertEqual(ways.shortcut_order(peers, HOME, positions, "ticked"), [B, C, None])
+
+ def test_next_target_skips_unready_peers_and_returns_home_after_the_last(self):
+ order = [A, B, C, None]
+ target, skipped = ways.next_target({"shortcut_goes_to": "next"}, order, None,
+ lambda ident: ident != A)
+ self.assertEqual((target, skipped), (B, [A]))
+ self.assertEqual(ways.next_target({}, order, C, lambda ident: True), (None, []))
+
+ def test_when_no_peer_is_ready_first_machine_is_named_for_the_refusal(self):
+ self.assertEqual(ways.next_target({}, [A, B, None], None, lambda _ident: False),
+ (A, [A, B]))
+
+ def test_hold_uses_last_machine_or_first_ready_cycle_machine(self):
+ order = [A, B, None]
+ self.assertEqual(ways.hold_target({"shortcut_goes_to": "last"}, order, A,
+ lambda _ident: True), (A, []))
+ self.assertEqual(ways.hold_target({"shortcut_goes_to": "next"}, order, A,
+ lambda ident: ident == B), (B, [A]))
+
+ def test_shortcut_mode_is_a_valid_optional_crossing_sync_value(self):
+ data = settings_sync.message_data(True, 7, {"shortcut_goes_to": "ticked"})
+ self.assertEqual(data["crossing"], {"shortcut_goes_to": "ticked"})
+ self.assertEqual(settings_sync.read(data, set())[2], {"shortcut_goes_to": "ticked"})
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/core/tests/test_special_keys.py b/core/tests/test_special_keys.py
new file mode 100644
index 0000000..6c75cbb
--- /dev/null
+++ b/core/tests/test_special_keys.py
@@ -0,0 +1,96 @@
+import unittest
+
+from core import special_keys
+
+
+class SpecialKeyWireTests(unittest.TestCase):
+ def test_window_switcher_chord_rules(self):
+ cases = (
+ ("macos", "windows", "tab", {"cmd"}, (("cmd",), "alt")),
+ ("macos", "windows", "tab", {"cmd", "shift"}, (("cmd",), "alt")),
+ ("macos", "linux", "tab", {"cmd_r"}, (("cmd_r",), "alt")),
+ ("windows", "macos", "tab", {"alt", "shift"}, (("alt",), "cmd")),
+ ("linux", "macos", "tab", {"alt_r"}, (("alt_r",), "cmd")),
+ )
+ for own, peer, key, held, expected in cases:
+ with self.subTest(own=own, peer=peer, held=held):
+ self.assertEqual(special_keys.switcher_chord(own, peer, key, held), expected)
+
+ def test_window_switcher_chord_ignores_other_keys_and_same_system_pairs(self):
+ self.assertIsNone(special_keys.switcher_chord("macos", "windows", "c", {"cmd"}))
+ self.assertIsNone(special_keys.switcher_chord("macos", "macos", "tab", {"cmd"}))
+ self.assertIsNone(special_keys.switcher_chord("windows", "linux", "tab", {"alt"}))
+ self.assertIsNone(special_keys.switcher_chord("windows", "macos", "tab", {"cmd"}))
+
+ def test_ios_is_in_the_mac_family_for_switcher_pairs(self):
+ self.assertIsNone(special_keys.switcher_chord("macos", "ios", "tab", {"cmd"}))
+ self.assertEqual(special_keys.switcher_chord("windows", "ios", "tab", {"alt"}), (("alt",), "cmd"))
+ self.assertEqual(special_keys.switcher_chord("ios", "windows", "tab", {"cmd"}), (("cmd",), "alt"))
+
+ def test_switcher_hold_survives_repeated_and_shift_tab_until_the_source_releases(self):
+ messages, held_as = special_keys.switcher_transitions("macos", "windows", {"cmd": "ctrl"})
+ self.assertEqual(held_as, {"cmd": "alt"})
+ self.assertEqual(special_keys.switcher_transitions("macos", "windows", {"cmd": "alt"}), ([], {}))
+ shifted = {"cmd": "alt", "shift": "shift"}
+ self.assertEqual(special_keys.switcher_transitions("macos", "windows", shifted), ([], {}))
+ self.assertEqual(special_keys.release_key("cmd", {"cmd": "alt", "shift": "shift"}), "alt")
+ self.assertEqual(special_keys.release_key("shift", {"shift": "shift"}), "shift")
+
+ def test_release_key_waits_until_the_last_physical_key_with_that_wire_name(self):
+ held = {"alt": "cmd", "alt_r": "cmd"}
+ self.assertIsNone(special_keys.release_key("alt", held))
+ self.assertEqual(special_keys.release_key("alt_r", {"alt_r": "cmd"}), "cmd")
+
+ def test_switcher_transitions_move_cmd_to_alt_once_and_keep_it(self):
+ messages, held_as = special_keys.switcher_transitions("macos", "windows", {"cmd": "ctrl"})
+ self.assertEqual(messages, [{"type": "keyup", "data": {"key": "ctrl"}},
+ {"type": "keydown", "data": {"key": "alt"}}])
+ self.assertEqual(held_as, {"cmd": "alt"})
+ self.assertEqual(special_keys.switcher_transitions("macos", "windows", {"cmd": "alt"}), ([], {}))
+
+ def test_switcher_transitions_leave_a_key_another_physical_key_still_holds(self):
+ messages, _ = special_keys.switcher_transitions("macos", "linux", {"cmd": "ctrl", "ctrl": "ctrl"})
+ self.assertEqual(messages, [{"type": "keydown", "data": {"key": "alt"}}])
+
+ def test_switcher_transitions_alt_tab_to_a_mac_becomes_cmd(self):
+ messages, held_as = special_keys.switcher_transitions("windows", "macos", {"alt": "alt"})
+ self.assertEqual(messages, [{"type": "keyup", "data": {"key": "alt"}},
+ {"type": "keydown", "data": {"key": "cmd"}}])
+ self.assertEqual(held_as["alt"], "cmd")
+
+ def test_switcher_transitions_nothing_without_the_modifier_or_between_like_systems(self):
+ self.assertEqual(special_keys.switcher_transitions("macos", "windows", {"shift": "shift"}), ([], {}))
+ self.assertEqual(special_keys.switcher_transitions("windows", "linux", {"alt": "alt"}), ([], {}))
+
+ def test_plain_mac_function_keys_keep_their_physical_names(self):
+ for key in ("f4", "f5", "f6"):
+ self.assertEqual(special_keys.wire_name(key, "macos", "windows"), key)
+ self.assertEqual(special_keys.wire_name(key, "macos", "linux"), key)
+
+ def test_search_key_from_windows_or_linux_opens_mac_spotlight(self):
+ self.assertEqual(special_keys.wire_name("browser_search", "windows", "macos"), "spotlight")
+ self.assertEqual(special_keys.wire_name("search", "linux", "macos"), "spotlight")
+
+ def test_windows_search_and_dictation_shortcuts_become_mac_intents(self):
+ self.assertEqual(special_keys.windows_shortcut_intent("s"), "spotlight")
+ self.assertEqual(special_keys.windows_shortcut_intent("h"), "dictation")
+ self.assertEqual(special_keys.windows_shortcut_intent("n"), "")
+
+ def test_mac_f13_print_screen_maps_to_the_windows_print_screen_key(self):
+ self.assertEqual(special_keys.wire_name("f13", "macos", "windows"), "print_screen")
+
+ def test_same_platform_and_unmapped_keys_keep_their_physical_name(self):
+ self.assertEqual(special_keys.wire_name("f4", "macos", "macos"), "f4")
+ self.assertEqual(special_keys.wire_name("f6", "macos", "windows"), "f6")
+ self.assertEqual(special_keys.wire_name("volume_up", "windows", "macos"), "volume_up")
+
+ def test_media_keys_keep_their_names_across_both_wire_directions(self):
+ keys = ("volume_up", "volume_down", "volume_mute", "media_play_pause", "media_next", "media_prev")
+ for key in keys:
+ self.assertEqual(special_keys.wire_name(key, "macos", "windows"), key)
+ self.assertEqual(special_keys.wire_name(key, "windows", "macos"), key)
+ self.assertEqual(special_keys.wire_name(key, "linux", "windows"), key)
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/core/tests/test_style_previews.py b/core/tests/test_style_previews.py
new file mode 100644
index 0000000..8520f08
--- /dev/null
+++ b/core/tests/test_style_previews.py
@@ -0,0 +1,123 @@
+"""Whole-crossing specimens retain the journey and freeze at the seam."""
+
+import unittest
+
+from core import effects
+
+STYLES = tuple(dict.fromkeys((*effects.CLASSIC, *effects.EFFECT_IDS)))
+PLACES = ("edge", "corner", "notch")
+PALETTE = ("#49b59c", "#db8d4b")
+
+
+def marks(scene):
+ return [[op[:2] + ((op[2].kind, op[2].geometry, op[2].stops)
+ if isinstance(op[2], effects.Gradient) else op[2],) + op[3:]
+ for op in pen.ops] for pen in scene["pens"]]
+
+
+class StylePreviewTests(unittest.TestCase):
+ def test_the_shipped_still_table_is_what_the_search_finds(self):
+ for style in STYLES:
+ for place, index in effects._PLACE_INDEX.items():
+ with self.subTest(style=style, place=place):
+ effects._search_still.cache_clear()
+ self.assertEqual(effects.STILL_SEARCHED[style][index], effects._search_still(style, place))
+
+ def test_a_length_or_size_step_builds_no_scene(self):
+ from unittest import mock
+ with mock.patch.object(effects, "preview_still_scene", side_effect=AssertionError("scene built")):
+ for style in STYLES:
+ for place in (*PLACES, "switch"):
+ for pace, fraction in ((0.37, 0.021), (1.0, None), (2.5, 0.079)):
+ at = effects.still_time(style, place, pace=pace, effect_size_fraction=fraction)
+ start = effects._S_START if place == "switch" else effects._P_CROSS
+ searched = effects.STILL_SEARCHED[style][effects._PLACE_INDEX[place]]
+ self.assertAlmostEqual(at, searched if searched < start else start + (searched - start) * pace)
+
+ def test_a_still_is_the_same_picture_at_every_length(self):
+ for style in STYLES:
+ for place in (*PLACES, "switch"):
+ with self.subTest(style=style, place=place):
+ fx = effects.preview_effect(style)
+ stills = [effects.preview_still_scene(fx, effects.still_time(style, place, pace=pace), place,
+ PALETTE, pace=pace) for pace in (0.25, 1.0, 2.5)]
+ def rounded(value):
+ if isinstance(value, float):
+ return round(value, 6)
+ if isinstance(value, (list, tuple)):
+ return type(value)(rounded(item) for item in value)
+ return value
+ for scene in stills[1:]:
+ self.assertEqual(rounded(scene["pointer"]), rounded(stills[0]["pointer"]))
+ self.assertEqual(rounded(marks(scene)), rounded(marks(stills[0])))
+
+ def test_hover_begins_at_approach_after_intent_and_reduced_motion_holds_still(self):
+ held = effects.still_time("beam", "edge")
+ self.assertEqual(effects.preview_time(held), held)
+ self.assertEqual(effects.preview_time(held, -0.05), held)
+ self.assertEqual(effects.preview_time(held, 0.0), 0.0)
+ self.assertEqual(effects.preview_time(held, 0.2), 0.2)
+ self.assertEqual(effects.preview_time(held, 0.2, reduced=True), held)
+ self.assertEqual(effects.preview_time(held, 0.2, switch=True), held + 0.2)
+
+
+ def test_camera_contains_pointer_for_the_entire_crossing(self):
+ for style in STYLES:
+ for place in PLACES:
+ with self.subTest(style=style, place=place):
+ fx = effects.preview_effect(style)
+ view = effects.still_view(fx, place)
+ x, y, width, height = view
+ for step in range(89):
+ scene = effects.preview_still_scene(fx, step * 0.05, place, PALETTE, live=True)
+ px, py, _os = scene["pointer"]
+ self.assertLessEqual(x, px)
+ self.assertLessEqual(px, x + width - 20)
+ self.assertLessEqual(y, py)
+ self.assertLessEqual(py, y + height - 20)
+ self.assertEqual(len(scene["screens"]), 2)
+
+
+ def test_still_is_a_real_seam_frame_with_pointer(self):
+ for style in STYLES:
+ for place in PLACES:
+ for pace in (0.25, 1.0, 2.0):
+ with self.subTest(style=style, place=place, pace=pace):
+ fx = effects.preview_effect(style)
+ at = effects.still_time(fx, place, pace=pace)
+ self.assertGreaterEqual(at, effects._P_CROSS - 0.3)
+ # The same frame of the effect at every Length: after the crossing it comes later.
+ self.assertLessEqual(at, effects._P_CROSS + 0.3 * max(1.0, pace))
+ scene = effects.preview_still_scene(fx, at, place, PALETTE, pace=pace)
+ self.assertIsNotNone(scene["pointer"])
+ self.assertEqual(len(scene["screens"]), 2)
+ if place != "notch" or style not in ("glow", "beam"):
+ self.assertTrue(scene["pens"])
+ frozen = effects.preview_still_scene(fx, 3.9, place, PALETTE, reduced=True, live=True, pace=pace)
+ self.assertEqual(frozen["pointer"], scene["pointer"])
+ self.assertEqual(marks(frozen), marks(scene))
+
+
+ def test_whole_journey_and_repeat(self):
+ for place in PLACES:
+ with self.subTest(place=place):
+ fx = effects.preview_effect("aperture")
+ scenes = [effects.preview_still_scene(fx, at, place, PALETTE, live=True)
+ for at in (0, 0.4, 2.1, 2.2, 3.4, effects.PREVIEW_LOOP_S)]
+ self.assertEqual([scene["pointer"][2] for scene in scenes], ["mac", "mac", "mac", "windows", "windows", "mac"])
+ self.assertNotEqual(scenes[0]["pointer"], scenes[1]["pointer"])
+ self.assertNotEqual(scenes[3]["pointer"], scenes[4]["pointer"])
+ self.assertEqual(scenes[0]["pointer"], scenes[-1]["pointer"])
+ self.assertTrue(scenes[2]["pens"] and scenes[3]["pens"])
+
+
+ def test_notch_contact_and_arrival_pointers_are_clear_of_the_hardware_cutout(self):
+ for notch in ((185, 32), (220, 48), (150, 24)):
+ with self.subTest(notch=notch):
+ fx = effects.preview_effect("aperture")
+ contact = effects.preview_still_scene(fx, 1.9, "notch", PALETTE, notch_geometry=notch)
+ arrival = effects.preview_still_scene(fx, 2.2, "notch", PALETTE, live=True, notch_geometry=notch)
+ _x, top, _w, height, _r = contact["notch"]
+ self.assertGreater(contact["pointer"][1], top + height)
+ self.assertLess(arrival["pointer"][1] + 20, top)
+ self.assertEqual(contact["notch"][2:4], notch)
diff --git a/core/tests/test_switch_display_pair.py b/core/tests/test_switch_display_pair.py
new file mode 100644
index 0000000..c2443b4
--- /dev/null
+++ b/core/tests/test_switch_display_pair.py
@@ -0,0 +1,88 @@
+"""A zone that knows the display it leads to but not which of its sides (or the reverse) still
+crosses, and a driven machine whose switch cannot be built keeps its zones (rc12, 10-10-2026: the rig's
+first push back raised "display and side go together" after disarming, and nothing crossed after)."""
+
+import unittest
+from unittest import mock
+
+from core import protocol, receiver, return_edge
+from core.return_edge import Rect
+from core.tests.responder_harness import Initiator, Machine, entry, wait_for, B, HERE
+
+MONITORS = [Rect(0, 0, 1920, 1080)]
+
+
+class Outcomes(unittest.TestCase):
+ def push(self, model):
+ outcome = None
+ for _ in range(10):
+ outcome = model.feed(MONITORS, (0, 540), -40, 0, display_map={"0": MONITORS[0]})
+ if outcome.action == return_edge.CROSS:
+ return outcome
+ self.fail(f"never crossed: {outcome}")
+
+ def test_a_target_side_with_no_target_display_names_neither(self):
+ outcome = self.push(return_edge.ReturnEdge("left", 120, display="0", target_side="right"))
+ self.assertIsNone(outcome.display)
+ self.assertIsNone(outcome.side)
+ protocol.switch_v6(1, HERE, outcome.edge, outcome.offset, display=outcome.display, side=outcome.side)
+
+ def test_a_target_display_brings_its_side(self):
+ outcome = self.push(return_edge.ReturnEdge("left", 120, display="0", target_display="2", target_side="top"))
+ self.assertEqual((outcome.display, outcome.side), ("2", "top"))
+ outcome = self.push(return_edge.ReturnEdge("left", 120, display="0", target_display="2"))
+ self.assertEqual((outcome.display, outcome.side), ("2", "right"))
+
+
+class DrivenSwitch(unittest.TestCase):
+ def setUp(self):
+ grace = mock.patch.object(return_edge, "ARRIVAL_GRACE_SECONDS", 0.0)
+ grace.start()
+ self.addCleanup(grace.stop)
+
+ def test_a_switch_that_cannot_name_its_display_still_goes_and_never_strands_the_zones(self):
+ # A PC's report: a scoped zone with target_side and no target_display.
+ machine = Machine([entry(B, "Mac", side="left")],
+ [{"peer": protocol.id_text(B), "kind": "edge", "display": "0", "side": "left",
+ "target_side": "right"}]).start()
+ self.addCleanup(machine.stop)
+ link = Initiator(machine)
+ self.addCleanup(link.close)
+ link.handshake()
+ route = link.take(reach=[], resistance_px=120)
+ self.assertEqual(link.answer(route)[0], protocol.MSG_ACCEPT)
+ machine.desktop.cursor = (0, 540)
+ for _ in range(8):
+ link.move(-40, 0)
+ machine.desktop.cursor = (0, 540)
+ switch = link.expect(protocol.MSG_SWITCH, timeout=2.0)
+ self.assertIsNotNone(switch, "the push through the edge sent no switch")
+ self.assertEqual(switch["next"], protocol.id_text(B))
+ self.assertNotIn("display", switch)
+
+ def test_a_switch_that_cannot_be_built_leaves_the_zones_armed(self):
+ machine = Machine([entry(B, "Mac", side="left")], [{"peer": protocol.id_text(B), "kind": "edge"}]).start()
+ self.addCleanup(machine.stop)
+ link = Initiator(machine)
+ self.addCleanup(link.close)
+ link.handshake()
+ route = link.take(reach=[], resistance_px=120)
+ self.assertEqual(link.answer(route)[0], protocol.MSG_ACCEPT)
+ real = protocol.switch_v6
+ with mock.patch.object(protocol, "switch_v6", side_effect=ValueError("broken")) as broken:
+ machine.desktop.cursor = (0, 540)
+ for _ in range(8):
+ link.move(-40, 0)
+ machine.desktop.cursor = (0, 540)
+ self.assertTrue(wait_for(lambda: broken.call_count >= 1, 2.0), "the push never reached the edge")
+ self.assertTrue(link.acked(link.seq), "the moves were not all taken")
+ self.assertTrue(machine.responder._zones_live, "a failed switch disarmed the way out")
+ with mock.patch.object(protocol, "switch_v6", real):
+ for _ in range(8):
+ link.move(-40, 0)
+ machine.desktop.cursor = (0, 540)
+ self.assertIsNotNone(link.expect(protocol.MSG_SWITCH, timeout=2.0), "the next push did not cross")
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/core/tests/test_three_desks.py b/core/tests/test_three_desks.py
index 57d794c..ba3417e 100644
--- a/core/tests/test_three_desks.py
+++ b/core/tests/test_three_desks.py
@@ -6,6 +6,7 @@ a driven pointer crosses by the responder's zones and a `switch`, all core/owner
import time
import unittest
+from unittest import mock
from core import owner as owner_module
from core import protocol
@@ -44,6 +45,11 @@ class Desks(unittest.TestCase):
LAYOUT = {}
def setUp(self):
+ # These tests cross the moment input lands; the arrival grace is test_arrival_grace's
+ # subject, not theirs.
+ grace = mock.patch.object(return_edge, "ARRIVAL_GRACE_SECONDS", 0.0)
+ grace.start()
+ self.addCleanup(grace.stop)
self.desks = {own: Desk(self, own, sides, zones) for own, (sides, zones) in self.LAYOUT.items()}
for own, desk in self.desks.items():
desk.connect(self, [other for ident_, other in self.desks.items() if ident_ != own])
@@ -226,13 +232,10 @@ class AMachinePairedLate(Desks):
self.assertEqual(self.arrives(A, C, "left", 1_790_000_100), (True, []))
self.walk(A, [("right", C), ("left", A), ("left", B), ("right", A)])
- def test_a_side_arriving_onto_another_machines_edge_is_refused_out_loud_and_the_thirds_share_it(self):
+ def test_an_old_side_arriving_onto_another_edge_has_no_way_until_the_map_shares_it(self):
changed, notices = self.arrives(A, C, "right", 1_790_000_100)
self.assertTrue(changed)
- # The harness's handshakes name every machine "Peer", so the sentences are held by their shape.
- self.assertEqual(len(notices), 1)
- self.assertIn("now lead from the same part of this PC's screen", notices[0])
- self.assertTrue(notices[0].endswith("edge is off."))
+ self.assertEqual(notices, [])
settings = self.desks[A].machine.settings.data
self.assertIn("has no way in", ways.blocked_sentence(settings, text(C), "this PC"))
self.assertFalse(ways.has_way(settings, text(C)))
@@ -241,7 +244,15 @@ class AMachinePairedLate(Desks):
self.assertEqual(self.answers(A, C), (True, []))
self.assertIn("has no way back", ways.no_way_back_sentence(on_sea, text(A)))
self.assertEqual(self.answers(A, C), (False, []))
- # What the Crossing page then offers: each its own thirds of the left edge.
+ # The map gives each machine a contact, then the page narrows its own thirds.
+ layout = {
+ text(A): dict(x=0, y=0, w=160, h=100),
+ text(B): dict(x=-160, y=-50, w=160, h=100),
+ text(C): dict(x=-160, y=51, w=160, h=100),
+ }
+ result = ways.compile_layout(settings, layout, capable={text(A), text(B), text(C)}, now=time.time())
+ settings.clear()
+ settings.update(result["settings"])
ways.edit(settings, text(B), side="left", methods=["part"], parts=["start"], corner="top_left",
kinds=("edge", "part", "corner"), corner_edge=lambda corner, side: side, now=time.time())
ways.edit(settings, text(C), side="left", methods=["part"], parts=["end"], corner="top_left",
diff --git a/core/tests/test_three_machines.py b/core/tests/test_three_machines.py
index 57d96e1..3dd96da 100644
--- a/core/tests/test_three_machines.py
+++ b/core/tests/test_three_machines.py
@@ -5,7 +5,9 @@ with nothing faked but the platform edges. The links are the harness's scripted
import time
import unittest
+from unittest import mock
+from core import return_edge
from core import owner as owner_module
from core import protocol
from core.tests.responder_harness import Initiator, Machine, entry, ident, token, wait_for
@@ -123,6 +125,11 @@ class Chain(unittest.TestCase):
"""Owner to A, A's zone to B, B's zone to C, C's zone back to A, over four real links."""
def setUp(self):
+ # These tests cross the moment input lands; the arrival grace is test_arrival_grace's
+ # subject, not theirs.
+ grace = mock.patch.object(return_edge, "ARRIVAL_GRACE_SECONDS", 0.0)
+ grace.start()
+ self.addCleanup(grace.stop)
self.a = responder(self, A, [(O, "bottom"), (B, "right"), (C, "left")], zones=(O, B))
self.b = responder(self, B, [(O, "bottom"), (A, "left"), (C, "right")], zones=(O, C))
self.c = responder(self, C, [(O, "bottom"), (B, "left"), (A, "right")], zones=(O, A))
diff --git a/core/tests/test_ways.py b/core/tests/test_ways.py
index 7d81f3d..bd50ef6 100644
--- a/core/tests/test_ways.py
+++ b/core/tests/test_ways.py
@@ -1,9 +1,11 @@
"""core/ways.py: a machine's zones read and written one peer at a time, the side settled with each
peer, the machine the shortcut picks, and the pairings a zone needs (WIRE.md sections 5 and 8)."""
+import itertools
+import time
import unittest
-from core import protocol, ways
+from core import crossing_state, protocol, ways
HERE = protocol.id_text(bytes(range(1, 17)))
A = protocol.id_text(bytes(range(20, 36)))
@@ -39,7 +41,8 @@ PC = ("edge", "part", "corner")
class ReadingOnePeer(unittest.TestCase):
def test_a_peer_with_no_zones_reads_as_nothing_in_use_and_the_defaults(self):
found = ways.ways(settings(peer(A, "Ay", side="left")), A)
- self.assertEqual(found, {"side": "left", "methods": [], "parts": ["middle"], "corner": "top_left"})
+ self.assertEqual(found, {"side": "left", "methods": ["edge"],
+ "parts": ["start", "middle", "end"], "corner": "top_left"})
def test_only_that_peers_zones_in_use_count(self):
held = settings(peer(A, "Ay", side="left"), peer(B, "Bee", side="right"), zones=[
@@ -48,7 +51,7 @@ class ReadingOnePeer(unittest.TestCase):
{"peer": B, "kind": "part", "parts": ["start", "end"]},
{"peer": B, "kind": "corner", "corner": "top_right", "edge": "right"},
])
- self.assertEqual(ways.ways(held, A), {"side": "left", "methods": ["edge"], "parts": ["middle"], "corner": "bottom_left"})
+ self.assertEqual(ways.ways(held, A), {"side": "left", "methods": ["edge"], "parts": ["start", "middle", "end"], "corner": "bottom_left"})
self.assertEqual(ways.ways(held, B), {"side": "right", "methods": ["part", "corner"], "parts": ["start", "end"],
"corner": "top_right"})
@@ -56,6 +59,306 @@ class ReadingOnePeer(unittest.TestCase):
self.assertEqual(ways.ways(settings(), A)["methods"], [])
+class PageOffZones(unittest.TestCase):
+ def edit(self, held, methods):
+ return ways.edit(held, A, side="right", methods=methods, parts=[], corner="top_left", kinds=MAC,
+ corner_edge=mac_corner_edge, now=30)
+
+ def contact(self, *, peer_y=0, own_displays=False, peer_displays=False):
+ own = {"x": 0, "y": 0, "w": 160, "h": 100}
+ other = {"x": 160, "y": peer_y, "w": 160, "h": 100}
+ if own_displays:
+ own["displays"] = {"main": {"x": 0, "y": 0, "w": 160, "h": 100}}
+ if peer_displays:
+ other["displays"] = {"main": {"x": 0, "y": 0, "w": 160, "h": 100}}
+ return {HERE: own, A: other}
+
+ def test_unticking_edge_turns_off_unscoped_and_display_scoped_edge_zones(self):
+ held = settings(peer(A, "Ay", side="right"), zones=[{"peer": A, "kind": "edge"}])
+ held["layout"] = self.contact(own_displays=True, peer_displays=True)
+
+ self.edit(held, ["shortcut"])
+
+ self.assertEqual(ways.ways(held, A)["methods"], [])
+ self.assertEqual(held["zones"], [])
+ self.assertFalse(ways.has_way(held, A))
+ self.assertFalse(ways.crosses_on_map(held, A))
+
+ self.edit(held, ["edge"])
+ zone = held["zones"][0]
+ self.assertEqual((zone["kind"], zone["display"], zone["side"]), ("edge", "main", "right"))
+ self.assertTrue(ways.has_way(held, A))
+
+ def test_page_does_not_turn_on_a_stale_scoped_zone(self):
+ held = settings(peer(A, "Ay", side="right"), zones=[
+ {"peer": A, "kind": "edge", "display": "0", "side": "right", "off": True},
+ ])
+
+ self.edit(held, ["edge"])
+
+ self.assertEqual(ways.ways(held, A)["methods"], ["edge"])
+ self.assertEqual(held["zones"][0]["kind"], "edge")
+ self.assertNotIn("off", held["zones"][0])
+
+ def test_compile_layout_keeps_a_page_off_scoped_zone_off(self):
+ held = settings(peer(A, "Ay", side="right"), zones=[
+ {"peer": A, "kind": "edge", "display": "main", "side": "right", "off": True, "page_off": True},
+ ])
+ layout = {
+ HERE: {"x": 0, "y": 0, "w": 160, "h": 100,
+ "displays": {"main": {"x": 0, "y": 0, "w": 160, "h": 100}}},
+ A: {"x": 160, "y": 0, "w": 160, "h": 100,
+ "displays": {"main": {"x": 160, "y": 0, "w": 160, "h": 100}}},
+ }
+
+ result = ways.compile_layout(held, layout)
+
+ self.assertTrue(result["accepted"])
+ self.assertEqual(result["settings"]["peers"][0]["ways"]["edge"], False)
+ self.assertEqual(result["settings"]["zones"], [])
+
+ def test_unticked_edge_survives_compile_with_or_without_display_metadata(self):
+ for scoped in (False, True):
+ for own_displays in (False, True):
+ for peer_displays in (False, True):
+ for y in (0, 50):
+ with self.subTest(scoped=scoped, own_displays=own_displays,
+ peer_displays=peer_displays, y=y):
+ zone = {"peer": A, "kind": "edge", "off": True} if scoped else {"peer": A, "kind": "edge"}
+ held = settings(peer(A, "Ay", side="right"), zones=[zone])
+ layout = self.contact(peer_y=y, own_displays=own_displays, peer_displays=peer_displays)
+ held["layout"] = layout
+ self.edit(held, ["shortcut"])
+
+ for _ in range(2):
+ result = ways.compile_layout(held, layout, moved=A)
+ self.assertTrue(result["accepted"])
+ held = result["settings"]
+ self.assertFalse(ways.crosses_on_map(held, A))
+ self.assertNotIn("edge", ways.ways(held, A)["methods"])
+ self.assertNotIn("part", ways.ways(held, A)["methods"])
+ self.assertEqual(held["zones"], [])
+
+ self.edit(held, ["edge"])
+ self.assertTrue(ways.crosses_on_map(held, A))
+ self.assertTrue(all("page_off" not in zone and "off" not in zone
+ for zone in held["zones"]))
+
+ def test_a_page_off_mark_goes_with_a_contact_the_tile_has_left(self):
+ held = settings(peer(A, "Ay", side="top"), zones=[
+ {"peer": A, "kind": "edge", "display": "main", "side": "top", "off": True, "page_off": True},
+ ])
+ layout = {
+ HERE: {"x": 0, "y": 0, "w": 160, "h": 100,
+ "displays": {"main": {"x": 0, "y": 0, "w": 160, "h": 100}}},
+ A: {"x": 160, "y": 0, "w": 160, "h": 100,
+ "displays": {"main": {"x": 160, "y": 0, "w": 160, "h": 100}}},
+ }
+
+ compiled = ways.compile_layout(held, layout)["settings"]
+ self.edit(compiled, ["shortcut"])
+ self.edit(compiled, ["edge"])
+
+ self.assertEqual(ways.ways(compiled, A)["methods"], ["edge"])
+ self.assertTrue(all(zone.get("side") != "top" for zone in compiled["zones"]))
+
+ def test_unticked_edge_survives_display_metadata_disappearing_and_returning(self):
+ held = settings(peer(A, "Ay", side="right"), zones=[
+ {"peer": A, "kind": "edge", "display": "main", "side": "right"},
+ ])
+ self.edit(held, ["shortcut"])
+ for display in ("main", None, "replacement", None):
+ layout = self.contact(own_displays=display is not None)
+ if display not in (None, "main"):
+ layout[HERE]["displays"] = {display: {"x": 0, "y": 0, "w": 160, "h": 100}}
+ held = ways.compile_layout(held, layout)["settings"]
+ self.assertFalse(ways.crosses_on_map(held, A))
+ self.assertEqual(held["zones"], [])
+
+ def test_compile_without_display_metadata_does_not_record_a_page_untick_for_a_scoped_corner(self):
+ held = settings(peer(A, "Ay", side="right"), zones=[
+ {"peer": A, "kind": "corner", "display": "main", "side": "right",
+ "corner": "top_right", "edge": "right", "off": True, "aside": True},
+ ])
+ held["layout"] = self.contact(own_displays=True, peer_displays=True)
+ held["peers"][0]["ways"] = {"edge": True, "thirds": list(ways.PARTS), "corner": True,
+ "corner_at": "top_right", "notch": False}
+ layout = self.contact()
+ compiled = ways.compile_layout(held, layout)["settings"]
+ corner = next(zone for zone in compiled["zones"] if zone["kind"] == "corner")
+ self.assertEqual((corner["kind"], corner["corner"], corner["side"]), ("corner", "top_right", "right"))
+ self.assertEqual(compiled["peers"][0]["ways"]["corner_at"], "top_right")
+ self.assertNotIn("page_off", corner)
+
+ def test_unscoped_page_off_mark_leaves_when_the_contact_changes_side(self):
+ held = settings(peer(A, "Ay", side="right"), zones=[{"peer": A, "kind": "edge"}])
+ self.edit(held, ["shortcut"])
+ self.assertEqual(held["peers"][0]["ways"]["edge"], False)
+ held["layout"] = self.contact()
+ self.edit(held, ["edge"])
+ self.assertEqual(ways.ways(held, A)["methods"], ["edge"])
+ self.assertTrue(ways.crosses_on_map(held, A))
+
+ def test_a_scoped_zone_set_aside_stays_off_once_the_page_turns_its_way_off(self):
+ held = settings(peer(A, "Ay", side="right"), zones=[
+ {"peer": A, "kind": "edge", "display": "0", "side": "right", "off": True, "aside": True},
+ ])
+
+ self.edit(held, ["shortcut"])
+ before = held["peers"][0]["ways"].copy()
+ self.assertEqual(ways.settle_presence(held, "this Mac", lambda _peer: True, lambda _peer: False), [])
+ self.assertEqual(held["peers"][0]["ways"], before)
+ self.assertEqual(held["zones"], [])
+
+ def test_notch_does_not_light_the_map_contact(self):
+ held = settings(peer(A, "Ay", side="right"), zones=[{"peer": A, "kind": "notch"}])
+ held["peers"][0]["ways"] = {"edge": False, "thirds": list(ways.PARTS), "corner": False,
+ "corner_at": "top_left", "notch": True}
+
+ self.assertTrue(ways.has_way(held, A))
+ self.assertFalse(ways.crosses_on_map(held, A))
+
+ def test_compiling_an_unticked_edge_keeps_the_notch_in_use(self):
+ held = settings(peer(A, "Ay", side="right"), zones=[{"peer": A, "kind": "edge"}])
+ held["peers"][0]["ways"] = {"edge": False, "thirds": list(ways.PARTS), "corner": False,
+ "corner_at": "top_left", "notch": True}
+ layout = self.contact()
+ held["layout"] = layout
+ compiled = ways.compile_layout(held, layout, platform="mac")["settings"]
+ self.assertFalse(ways.crosses_on_map(compiled, A))
+ self.assertTrue(ways.has_way(compiled, A))
+ self.assertIn("notch", ways.ways(compiled, A)["methods"])
+
+
+class LeavingOut(unittest.TestCase):
+ def test_leave_out_turns_every_zone_off_and_put_back_restores_only_the_recorded_kinds(self):
+ held = settings(peer(A, "Ay", side="right"), zones=[
+ {"peer": A, "kind": "edge"},
+ {"peer": A, "kind": "part", "parts": ["start"], "off": True},
+ {"peer": A, "kind": "corner", "corner": "bottom_left", "off": True},
+ ])
+
+ held["layout"] = {HERE: {"x": 0, "y": 0, "w": 160, "h": 100},
+ A: {"x": 160, "y": 0, "w": 160, "h": 100}}
+ ways.leave_out(held, A)
+
+ self.assertTrue(held["peers"][0]["left_out"])
+ self.assertNotIn("left_out_ways", held["peers"][0])
+ self.assertEqual(held["peers"][0]["ways"], {"edge": True, "thirds": list(ways.PARTS),
+ "corner": False, "corner_at": "bottom_left", "notch": False})
+ self.assertEqual(held["zones"], [])
+ self.assertFalse(ways.has_way(held, A))
+
+ ways.put_back(held, A)
+
+ self.assertNotIn("left_out", held["peers"][0])
+ self.assertNotIn("left_out_ways", held["peers"][0])
+ self.assertEqual(held["peers"][0]["ways"]["edge"], True)
+ self.assertEqual(held["peers"][0]["ways"]["thirds"], list(ways.PARTS))
+ self.assertTrue(ways.has_way(held, A))
+
+ def test_left_out_peer_arrangement_has_no_way_back_and_restoring_zones_restores_it(self):
+ held = settings(peer(A, "Ay", side="left"), zones=[{"peer": A, "kind": "edge"}])
+
+ ways.leave_out(held, A)
+ self.assertFalse(ways.has_way(held, A))
+ message = protocol.arrangement_v6("right", 1, protocol.read_id(HERE), way_back=ways.has_way(held, A))
+ self.assertIs(message["data"]["way_back"], False)
+ self.assertFalse(ways.way_back_state(held)[A][0])
+ ways.put_back(held, A)
+ self.assertTrue(ways.has_way(held, A))
+ message = protocol.arrangement_v6("right", 1, protocol.read_id(HERE), way_back=ways.has_way(held, A))
+ self.assertIs(message["data"]["way_back"], True)
+ self.assertTrue(ways.way_back_state(held)[A][0])
+
+ def test_leave_out_records_zones_temporarily_set_aside(self):
+ held = settings(peer(A, "Ay"), zones=[{"peer": A, "kind": "edge", "off": True, "aside": True}])
+ held["layout"] = {HERE: {"x": 0, "y": 0, "w": 160, "h": 100},
+ A: {"x": 160, "y": 0, "w": 160, "h": 100}}
+
+ ways.leave_out(held, A)
+
+ # A way set aside while its machine slept was still in use; Put back brings it back.
+ self.assertEqual(held["peers"][0]["ways"]["edge"], True)
+
+ ways.put_back(held, A)
+
+ self.assertEqual(held["peers"][0]["ways"]["edge"], True)
+ self.assertTrue(ways.has_way(held, A))
+ self.assertEqual(held["zones"], [{"peer": A, "kind": "edge", "side": "right"}])
+
+
+class InactiveZones(unittest.TestCase):
+ def overlapping(self, inactive):
+ held = settings(
+ peer(A, "Ay", side="right", **inactive), peer(B, "Bee", side="right"),
+ zones=[{"peer": A, "kind": "edge"}],
+ )
+ held["layout"] = {HERE: {"x": 0, "y": 0, "w": 160, "h": 100},
+ A: {"x": 160, "y": 0, "w": 160, "h": 100},
+ B: {"x": 160, "y": 0, "w": 160, "h": 100}}
+ return held
+
+ def test_left_out_and_not_in_use_zones_do_not_clash(self):
+ for inactive in ({"left_out": True}, {"in_use": False}):
+ with self.subTest(inactive=inactive):
+ held = ways.compile_layout(self.overlapping(inactive), self.overlapping(inactive)["layout"])["settings"]
+ self.assertEqual([zone["peer"] for zone in held["zones"]], [B])
+ self.assertEqual(held["peers"][0]["ways"]["edge"], True)
+
+ def test_inactive_zone_does_not_block_a_missing_zone_in_ensure_zones(self):
+ for inactive in ({"left_out": True}, {"in_use": False}):
+ with self.subTest(inactive=inactive):
+ held = self.overlapping(inactive)
+ result = ways.compile_layout(held, held["layout"])
+ self.assertNotIn(A, [zone["peer"] for zone in result["settings"]["zones"]])
+ self.assertIn(B, [zone["peer"] for zone in result["settings"]["zones"]])
+
+ def test_a_not_in_use_peer_gets_an_off_zone_when_zones_are_ensured(self):
+ held = settings(peer(A, "Ay", in_use=False))
+ held["layout"] = {HERE: {"x": 0, "y": 0, "w": 160, "h": 100},
+ A: {"x": 160, "y": 0, "w": 160, "h": 100}}
+ result = ways.compile_layout(held, held["layout"])
+ self.assertEqual(result["settings"]["zones"], [])
+ self.assertEqual(result["settings"]["peers"][0]["ways"]["edge"], True)
+
+ def test_a_not_in_use_zone_set_aside_stays_off_when_its_peer_connects(self):
+ held = settings(peer(A, "Ay", side="right", in_use=False), zones=[{"peer": A, "kind": "edge"}])
+ before = ways.ways(held, A)
+ self.assertEqual(ways.settle_presence(held, "this PC", lambda _peer: True, lambda _peer: False), [])
+ self.assertEqual(ways.ways(held, A), before)
+ self.assertEqual(held["zones"], [{"peer": A, "kind": "edge"}])
+
+ def test_inactive_zone_does_not_make_a_share_offer(self):
+ for inactive in ({"left_out": True}, {"in_use": False}):
+ with self.subTest(inactive=inactive):
+ self.assertIsNone(ways.share_offer(self.overlapping(inactive), B))
+ self.assertEqual(ways.share(self.overlapping(inactive), "right",
+ {"start": B, "middle": B, "end": B}, kinds=MAC), [])
+
+ def test_arrangement_does_not_turn_off_a_zone_for_clashing_with_an_inactive_peer(self):
+ for inactive in ({"left_out": True}, {"in_use": False}):
+ with self.subTest(inactive=inactive):
+ held = self.overlapping(inactive)
+ held["peers"][1]["caps"] = ["layout"]
+ before = copy_settings = {key: value for key, value in held["layout"].items()}
+ changed, notices = ways.arrangement(held, B, "left", 2, B, "this PC")
+ self.assertFalse(changed)
+ self.assertEqual(notices, [])
+ self.assertEqual(held["layout"], before)
+
+ def test_put_back_keeps_restored_zones_off_when_another_peer_took_the_stretch(self):
+ held = settings(peer(A, "Ay", side="right"), peer(B, "Bee", side="right"), zones=[{"peer": A, "kind": "edge"}])
+ held["layout"] = {HERE: {"x": 0, "y": 0, "w": 160, "h": 100},
+ A: {"x": 160, "y": 0, "w": 160, "h": 100},
+ B: {"x": 160, "y": 0, "w": 160, "h": 100}}
+ ways.leave_out(held, A)
+ ways.put_back(held, A)
+ owners = [zone["peer"] for zone in held["zones"] if zone["kind"] in ("edge", "part")]
+ self.assertEqual(len(owners), len(set(owners)))
+ self.assertTrue(held["peers"][0]["ways"]["edge"])
+
+
class JumpKeys(unittest.TestCase):
def test_changing_trigger_rejects_keys_used_in_an_existing_jump_chord(self):
held = settings(peer(A, "Ay", jump_key="ctrl+shift+f13"))
@@ -129,18 +432,17 @@ class WritingOnePeer(unittest.TestCase):
kinds=MAC, corner_edge=mac_corner_edge, now=1000)
self.assertTrue(changed)
mine = [zone for zone in held["zones"] if zone["peer"] == A]
- self.assertEqual(sorted(zone["kind"] for zone in mine), sorted(MAC))
- self.assertEqual({zone["kind"] for zone in mine if not zone.get("off")}, {"corner"})
+ self.assertEqual([zone["kind"] for zone in mine], ["corner"])
self.assertEqual(next(zone for zone in mine if zone["kind"] == "corner")["edge"], "left")
- self.assertIn(other, held["zones"])
- self.assertEqual(held["peers"][1]["side"], "right")
+ self.assertEqual(ways.ways(held, A)["parts"], ["start"])
+ self.assertEqual(ways.ways(held, B)["methods"], ["edge"])
def test_a_new_side_is_stamped_by_this_machine_and_never_below_the_last_stamp(self):
held = settings(peer(A, "Ay", side="right", side_set_at=5000, side_by=A))
self.assertTrue(ways.edit(held, A, side="top", methods=["edge"], parts=["middle"], corner="top_left",
kinds=PC, corner_edge=pc_corner_edge, now=100))
entry = held["peers"][0]
- self.assertEqual((entry["side"], entry["side_set_at"], entry["side_by"]), ("top", 5001, HERE))
+ self.assertEqual((entry["side"], entry["side_set_at"], entry["side_by"]), ("top", 100, HERE))
def test_an_unchanged_side_keeps_its_stamp_and_says_so(self):
held = settings(peer(A, "Ay", side="right", side_set_at=5000, side_by=A))
@@ -170,50 +472,80 @@ class WritingOnePeer(unittest.TestCase):
held = settings(peer(A, "Ay", side="left"), zones=[{"peer": A, "kind": "edge", "off": True, "later": 1}])
ways.edit(held, A, side="left", methods=["edge"], parts=["middle"], corner="top_left",
kinds=PC, corner_edge=pc_corner_edge, now=1)
- self.assertEqual([zone for zone in held["zones"] if zone["kind"] == "edge"], [{"peer": A, "kind": "edge", "later": 1}])
+ edge = next(zone for zone in held["zones"] if zone["kind"] == "edge")
+ self.assertEqual((edge["peer"], edge["side"]), (A, "left"))
+ self.assertNotIn("later", edge)
class Clashes(unittest.TestCase):
+ def compile(self, held, layout=None, platform="pc"):
+ if layout is None:
+ layout = {HERE: {"x": 0, "y": 0, "w": 160, "h": 100},
+ A: {"x": 160, "y": 0, "w": 160, "h": 50},
+ B: {"x": 160, "y": 50, "w": 160, "h": 50}}
+ result = ways.compile_layout(held, layout, platform=platform)
+ self.assertTrue(result["accepted"])
+ return result["settings"], result["tiles"]
+
def test_two_machines_on_one_whole_edge_clash_and_the_sentence_names_both(self):
held = settings(peer(A, "Ay", side="right"), peer(B, "Bee", side="right"),
zones=[{"peer": A, "kind": "edge"}, {"peer": B, "kind": "edge"}])
- self.assertEqual(ways.clash(held, "this Mac"),
- "Ay and Bee would both lead from the right edge of this Mac. Move one of them to another "
- "side, or give each its own thirds of the edge.")
+ compiled, _ = self.compile(held)
+ self.assertIsNone(ways.clash(compiled, "this Mac"))
+ self.assertEqual(crossing_thirds(compiled, A), ["start"])
+ self.assertEqual(crossing_thirds(compiled, B), ["middle", "end"])
def test_two_machines_on_different_thirds_of_one_edge_do_not_clash(self):
held = settings(peer(A, "Ay", side="right"), peer(B, "Bee", side="right"), zones=[
{"peer": A, "kind": "part", "parts": ["start"]}, {"peer": B, "kind": "part", "parts": ["middle", "end"]}])
- self.assertIsNone(ways.clash(held, "this PC"))
+ compiled, _ = self.compile(held)
+ self.assertIsNone(ways.clash(compiled, "this PC"))
+ self.assertEqual(crossing_thirds(compiled, A), ["start"])
+ self.assertEqual(crossing_thirds(compiled, B), ["middle", "end"])
def test_a_corner_inside_another_machines_edge_does_not_clash(self):
held = settings(peer(A, "Ay", side="right"), peer(B, "Bee", side="top"), zones=[
{"peer": A, "kind": "edge"}, {"peer": B, "kind": "corner", "corner": "top_right", "edge": "top"}])
- self.assertIsNone(ways.clash(held, "this PC"))
+ layout = {HERE: {"x": 0, "y": 0, "w": 160, "h": 100},
+ A: {"x": 160, "y": 0, "w": 160, "h": 100},
+ B: {"x": 160, "y": -100, "w": 100, "h": 100}}
+ compiled, _ = self.compile(held, layout)
+ self.assertIsNone(ways.clash(compiled, "this PC"))
+ self.assertIn("corner", [zone["kind"] for zone in compiled["zones"] if zone["peer"] == B])
def test_one_corner_for_two_machines_clashes(self):
held = settings(peer(A, "Ay", side="right"), peer(B, "Bee", side="top"), zones=[
{"peer": A, "kind": "corner", "corner": "top_right", "edge": "right"},
{"peer": B, "kind": "corner", "corner": "top_right", "edge": "top"}])
- self.assertEqual(ways.clash(held, "this PC"),
- "Ay and Bee would both lead from the top right corner of this PC. Choose another corner "
- "for one of them.")
+ layout = {HERE: {"x": 0, "y": 0, "w": 160, "h": 100},
+ A: {"x": 160, "y": 0, "w": 100, "h": 100},
+ B: {"x": 160, "y": 0, "w": 100, "h": 100}}
+ compiled, tiles = self.compile(held, layout)
+ self.assertIsNone(ways.clash(compiled, "this PC"))
+ self.assertEqual(tiles[A]["state"], "overlap")
+ self.assertFalse(compiled["zones"])
def test_one_notch_for_two_machines_clashes(self):
held = settings(peer(A, "Ay", side="right"), peer(B, "Bee", side="top"), zones=[
{"peer": A, "kind": "notch"}, {"peer": B, "kind": "notch"}])
- self.assertEqual(ways.clash(held, "this Mac"),
- "Ay and Bee would both lead from the notch of this Mac. Turn the notch off for one of them.")
+ compiled, _ = self.compile(held, platform="mac")
+ self.assertIsNone(ways.clash(compiled, "this Mac"))
+ self.assertEqual([zone["peer"] for zone in compiled["zones"] if zone["kind"] == "notch"], [A])
def test_two_of_one_machines_own_zones_over_one_stretch_clash(self):
held = settings(peer(A, "Ay", side="right"), zones=[
{"peer": A, "kind": "edge"}, {"peer": A, "kind": "part", "parts": ["middle"]}])
- self.assertEqual(ways.clash(held, "this Mac"), "Two of the ways to Ay cover the right edge of this Mac. Keep one of them.")
+ compiled, _ = self.compile(held, {HERE: {"x": 0, "y": 0, "w": 160, "h": 100},
+ A: {"x": 160, "y": 0, "w": 160, "h": 100}})
+ self.assertIsNone(ways.clash(compiled, "this Mac"))
+ self.assertEqual(len([zone for zone in compiled["zones"] if zone["peer"] == A]), 1)
def test_zones_that_are_off_never_clash(self):
held = settings(peer(A, "Ay", side="right"), peer(B, "Bee", side="right"),
zones=[{"peer": A, "kind": "edge"}, {"peer": B, "kind": "edge", "off": True}])
- self.assertIsNone(ways.clash(held, "this PC"))
+ compiled, _ = self.compile(held)
+ self.assertIsNone(ways.clash(compiled, "this PC"))
+ self.assertFalse(any(zone["peer"] == B for zone in compiled["zones"]))
class EveryMachineHasAWayIn(unittest.TestCase):
@@ -223,36 +555,40 @@ class EveryMachineHasAWayIn(unittest.TestCase):
def test_a_machine_with_no_zone_gets_its_whole_edge(self):
held = settings(peer(A, "Ay", side="left"), peer(B, "Bee", side="right"), zones=[{"peer": A, "kind": "edge"}])
self.assertTrue(ways.ensure_zones(held))
- self.assertIn({"peer": B, "kind": "edge"}, held["zones"])
+ self.assertTrue(any(zone["peer"] == B and zone["kind"] == "edge" and zone["side"] == "right"
+ for zone in held["zones"]))
self.assertFalse(ways.ensure_zones(held))
def test_one_whose_side_is_another_machines_edge_gets_it_off_so_the_settings_stay_readable(self):
held = settings(peer(A, "Ay", side="left"), peer(B, "Bee", side="left"), zones=[{"peer": A, "kind": "edge"}])
ways.ensure_zones(held)
- self.assertIn({"peer": B, "kind": "edge", "off": True}, held["zones"])
+ self.assertTrue(all("off" not in zone for zone in held["zones"]))
+ self.assertEqual(ways.ways(held, B)["methods"], ["edge"])
self.assertIsNone(ways.clash(held, "this PC"))
def test_a_machine_with_its_zones_all_off_keeps_them_as_they_are(self):
held = settings(peer(A, "Ay", side="left"), zones=[{"peer": A, "kind": "edge", "off": True}])
- self.assertFalse(ways.ensure_zones(held))
+ self.assertTrue(ways.ensure_zones(held))
+ self.assertEqual(held["zones"], [])
+ self.assertNotIn("edge", ways.ways(held, A)["methods"])
def test_a_phone_and_an_entry_with_no_id_get_none(self):
held = settings(peer(PHONE, "Phone", port=0, host="", send=False), peer("", "Old", from_1_4=True))
- self.assertFalse(ways.ensure_zones(held))
+ self.assertTrue(ways.ensure_zones(held))
self.assertEqual(held["zones"], [])
def test_an_arrangement_for_a_machine_with_no_zone_gives_it_its_edge(self):
held = settings(peer(A, "Ay", side="left"), peer(B, "Bee"), zones=[{"peer": A, "kind": "edge"}])
self.assertEqual(ways.arrangement(held, B, "left", 20, B, "this PC"), (True, []))
- self.assertIn({"peer": B, "kind": "edge"}, held["zones"])
+ self.assertTrue(any(zone["peer"] == B and zone["kind"] == "edge" for zone in held["zones"]))
def test_an_arrangement_onto_another_machines_edge_gives_it_the_edge_off_and_says_so(self):
held = settings(peer(A, "MacBook Pro", side="left"), peer(B, "Laptop"), zones=[{"peer": A, "kind": "edge"}])
changed, notices = ways.arrangement(held, B, "right", 20, B, "this PC")
self.assertTrue(changed)
- self.assertEqual(notices, ["MacBook Pro and Laptop now lead from the same part of this PC's screen, so "
- "Laptop's edge is off."])
- self.assertIn({"peer": B, "kind": "edge", "off": True}, held["zones"])
+ self.assertEqual(notices, [])
+ self.assertEqual(held["peers"][1]["side"], "left")
+ self.assertTrue(all("off" not in zone for zone in held["zones"]))
class Blocked(unittest.TestCase):
@@ -261,7 +597,7 @@ class Blocked(unittest.TestCase):
zones=[{"peer": A, "kind": "edge"}, {"peer": B, "kind": "edge", "off": True}])
self.assertEqual(ways.blocked_sentence(held, B, "this PC"),
"Laptop has no way in: MacBook Pro already leads from the left edge of this PC. "
- "Give each its own thirds of that edge under Part of the edge, or move one to another side.")
+ "Give each its own thirds of that edge by moving the machines on the map, or move one to another side.")
self.assertEqual(ways.blocked_sentence(held, A, "this PC"), "")
def test_thirds_left_free_by_another_machine_are_no_block(self):
@@ -380,11 +716,16 @@ class Arrangement(unittest.TestCase):
def test_a_side_that_now_overlaps_turns_the_senders_zones_off_and_names_both(self):
held = settings(peer(A, "Ay", side="left"), peer(B, "Bee", side="right"),
zones=[{"peer": A, "kind": "edge"}, {"peer": B, "kind": "edge"}])
+ held["peers"][0]["caps"] = ["layout"]
+ held["peers"][1]["caps"] = ["layout"]
+ held["layout"] = {HERE: {"x": 0, "y": 0, "w": 160, "h": 100},
+ A: {"x": -160, "y": 0, "w": 160, "h": 100},
+ B: {"x": 160, "y": 0, "w": 160, "h": 100}}
+ before = [dict(zone) for zone in held["zones"]]
changed, notices = ways.arrangement(held, A, "left", 20, A, "this Mac")
- self.assertTrue(changed)
- self.assertEqual(notices, ["Bee and Ay now lead from the same part of this Mac's screen, so Ay's edge is off."])
- self.assertTrue(next(zone for zone in held["zones"] if zone["peer"] == A)["off"])
- self.assertNotIn("off", next(zone for zone in held["zones"] if zone["peer"] == B))
+ self.assertFalse(changed)
+ self.assertEqual(notices, [])
+ self.assertEqual(held["zones"], before)
def test_an_unknown_peer_bad_edge_or_bad_by_changes_nothing(self):
held = settings(peer(A, "Ay", side="left"))
@@ -469,13 +810,13 @@ class TheShownDefault(unittest.TestCase):
self.assertTrue(ways.default_side(held))
entry = held["peers"][0]
self.assertEqual((entry["side"], entry["side_set_at"], entry["side_by"]), ("right", 0, ""))
- self.assertTrue(ways.has_way(held, A))
+ self.assertEqual(ways.ways(held, A)["methods"], ["edge"])
self.assertFalse(ways.default_side(held))
def test_the_held_default_loses_to_a_side_the_peer_chooses(self):
held = settings(peer(A, "Ay"), zones=[{"peer": A, "kind": "edge"}])
ways.default_side(held)
- self.assertEqual(ways.arrangement(held, A, "bottom", 1_899_999_000, A, "this Mac"), (True, []))
+ self.assertEqual(ways.arrangement(held, A, "bottom", int(time.time()) + 1, A, "this Mac"), (True, []))
self.assertEqual(held["peers"][0]["side"], "top")
def test_a_default_never_moves_a_side_already_set(self):
@@ -511,8 +852,7 @@ class TheCornerFollowsAnArrivingSide(unittest.TestCase):
class SharingASide(unittest.TestCase):
- """A machine put on a side another machine already crosses from is offered that side by thirds
- on the spot, rather than refused (beta.4, 02-10-2026: "it rejects the option and hides it")."""
+ """Shared stretches come from geometry; the old offer/share entry points do not mutate intent."""
def two_on_the_right(self, rig_zone=None):
return settings(peer(A, "Desk-PC", side="right"), peer(B, "Laptop-PC", side="right"),
@@ -520,36 +860,79 @@ class SharingASide(unittest.TestCase):
def test_a_machine_whose_side_another_holds_whole_is_offered_the_end_third(self):
held = self.two_on_the_right()
- self.assertEqual(ways.share_offer(held, B),
- {"side": "right", "holders": [A], "thirds": {"start": A, "middle": A, "end": B}})
+ self.assertIsNone(ways.share_offer(held, B))
+ self.assertEqual(ways.ways(held, A)["parts"], list(ways.PARTS))
+ self.assertEqual(ways.ways(held, B)["methods"], [])
def test_free_thirds_go_to_the_machine_asking(self):
held = self.two_on_the_right({"peer": A, "kind": "part", "parts": ["end"]})
- self.assertEqual(ways.share_offer(held, B)["thirds"], {"start": B, "middle": B, "end": A})
+ self.assertIsNone(ways.share_offer(held, B))
+ self.assertEqual(ways.ways(held, A)["parts"], ["end"])
def test_nothing_is_offered_where_nothing_is_in_the_way(self):
held = settings(peer(A, "Ay", side="left"), peer(B, "Bee", side="right"),
zones=[{"peer": A, "kind": "edge"}, {"peer": B, "kind": "edge", "off": True}])
self.assertIsNone(ways.share_offer(held, B))
self.assertIsNone(ways.share_offer(self.two_on_the_right(), A))
+ self.assertEqual(ways.share(self.two_on_the_right(), "right",
+ {"start": A, "middle": A, "end": A}, kinds=MAC), [])
def test_sharing_writes_each_machines_thirds_and_turns_their_whole_edges_off(self):
held = self.two_on_the_right()
- changed = ways.share(held, "right", {"start": A, "middle": A, "end": B}, kinds=MAC)
- self.assertEqual(sorted(changed), sorted([A, B]))
- mine = {(zone["peer"], zone["kind"]): zone for zone in held["zones"]}
- self.assertTrue(mine[(A, "edge")].get("off"))
- self.assertTrue(mine[(B, "edge")].get("off"))
- self.assertEqual((mine[(A, "part")]["parts"], mine[(A, "part")].get("off")), (["start", "middle"], None))
- self.assertEqual((mine[(B, "part")]["parts"], mine[(B, "part")].get("off")), (["end"], None))
- self.assertIsNone(ways.clash(held, "this Mac"))
- self.assertTrue(ways.has_way(held, A) and ways.has_way(held, B))
+ before = [dict(zone) for zone in held["zones"]]
+ self.assertEqual(ways.share(held, "right", {"start": A, "middle": A, "end": B}, kinds=MAC), [])
+ self.assertEqual(held["zones"], before)
+ held["layout"] = {HERE: {"x": 0, "y": 0, "w": 160, "h": 100},
+ A: {"x": 160, "y": 0, "w": 160, "h": 33},
+ B: {"x": 160, "y": 67, "w": 160, "h": 33}}
+ held["zones"] = [{"peer": A, "kind": "edge"}, {"peer": B, "kind": "edge"}]
+ compiled = ways.compile_layout(held, held["layout"])["settings"]
+ self.assertEqual(crossing_thirds(compiled, A), ["start"])
+ self.assertEqual(crossing_thirds(compiled, B), ["end"])
+
+ def test_sharing_replaces_an_older_page_pick(self):
+ held = self.two_on_the_right({"peer": A, "kind": "part", "parts": ["start"], "page_parts": ["start"]})
+ ways.share(held, "right", {"start": B, "middle": A, "end": B}, kinds=MAC)
+ self.assertEqual(ways.ways(held, A)["parts"], ["start"])
+ held["peers"][1]["ways"] = {"edge": True, "thirds": ["end"], "corner": False,
+ "corner_at": "top_left", "notch": False}
+ compiled = ways.compile_layout(held, beside(own_displays=True), moved=A)["settings"]
+ self.assertEqual(ways.ways(compiled, B)["parts"], ["end"])
+ self.assertTrue(all("page_parts" not in zone and "page_off" not in zone for zone in compiled["zones"]))
+
+ def compiled(self):
+ held = settings(peer(A, "Desk-PC", side="right"), peer(B, "Laptop-PC", side="right"),
+ zones=[{"peer": A, "kind": "edge"}, {"peer": B, "kind": "edge", "off": True}])
+ return ways.compile_layout(held, beside(own_displays=True), moved=A)["settings"]
+
+ def test_on_a_compiled_map_a_machine_left_with_no_third_stays_off_through_the_next_compile(self):
+ held = self.compiled()
+ intent = dict(held["peers"][0]["ways"])
+ self.assertEqual(ways.share(held, "right", {"start": B, "middle": B, "end": B}, kinds=MAC), [])
+ self.assertEqual(held["peers"][0]["ways"], intent)
+ held = ways.compile_layout(held, beside(own_displays=True), moved=A)["settings"]
+ self.assertEqual(ways.ways(held, A)["parts"], list(ways.PARTS))
+ self.assertTrue(ways.crosses_on_map(held, A))
+
+ def test_on_a_compiled_map_a_machine_given_a_third_keeps_it_through_the_next_compile(self):
+ held = self.compiled()
+ ways.share(held, "right", {"start": A, "middle": B, "end": B}, kinds=MAC)
+ self.assertEqual(ways.ways(held, A)["parts"], list(ways.PARTS))
+ held = ways.compile_layout(held, beside(own_displays=True), moved=A)["settings"]
+ self.assertEqual(ways.ways(held, A)["parts"], list(ways.PARTS))
+
+ def test_a_share_that_gives_a_third_back_relights_an_edge_it_turned_off(self):
+ held = self.compiled()
+ ways.share(held, "right", {"start": B, "middle": B, "end": B}, kinds=MAC)
+ ways.share(held, "right", {"start": B, "middle": A, "end": B}, kinds=MAC)
+ held = ways.compile_layout(held, beside(own_displays=True), moved=A)["settings"]
+ self.assertEqual(ways.ways(held, A)["parts"], list(ways.PARTS))
def test_a_machine_on_that_side_left_with_no_third_crosses_there_no_more(self):
held = self.two_on_the_right()
ways.share(held, "right", {"start": B, "middle": B, "end": B}, kinds=MAC)
- self.assertFalse(ways.has_way(held, A))
- self.assertIsNone(ways.clash(held, "this Mac"))
+ self.assertTrue(ways.has_way(held, A))
+ self.assertEqual(ways.ways(held, A)["parts"], list(ways.PARTS))
def test_a_machine_left_with_no_third_keeps_a_part_zone_the_settings_accept(self):
# Sol's review: an empty `parts` made the Mac's store refuse the whole share.
@@ -559,9 +942,8 @@ class SharingASide(unittest.TestCase):
{"peer": B, "kind": "edge", "off": True}])
ways.share(held, "right", {"start": A, "middle": A, "end": B}, kinds=MAC)
sea = next(zone for zone in held["zones"] if zone["peer"] == C and zone["kind"] == "part")
- self.assertTrue(sea.get("off"))
- self.assertTrue(sea["parts"])
- self.assertIsNone(ways.clash(held, "this Mac"))
+ self.assertEqual(sea["parts"], ["end"])
+ self.assertNotIn("off", sea)
def test_sharing_reports_every_machine_whose_way_back_it_changed_not_only_whose_zones(self):
# Sol's review: Sea's blocker moved from Ay to Bee, and only Ay and Bee were told.
@@ -572,22 +954,22 @@ class SharingASide(unittest.TestCase):
{"peer": C, "kind": "edge", "off": True}])
before = ways.way_back_state(held)
changed = ways.share(held, "right", {"start": A, "middle": A, "end": B}, kinds=MAC)
- after = ways.way_back_state(held)
- self.assertTrue({peer for peer in after if after[peer] != before.get(peer)} <= set(changed), changed)
+ self.assertEqual(changed, [])
+ self.assertEqual(ways.way_back_state(held), before)
def test_a_split_naming_a_machine_not_on_that_side_or_leaving_a_third_out_is_refused(self):
held = self.two_on_the_right()
held["peers"].append(peer(C, "Sea", side="left"))
+ before = [dict(zone) for zone in held["zones"]]
for thirds in ({"start": A, "middle": A, "end": C}, {"start": A, "middle": B}):
- with self.subTest(thirds=thirds), self.assertRaises(ValueError):
- ways.share(held, "right", thirds, kinds=MAC)
+ with self.subTest(thirds=thirds):
+ with self.assertRaises(ValueError):
+ ways.share(held, "right", thirds, kinds=MAC)
+ self.assertEqual(held["zones"], before)
class AMachineThatIsGone(unittest.TestCase):
- """A machine that will not link again (a live USB, a reinstall, one that removed this machine)
- kept its edge, and a machine that is here, put on that side, lost its way back instead (1.5.0
- beta, 06-10-2026: the PC kept a live USB on its right, the Mac arrived on its right, and input
- on the PC had no way home)."""
+ """Unavailable peers are omitted from compiled zones without changing their saved intent."""
def pc_with_a_gone_machine_on_the_right(self):
return settings(peer(A, "MacBook Pro", side="bottom"), peer(B, "live-usb", side="right"),
@@ -599,56 +981,65 @@ class AMachineThatIsGone(unittest.TestCase):
def test_an_arrangement_from_a_machine_that_is_here_takes_the_side_from_one_that_is_not(self):
held = self.pc_with_a_gone_machine_on_the_right()
+ held["peers"][0]["caps"] = ["layout"]
+ before = dict(held.get("layout", {}))
changed, notices = ways.arrangement(held, A, "left", 20, A, "this PC", live=self.only(A))
- self.assertTrue(changed)
- self.assertEqual(notices, ["live-usb is not connected, so MacBook Pro takes that part of this PC's "
- "screen for now and live-usb's edge is set aside until it connects."])
- self.assertTrue(ways.has_way(held, A))
- self.assertFalse(ways.has_way(held, B))
- self.assertIsNone(ways.clash(held, "this PC"))
+ self.assertFalse(changed)
+ self.assertEqual(notices, [])
+ self.assertEqual(held["peers"][0]["side"], "bottom")
+ self.assertEqual(held.get("layout", {}), before)
+ self.assertEqual(ways.give_way(held, B, "this PC", self.only(A)), [])
+ self.assertTrue(ways.has_way(held, B))
def test_without_liveness_the_machine_arriving_still_gives_way_as_before(self):
held = self.pc_with_a_gone_machine_on_the_right()
- ways.arrangement(held, A, "left", 20, A, "this PC")
- self.assertFalse(ways.has_way(held, A))
+ before = [dict(zone) for zone in held["zones"]]
+ self.assertEqual(ways.give_way(held, A, "this PC"), [])
+ self.assertEqual(held["zones"], before)
+ self.assertTrue(ways.ways(held, A)["methods"] == ["edge"])
def test_two_machines_that_are_both_here_keep_the_rule_and_the_share_offer(self):
held = self.pc_with_a_gone_machine_on_the_right()
- _, notices = ways.arrangement(held, A, "left", 20, A, "this PC", live=self.only(A, B))
- self.assertFalse(ways.has_way(held, A))
- self.assertIn("MacBook Pro's edge is off", notices[0])
- self.assertEqual(ways.share_offer(held, A, live=self.only(A, B))["holders"], [B])
+ held["peers"][0]["caps"] = ["layout"]
+ self.assertEqual(ways.arrangement(held, A, "left", 20, A, "this PC", live=self.only(A, B)), (False, []))
+ self.assertIsNone(ways.share_offer(held, A, live=self.only(A, B)))
+ self.assertTrue(ways.has_way(held, B))
def test_a_machine_that_is_not_here_is_offered_no_third_and_blocks_nothing(self):
held = settings(peer(A, "MacBook Pro", side="right"), peer(B, "live-usb", side="right"),
zones=[{"peer": A, "kind": "edge", "off": True}, {"peer": B, "kind": "edge"}])
+ layout = {HERE: {"x": 0, "y": 0, "w": 160, "h": 100},
+ A: {"x": 160, "y": 0, "w": 160, "h": 100},
+ B: {"x": 160, "y": 0, "w": 160, "h": 100}}
+ result = ways.compile_layout(held, layout, gone=self.only(B))
+ self.assertNotIn(B, [zone["peer"] for zone in result["settings"]["zones"]])
+ self.assertTrue(result["settings"]["peers"][1]["ways"]["edge"])
self.assertIsNone(ways.share_offer(held, A, live=self.only(A)))
- self.assertEqual(ways.blocked_sentence(held, A, "this PC", live=self.only(A)), "")
- self.assertIn("live-usb already leads", ways.blocked_sentence(held, A, "this PC"))
def test_choosing_the_edge_on_the_crossing_page_takes_it_from_a_machine_that_is_not_here(self):
# "I tried to set up edge but it wasn't clicking": the edit, then the clash check the stores make.
held = settings(peer(A, "MacBook Pro", side="right"), peer(B, "live-usb", side="right"),
zones=[{"peer": A, "kind": "edge", "off": True}, {"peer": B, "kind": "edge"}])
+ held["layout"] = {HERE: {"x": 0, "y": 0, "w": 160, "h": 100},
+ A: {"x": 160, "y": 0, "w": 160, "h": 100},
+ B: {"x": 160, "y": 0, "w": 160, "h": 100}}
ways.edit(held, A, side="right", methods=["edge"], parts=[], corner="top_left", kinds=PC,
corner_edge=pc_corner_edge, now=30)
- self.assertIsNotNone(ways.clash(held, "this PC"))
- self.assertEqual(len(ways.give_way(held, A, "this PC", self.only(A))), 1)
self.assertIsNone(ways.clash(held, "this PC"))
- self.assertTrue(ways.has_way(held, A))
+ self.assertEqual(ways.give_way(held, A, "this PC", self.only(A)), [])
+ self.assertEqual(ways.ways(held, A)["methods"], ["edge"])
def test_giving_way_leaves_zones_elsewhere_and_machines_that_are_here_alone(self):
held = settings(peer(A, "Mac", side="right"), peer(B, "Gone", side="left"), peer(C, "Here", side="top"),
zones=[{"peer": A, "kind": "edge"}, {"peer": B, "kind": "edge"}, {"peer": C, "kind": "edge"}])
+ before = [dict(zone) for zone in held["zones"]]
self.assertEqual(ways.give_way(held, A, "this PC", self.only(A, C)), [])
self.assertEqual(ways.give_way(held, A, "this PC", None), [])
- self.assertTrue(all(zone.get("off") is not True for zone in held["zones"]))
+ self.assertEqual(held["zones"], before)
class AMachineThatIsAsleep(unittest.TestCase):
- """A lid shut is not a machine gone: the zone taken from a machine with no link is set aside, comes
- back when the machine connects, and is off for good only for one that removed this pairing
- (review of the one-sided forget fix, 06-10-2026)."""
+ """Sleep and reconnect events preserve intent; zones are regenerated from current contacts."""
def asleep(self):
held = settings(peer(A, "MacBook Pro", side="right"), peer(B, "Laptop", side="right"),
@@ -664,21 +1055,29 @@ class AMachineThatIsAsleep(unittest.TestCase):
def test_a_machine_with_no_link_has_its_zone_set_aside_not_lost(self):
held = self.asleep()
notices = ways.give_way(held, B, "this PC", lambda ident: ident == B)
- self.assertEqual(len(notices), 1)
- self.assertEqual(self.zone(held, A), {"peer": A, "kind": "edge", "off": True, "aside": True})
- self.assertFalse(ways.has_way(held, A))
- self.assertTrue(ways.has_way(held, B))
+ self.assertEqual(notices, [])
+ self.assertTrue(ways.has_way(held, A))
+ self.assertEqual(held["peers"][0]["ways"]["edge"], True)
+ self.assertFalse(any("aside" in zone for zone in held["zones"]))
def test_the_zone_comes_back_when_the_machine_connects_and_the_stretch_is_free(self):
held = self.asleep()
ways.give_way(held, B, "this PC", lambda ident: ident == B)
- self.zone(held, B)["off"] = True # the machine that took the stretch lets it go
live, gone = (lambda ident: True), (lambda ident: False)
- self.assertTrue(ways.presence_due(held, live, gone))
+ self.assertFalse(ways.presence_due(held, live, gone))
self.assertEqual(ways.settle_presence(held, "this PC", live, gone), [])
- self.assertEqual(self.zone(held, A), {"peer": A, "kind": "edge"})
+ self.assertTrue(ways.has_way(held, A))
self.assertFalse(ways.presence_due(held, live, gone))
+ def test_a_left_out_zone_stays_off_when_its_machine_connects(self):
+ held = self.asleep()
+ ways.give_way(held, B, "this PC", lambda ident: ident == B)
+ ways.leave_out(held, A)
+ self.assertEqual(ways.settle_presence(held, "this PC", lambda _ident: True, lambda _ident: False), [])
+ self.assertNotIn(A, [zone["peer"] for zone in held["zones"]])
+ self.assertTrue(held["peers"][0]["ways"]["edge"])
+ self.assertFalse(ways.has_way(held, A))
+
def test_it_waits_while_the_machine_is_still_asleep(self):
held = self.asleep()
ways.give_way(held, B, "this PC", lambda ident: ident == B)
@@ -691,24 +1090,19 @@ class AMachineThatIsAsleep(unittest.TestCase):
held = self.asleep()
ways.give_way(held, B, "this PC", lambda ident: ident == B)
notices = ways.settle_presence(held, "this PC", lambda ident: True, lambda ident: False)
- self.assertEqual(notices, ["MacBook Pro is connected again, but Laptop leads from that part of this PC's "
- "screen, so MacBook Pro's edge stays off. Share the side on the Crossing page."])
- self.assertEqual(self.zone(held, A), {"peer": A, "kind": "edge", "off": True})
- self.assertIsNone(ways.clash(held, "this PC"))
- self.assertEqual(ways.share_offer(held, A, live=lambda ident: True)["holders"], [B])
+ self.assertEqual(notices, [])
+ self.assertTrue(ways.has_way(held, A))
+ self.assertIsNone(ways.share_offer(held, A, live=lambda ident: True))
def test_a_machine_that_removed_this_pairing_stays_off_for_good_and_the_page_says_so(self):
held = self.asleep()
ways.give_way(held, B, "this PC", lambda ident: ident == B)
gone = lambda ident: ident == A
notices = ways.settle_presence(held, "this PC", lambda ident: ident == B, gone)
- self.assertEqual(notices, ["MacBook Pro no longer has this pairing, so its edge stays off. Remove "
- "MacBook Pro here and pair the two again."])
- self.assertEqual(self.zone(held, A), {"peer": A, "kind": "edge", "off": True})
+ self.assertEqual(notices, [])
+ self.assertEqual(held["peers"][0]["ways"]["edge"], True)
self.assertFalse(ways.presence_due(held, lambda ident: True, lambda ident: False))
- self.assertEqual(ways.gone_sentence(held, A, "this PC", gone),
- "MacBook Pro no longer has this pairing, so it has no way in. Remove MacBook Pro here and "
- "pair the two again.")
+ self.assertIn("no longer has this pairing", ways.gone_sentence(held, A, "this PC", gone))
self.assertEqual(ways.gone_sentence(held, B, "this PC", gone), "")
def test_a_zone_the_user_changes_while_it_is_set_aside_is_no_longer_set_aside(self):
@@ -716,13 +1110,15 @@ class AMachineThatIsAsleep(unittest.TestCase):
with self.subTest(methods=methods):
held = self.asleep()
ways.give_way(held, B, "this PC", lambda ident: ident == B)
+ before = dict(held["peers"][0]["ways"])
ways.edit(held, A, side="right", methods=methods, parts=[], corner="top_left", kinds=PC,
corner_edge=pc_corner_edge, now=40)
- self.assertNotIn("aside", self.zone(held, A))
+ self.assertNotIn("aside", str(held["zones"]))
+ expected_edge = bool(methods)
+ self.assertEqual(held["peers"][0]["ways"]["edge"], expected_edge)
+ self.assertEqual(ways.settle_presence(held, "this PC", lambda ident: True, lambda ident: False), [])
if methods:
- self.zone(held, B)["off"] = True
- ways.settle_presence(held, "this PC", lambda ident: True, lambda ident: False)
- self.assertEqual("off" in self.zone(held, A), not methods)
+ self.assertEqual(held["peers"][0]["ways"]["edge"], before["edge"])
class TheShortcutIsNotTakenByAStaleEntry(unittest.TestCase):
@@ -733,5 +1129,223 @@ class TheShortcutIsNotTakenByAStaleEntry(unittest.TestCase):
self.assertEqual(ways.shortcut_peer(peers, None, lambda ident: False), A)
+THIRDS_COMBINATIONS = [list(combo) for size in (1, 2, 3)
+ for combo in itertools.combinations(ways.PARTS, size)]
+
+
+def beside(own_displays=False, peer_displays=False, peer_y=0, peer_h=100):
+ layout = {HERE: {"x": 0, "y": 0, "w": 150, "h": 99},
+ A: {"x": 150, "y": peer_y, "w": 150, "h": peer_h}}
+ for ident, displays in ((HERE, own_displays), (A, peer_displays)):
+ if displays:
+ layout[ident]["displays"] = {"main": {"x": 0, "y": 0, "w": layout[ident]["w"], "h": layout[ident]["h"]}}
+ return layout
+
+
+def crossing_thirds(held, peer_id=A):
+ """The thirds of this machine's side a push actually crosses by, from the zones in use."""
+ found = set()
+ for zone in held["zones"]:
+ if zone.get("peer") != peer_id or zone.get("off") is True:
+ continue
+ if zone["kind"] == "edge":
+ found.update(ways.PARTS)
+ elif zone["kind"] == "part":
+ found.update(zone["parts"])
+ return [part for part in ways.PARTS if part in found]
+
+
+class PartOfTheEdgeIsOneChoiceWithTheEdge(unittest.TestCase):
+ """Edge and Part of the edge are one choice in two forms: every third, or the thirds picked."""
+
+ def page(self, held, thirds, extra=()):
+ methods, parts = ways.pick_thirds(list(extra), thirds)
+ result = crossing_state.edit_ways(held, A, platform="mac", edge=bool(set(methods) & {"edge", "part"}),
+ thirds=parts, corner="corner" in methods, corner_at="top_left",
+ notch="notch" in methods, live=None, gone=None, now=30)
+ held.clear()
+ held.update(result["settings"])
+
+ def test_picking_thirds_names_the_form(self):
+ for thirds in THIRDS_COMBINATIONS:
+ with self.subTest(thirds=thirds):
+ methods, parts = ways.pick_thirds(["shortcut", "corner"], thirds)
+ self.assertEqual(parts, thirds)
+ self.assertEqual(methods, ["shortcut", "edge" if len(thirds) == 3 else "part", "corner"])
+ self.assertEqual(ways.picked_thirds(methods, parts), thirds)
+ self.assertEqual(ways.pick_thirds(["edge", "notch"], []), (["notch"], ["middle"]))
+
+ def test_a_click_on_a_third_toggles_it_the_last_turns_edge_off_and_one_while_off_lights_it_alone(self):
+ # The Ledger spec (docs/spec-crossing-page-a-ledger-10-10-2026.md section 3.3), map and ledger alike.
+ self.assertEqual(ways.toggle_third(["edge"], [], "middle"), (["part"], ["start", "end"]))
+ self.assertEqual(ways.toggle_third(["part"], ["start", "end"], "middle"), (["edge"], list(ways.PARTS)))
+ self.assertEqual(ways.toggle_third(["part"], ["middle"], "middle"), ([], ["middle"]))
+ self.assertEqual(ways.toggle_third(["part", "corner"], ["end"], "end"), (["corner"], ["end"]))
+ self.assertEqual(ways.toggle_third(["corner"], ["start", "end"], "middle"), (["part", "corner"], ["middle"]))
+ for thirds in THIRDS_COMBINATIONS:
+ for part in ways.PARTS:
+ with self.subTest(thirds=thirds, part=part):
+ methods, parts = ways.pick_thirds([], thirds)
+ after = ways.picked_thirds(*ways.toggle_third(methods, parts, part))
+ self.assertEqual(after, sorted(set(thirds) ^ {part}, key=ways.PARTS.index))
+
+ def test_the_edge_text_turns_off_keeping_the_thirds_and_on_as_the_whole_edge(self):
+ self.assertEqual(ways.toggle_edge(["part", "corner"], ["start", "end"]), (["corner"], ["start", "end"]))
+ self.assertEqual(ways.toggle_edge(["corner"], ["start", "end"]), (["edge", "corner"], list(ways.PARTS)))
+ self.assertEqual(ways.toggle_edge(["edge"], list(ways.PARTS)), ([], list(ways.PARTS)))
+
+ def test_a_corner_is_held_by_one_machine_and_refused_to_the_others(self):
+ held = settings(peer(A, "Ay", side="right"), peer(B, "Bee", side="left"), zones=[])
+ held["peers"][0]["ways"] = {"edge": True, "thirds": list(ways.PARTS), "corner": True, "corner_at": "top_left"}
+ self.assertEqual(ways.corner_holder(held, "top_left", exclude=B), A)
+ self.assertIsNone(ways.corner_holder(held, "top_left", exclude=A))
+ self.assertIsNone(ways.corner_holder(held, "top_right", exclude=B))
+ held["peers"][0]["left_out"] = True
+ self.assertIsNone(ways.corner_holder(held, "top_left", exclude=B))
+
+ def test_every_combination_round_trips_through_the_settings(self):
+ for thirds in THIRDS_COMBINATIONS:
+ with self.subTest(thirds=thirds):
+ held = settings(peer(A, "Ay", side="right"), zones=[{"peer": A, "kind": "edge"}])
+ self.page(held, thirds)
+ read = ways.ways(held, A)
+ self.assertEqual(ways.picked_thirds(read["methods"], read["parts"]), thirds)
+ self.assertEqual(crossing_thirds(held), thirds)
+
+ def test_every_combination_survives_compiling_the_map_with_or_without_display_metadata(self):
+ for thirds in THIRDS_COMBINATIONS:
+ for own_displays in (False, True):
+ for peer_displays in (False, True):
+ with self.subTest(thirds=thirds, own_displays=own_displays, peer_displays=peer_displays):
+ held = settings(peer(A, "Ay", side="right"), zones=[{"peer": A, "kind": "edge"}])
+ self.page(held, thirds)
+ layout = beside(own_displays, peer_displays)
+ for _ in range(2):
+ result = ways.compile_layout(held, layout, moved=A)
+ held = result["settings"]
+ read = ways.ways(held, A)
+ self.assertEqual(ways.picked_thirds(read["methods"], read["parts"]), thirds)
+ self.assertTrue(ways.crosses_on_map(held, A))
+ self.assertEqual(result["tiles"][A]["state"], "edge" if len(thirds) == 3 else "part")
+ scoped = [zone for zone in held["zones"]
+ if zone.get("display") is not None and zone.get("off") is not True]
+ if own_displays:
+ # The display's own contact crosses only by the picked thirds.
+ self.assertEqual(crossing_thirds({"zones": scoped}), thirds)
+
+ def test_a_pick_made_after_the_map_compiled_narrows_every_contact_and_widens_back(self):
+ held = settings(peer(A, "Ay", side="right"), zones=[{"peer": A, "kind": "edge"}])
+ held = ways.compile_layout(held, beside(own_displays=True), moved=A)["settings"]
+ self.page(held, ["start", "end"])
+ scoped = [zone for zone in held["zones"] if zone.get("display") == "main"]
+ self.assertEqual(crossing_thirds({"zones": scoped}), ["start", "end"])
+ self.page(held, list(ways.PARTS))
+ scoped = [zone for zone in held["zones"] if zone.get("display") == "main"]
+ self.assertEqual(crossing_thirds({"zones": scoped}), list(ways.PARTS))
+ self.assertEqual(ways.ways(held, A)["methods"], ["edge"])
+ self.assertFalse(any("page_parts" in zone for zone in held["zones"]))
+
+ def test_a_tile_touching_only_some_thirds_crosses_by_the_picked_ones_it_touches(self):
+ held = settings(peer(A, "Ay", side="right"), zones=[{"peer": A, "kind": "edge"}])
+ self.page(held, ["start", "end"])
+ # Against the top two thirds only: the bottom third is picked but not touched.
+ layout = beside(own_displays=True, peer_y=-34, peer_h=100)
+ result = ways.compile_layout(held, layout, moved=A)
+ held = result["settings"]
+ scoped = [zone for zone in held["zones"] if zone.get("display") == "main"]
+ self.assertEqual(crossing_thirds({"zones": scoped}), ["start"])
+ self.assertEqual(ways.ways(held, A)["parts"], ["start", "end"])
+ # Against the middle only: nothing picked is touched, and the map says so.
+ result = ways.compile_layout(held, beside(own_displays=True, peer_y=33, peer_h=33), moved=A)
+ self.assertEqual(result["tiles"][A]["state"], "gap")
+ self.assertEqual(result["tiles"][A]["sentence_keys"], ["unpicked"])
+ self.assertTrue(result["tiles"][A]["unpicked"])
+ self.assertIn("{name}", ways.ATLAS_SENTENCES["unpicked"])
+
+ def test_a_pick_a_clash_turned_off_reads_as_off_and_an_untouched_pick_as_on(self):
+ held = settings(peer(A, "Ay", side="right"), zones=[{"peer": A, "kind": "edge"}])
+ self.page(held, ["start"])
+ held["zones"][0]["off"] = True
+ self.assertIn("part", ways.ways(held, A)["methods"])
+ self.assertEqual(ways.ways(held, A)["parts"], ["start"])
+ self.page(held, ["start"])
+ held = ways.compile_layout(held, beside(own_displays=True, peer_y=33, peer_h=33), moved=A)["settings"]
+ self.assertFalse(ways.crosses_on_map(held, A))
+ self.assertIn("part", ways.ways(held, A)["methods"])
+ self.assertTrue(all("off" not in zone for zone in held["zones"]))
+ self.page(held, ["start", "middle"])
+ self.assertTrue(ways.crosses_on_map(held, A))
+ self.assertFalse(any(zone.get("unpicked") for zone in held["zones"]))
+
+ def test_leave_out_and_put_back_keep_the_pick_whether_or_not_it_touches(self):
+ for peer_y, peer_h, crossing in ((0, 100, ["start"]), (33, 33, [])):
+ with self.subTest(peer_y=peer_y):
+ held = settings(peer(A, "Ay", side="right"), zones=[{"peer": A, "kind": "edge"}])
+ self.page(held, ["start"])
+ held = ways.compile_layout(held, beside(own_displays=True, peer_y=peer_y, peer_h=peer_h),
+ moved=A)["settings"]
+ ways.leave_out(held, A)
+ self.assertFalse(ways.crosses_on_map(held, A))
+ ways.put_back(held, A)
+ self.assertIn("part", ways.ways(held, A)["methods"])
+ self.assertEqual(ways.ways(held, A)["parts"], ["start"])
+ scoped = [zone for zone in held["zones"] if zone.get("display") == "main"]
+ self.assertEqual(crossing_thirds({"zones": scoped}), crossing)
+
+ def test_put_back_leaves_off_a_third_another_machine_took_meanwhile(self):
+ held = settings(peer(A, "Ay", side="right"), peer(B, "Bee", side="right"),
+ zones=[{"peer": A, "kind": "edge"}])
+ self.page(held, ["start"])
+ layout = beside(own_displays=True)
+ held = ways.compile_layout(held, layout, moved=A)["settings"]
+ ways.leave_out(held, A)
+ ways.put_back(held, A)
+ scoped = [zone for zone in held["zones"] if zone.get("peer") == A and zone.get("display") == "main"]
+ self.assertEqual(crossing_thirds({"zones": scoped}), ["start"])
+ self.assertIsNone(ways.clash(held, "here"))
+
+ def test_a_contact_the_tile_has_left_is_not_revived_by_a_later_pick(self):
+ held = settings(peer(A, "Ay", side="right"), zones=[{"peer": A, "kind": "edge"}])
+ self.page(held, ["start"])
+ held = ways.compile_layout(held, beside(own_displays=True), moved=A)["settings"]
+ away = beside(own_displays=True)
+ away[A]["x"] = 400
+ held = ways.compile_layout(held, away, moved=A)["settings"]
+ self.page(held, ["start", "middle"])
+ scoped = [zone for zone in held["zones"] if zone.get("display") == "main"]
+ self.assertEqual(crossing_thirds({"zones": scoped}), [])
+
+ def test_edge_off_still_holds_with_thirds_picked_and_comes_back_whole(self):
+ for own_displays in (False, True):
+ with self.subTest(own_displays=own_displays):
+ held = settings(peer(A, "Ay", side="right"), zones=[{"peer": A, "kind": "edge"}])
+ self.page(held, ["start", "end"])
+ held = ways.compile_layout(held, beside(own_displays), moved=A)["settings"]
+ self.page(held, [], extra=["shortcut"])
+ for _ in range(2):
+ held = ways.compile_layout(held, beside(own_displays), moved=A)["settings"]
+ self.assertFalse(ways.crosses_on_map(held, A))
+ self.assertEqual(ways.picked_thirds(**{k: ways.ways(held, A)[k] for k in ("methods", "parts")}), [])
+ self.page(held, list(ways.PARTS))
+ self.assertTrue(ways.crosses_on_map(held, A))
+ self.assertEqual(ways.ways(held, A)["methods"], ["edge"])
+
+ def test_the_edge_tile_names_its_form(self):
+ cases = {("start", "end"): "Top and bottom thirds", ("middle",): "Middle third",
+ ("start", "middle", "end"): "Whole edge", (): "Whole edge or the thirds you pick"}
+ for thirds, words in cases.items():
+ with self.subTest(thirds=thirds):
+ self.assertEqual(ways.edge_form_detail("right", *ways.pick_thirds([], thirds)), words)
+ self.assertEqual(ways.edge_form_detail("top", ["part"], ["start", "middle"]), "Left and middle thirds")
+ self.assertEqual(ways.edge_form_detail("", ["edge"], [], here="This PC"), "Place it beside This PC on the map")
+
+ def test_the_map_click_targets_are_the_thirds_a_contact_covers(self):
+ own = {"x": 0, "y": 0, "w": 150, "h": 99}
+ self.assertEqual([third for third, *_ in ways.third_stretches(("right", 0, 99), own)], list(ways.PARTS))
+ self.assertEqual(ways.third_stretches(("right", 0, 50), own),
+ [("start", "right", 0, 33.0), ("middle", "right", 33.0, 50)])
+ self.assertEqual(ways.third_stretches(("corner", "top_right", ""), own), [])
+
+
if __name__ == "__main__":
unittest.main()
diff --git a/core/tests/v6_vectors.json b/core/tests/v6_vectors.json
index 9aa48c1..f3e0458 100644
--- a/core/tests/v6_vectors.json
+++ b/core/tests/v6_vectors.json
@@ -1427,14 +1427,23 @@
"alt",
"alt_r",
"backspace",
+ "brightness_down",
+ "brightness_up",
"browser_back",
+ "browser_favourites",
"browser_forward",
+ "browser_home",
+ "browser_refresh",
+ "browser_search",
+ "browser_stop",
+ "calculator",
"caps_lock",
"cmd",
"cmd_r",
"ctrl",
"ctrl_r",
"delete",
+ "dictation",
"down",
"end",
"enter",
@@ -1465,12 +1474,17 @@
"f9",
"home",
"insert",
+ "launch_app1",
+ "launch_app2",
"left",
+ "mail",
"media_next",
"media_play_pause",
"media_prev",
+ "media_select",
"media_stop",
"menu",
+ "mic_mute",
"num_lock",
"page_down",
"page_up",
@@ -1478,9 +1492,11 @@
"print_screen",
"right",
"scroll_lock",
+ "search",
"shift",
"shift_r",
"space",
+ "spotlight",
"tab",
"up",
"volume_down",
@@ -1533,12 +1549,17 @@
"125": "cmd",
"126": "cmd_r",
"127": "menu",
+ "128": "browser_stop",
+ "140": "calculator",
+ "150": "browser_home",
+ "155": "mail",
"158": "browser_back",
"159": "browser_forward",
"163": "media_next",
"164": "media_play_pause",
"165": "media_prev",
"166": "media_stop",
+ "173": "browser_refresh",
"183": "f13",
"184": "f14",
"185": "f15",
@@ -1550,7 +1571,11 @@
"191": "f21",
"192": "f22",
"193": "f23",
- "194": "f24"
+ "194": "f24",
+ "217": "search",
+ "224": "brightness_down",
+ "225": "brightness_up",
+ "248": "mic_mute"
}
},
"ack": {
diff --git a/core/ways.py b/core/ways.py
index 9a3a23e..2f8183d 100644
--- a/core/ways.py
+++ b/core/ways.py
@@ -1,15 +1,16 @@
-"""A machine's zones, one peer at a time (WIRE.md sections 5 and 8), shared by both desktops.
+"""Local way intent, picture-to-zone compilation, and the desktops' crossing helpers.
-What the Crossing page reads and writes for the machine it has chosen, the side settled with each
-peer by `arrangement`, the sentence for two zones over one stretch, which machine the shortcut and
-the Send button pick, and which machines that may drive this one cannot follow a zone. Pure: each
-app calls these on its settings under its own lock and writes the file itself.
+Crossing events live in crossing_state; mutating entry points here are compatibility
+wrappers for the existing app loaders and pages. WIRE.md sections 5 and 8 are unchanged.
"""
import base64
import binascii
import copy
+import math
import re
+import sys
+import time
from typing import Callable, Optional
from core import peerlist
@@ -30,6 +31,669 @@ _JUMP_KEYS = {"backspace", "caps_lock", "delete", "down", "end", "enter", "esc",
"volume_down", "volume_up", "media_next", "media_prev", "media_stop", "media_play_pause"}
+ATLAS_SENTENCES = {
+ "set_elsewhere": "Set on {first} or {second}.",
+ "between": "Crosses between {first} and {second}.",
+ "gap": "No edge leads to {name}. The shortcut and the menu still reach it.",
+ "edge_off": "Edge to {name} is off. Tick Edge to turn it back on.",
+ "unpicked": "None of the thirds picked for {name} touch its tile. Click a third along its edge.",
+ "overlap": "{first} overlaps {second}. Drag them apart.",
+}
+ATLAS_PARTS = ("start", "middle", "end")
+DIAGRAM_THIS = (120.0, 75.0)
+DIAGRAM_OTHER = (112.0, 63.0)
+DIAGRAM_GAP = 10.0
+DIAGRAM_SPLIT_GAP = 6.0
+DIAGRAM_MARGIN = 12.0
+
+
+def diagram_layout(width, height, machines):
+ """The legacy star placement, shared by callers that draw the Crossing arrangement."""
+ tw, th = DIAGRAM_THIS
+ ow, oh = DIAGRAM_OTHER
+ gap, split, margin = DIAGRAM_GAP, DIAGRAM_SPLIT_GAP, DIAGRAM_MARGIN
+ placed = [None] * len(machines)
+ for side in EDGES:
+ indexes = [i for i, (where, _third) in enumerate(machines) if where == side]
+ if indexes and all(machines[i][1] is not None for i in indexes):
+ indexes.sort(key=lambda i: machines[i][1])
+ count = len(indexes)
+ if not count:
+ continue
+ w, h = ow / count, oh / count
+ upright = side in ("left", "right")
+ step = (h if upright else w) + split
+ start = ((th if upright else tw) - (step * count - split)) / 2
+ for order, index in enumerate(indexes):
+ along = start + order * step
+ placed[index] = {"left": (-gap-w, along), "right": (tw+gap, along),
+ "top": (along, -gap-h), "bottom": (along, th+gap)}[side] + (w, h)
+ frames = [(0.0, 0.0, tw, th)] + [frame for frame in placed if frame is not None]
+ left, top = min(f[0] for f in frames), min(f[1] for f in frames)
+ span_w = max(f[0]+f[2] for f in frames)-left
+ span_h = max(f[1]+f[3] for f in frames)-top
+ scale = 1.0
+ if span_w > width or span_h > height:
+ scale = min((width-2*margin)/span_w, (height-2*margin)/span_h)
+ dx, dy = (width-span_w*scale)/2-left*scale, (height-span_h*scale)/2-top*scale
+ def fit(frame):
+ x, y, w, h = frame
+ return dx+x*scale, dy+y*scale, w*scale, h*scale
+ return fit(frames[0]), [None if frame is None else fit(frame) for frame in placed]
+
+
+def layout_ids(settings, layout=None):
+ """Machine ids allowed here, including named third parties in active peers' current paired lists."""
+ own = settings.get("machine_id", "")
+ entries = settings.get("peers", [])
+ known = {own} if isinstance(own, str) and own else set()
+ desktops = [peer for peer in entries if peer.get("port", 24820) != 0]
+ desktop_ids = {peer.get("id") for peer in desktops
+ if isinstance(peer.get("id"), str) and peer.get("id")}
+ known.update(desktop_ids)
+ layout = layout if isinstance(layout, dict) else {}
+ for peer in desktops:
+ if (peer.get("in_use", True) is False or peer.get("left_out") is True
+ or peerlist.dormant_reason(peer) is not None):
+ continue
+ paired_with = peer.get("paired_with", [])
+ if isinstance(paired_with, list):
+ known.update(ident for ident in paired_with
+ if isinstance(ident, str) and ident not in known
+ and _valid_tile_name(layout.get(ident)))
+ return known
+
+
+def _valid_tile_name(tile):
+ name = tile.get("name") if isinstance(tile, dict) else None
+ return isinstance(name, str) and bool(name.strip()) and len(name) <= 64
+
+
+def retain_held_peer_tiles(settings, layout, held_layout=None, received_layout=None):
+ """Keep received peer tiles, filling only those omitted by the other machine."""
+ result = copy.deepcopy(layout) if isinstance(layout, dict) else {}
+ if isinstance(received_layout, dict):
+ allowed = layout_ids(settings, received_layout)
+ result.update({ident: copy.deepcopy(tile) for ident, tile in received_layout.items() if ident in allowed})
+ held_layout = held_layout if isinstance(held_layout, dict) else settings.get("layout", {})
+ protected_ids = layout_ids(settings, held_layout)
+ missing = sorted(ident for ident in protected_ids if ident and ident not in result)
+ if not missing:
+ return result
+ kept = {peer: held_layout[peer] for peer in missing if isinstance(held_layout.get(peer), dict)}
+ defaults = derive_layout({**settings, "layout": {**result, **kept}}, gap=0)
+ for peer in missing:
+ tile = held_layout.get(peer) if isinstance(held_layout, dict) else None
+ if not isinstance(tile, dict):
+ tile = defaults.get(peer)
+ if isinstance(tile, dict):
+ result[peer] = copy.deepcopy(tile)
+ return result
+
+
+def prune_layout(settings, now=None):
+ """Drop tiles outside the local map rules and remove legacy vouch metadata."""
+ layout = settings.get("layout")
+ if not isinstance(layout, dict):
+ return False
+ allowed = layout_ids(settings, layout)
+ cleaned = copy.deepcopy({ident: tile for ident, tile in layout.items() if ident in allowed})
+ dropped = len(cleaned) != len(layout)
+ for tile in cleaned.values():
+ if isinstance(tile, dict):
+ tile.pop("vouched_by", None)
+ if cleaned == layout:
+ return False
+ settings["layout"] = cleaned
+ if dropped:
+ settings["layout_set_at"] = next_stamp(settings.get("layout_set_at", 0), time.time() if now is None else now)
+ settings["layout_by"] = settings.get("machine_id", "")
+ return True
+
+
+def derive_layout(settings, width=160, height=100, gap=12):
+ """Default one-tile-per-machine positions derived from the local sides and zones."""
+ own = settings.get("machine_id", "")
+ saved_tiles = settings.get("layout") or {}
+ saved = {key: tile for key, tile in saved_tiles.items() if key in layout_ids(settings, saved_tiles)}
+ held = saved.get(own)
+ x0, y0 = (held.get("x", 0), held.get("y", 0)) if isinstance(held, dict) else (0, 0)
+ if isinstance(held, dict) and type(held.get("w")) is int and type(held.get("h")) is int:
+ width, height = held["w"], held["h"]
+ result = {own: {"x": x0, "y": y0, "w": width, "h": height}}
+ for peer, tile in saved.items():
+ if isinstance(tile, dict) and all(type(tile.get(key)) is int for key in ("x", "y", "w", "h")) and tile["w"] > 0 and tile["h"] > 0:
+ result[peer] = {key: tile[key] for key in ("x", "y", "w", "h")}
+ if "displays" in tile and _valid_tile_displays(tile):
+ result[peer]["displays"] = copy.deepcopy(tile["displays"])
+ if tile.get("display_offsets"):
+ result[peer]["display_offsets"] = copy.deepcopy(tile["display_offsets"])
+ if _valid_tile_name(tile):
+ result[peer]["name"] = tile["name"].strip()
+ entries = [p for p in settings.get("peers", []) if p.get("id") and p.get("port", 24820) != 0]
+ # A shelved machine's kept tile is off the map, so it never blocks an active one's place.
+ shelved = {p["id"] for p in entries if p.get("left_out") is True or p.get("in_use", True) is False
+ or peerlist.dormant_reason(p) is not None}
+ def active():
+ return {key: tile for key, tile in result.items() if key not in shelved}
+ for side in EDGES:
+ group = []
+ for peer in entries:
+ if peer.get("side") != side or peer.get("id") in result:
+ continue
+ zones = {z.get("kind"): z for z in settings.get("zones", []) if z.get("peer") == peer["id"] and z.get("off") is not True}
+ parts = zones.get("part", {}).get("parts", [])
+ rank = min((ATLAS_PARTS.index(p) for p in parts if p in ATLAS_PARTS), default=1)
+ group.append((peer["id"], rank if "part" in zones else None))
+ if group and all(item[1] is not None for item in group):
+ group.sort(key=lambda item: item[1])
+ for index, (peer, _rank) in enumerate(group):
+ centre = y0 + height / 2 if side in ("left", "right") else x0 + width / 2
+ along = centre + (index - (len(group)-1)/2) * ((height if side in ("left", "right") else width) + gap)
+ if side == "left": rect = (x0-gap-width, along-height/2, width, height)
+ elif side == "right": rect = (x0+width+gap, along-height/2, width, height)
+ elif side == "top": rect = (along-width/2, y0-gap-height, width, height)
+ else: rect = (along-width/2, y0+height+gap, width, height)
+ tile = dict(zip(("x", "y", "w", "h"), map(round, rect)))
+ if any(_overlaps(tile, other) for other in active().values()):
+ tile = {**tile, **snap_position(tile, own, active(), radius=math.inf)}
+ result[peer] = tile
+ unplaced = [peer["id"] for peer in entries if peer["id"] not in result]
+ if unplaced:
+ below = max((tile["y"] + tile["h"] for key, tile in active().items() if key != own), default=y0+height)
+ for index, peer in enumerate(unplaced):
+ x = x0 + width/2 + (index - (len(unplaced)-1)/2) * (width + gap) - width/2
+ tile = {"x": round(x), "y": round(below + gap), "w": width, "h": height}
+ result[peer] = snap_position(tile, own, active(), radius=math.inf)
+ return result
+
+
+def crossing_stretches(contact, own, thirds):
+ """The parts of a contact with `own`'s tile that cross: the whole contact, or only the stretches
+ of it inside the listed thirds of `own`'s side when some but not all are."""
+ side, start, end = contact
+ if side == "corner" or not thirds or set(thirds) >= set(PARTS):
+ return [contact]
+ origin, length = (own["y"], own["h"]) if side in ("left", "right") else (own["x"], own["w"])
+ stretches = []
+ for index, part in enumerate(PARTS):
+ if part in thirds:
+ low, high = max(start, origin+index*length/3), min(end, origin+(index+1)*length/3)
+ if high > low:
+ stretches.append((side, low, high))
+ return stretches
+
+
+def _rect_contact(a, b):
+ ax, ay, aw, ah = (a[k] for k in ("x", "y", "w", "h")); bx, by, bw, bh = (b[k] for k in ("x", "y", "w", "h"))
+ ar, ab, br, bb = ax+aw, ay+ah, bx+bw, by+bh
+ along_y, along_x = min(ab, bb)-max(ay, by), min(ar, br)-max(ax, bx)
+ if br == ax and along_y > 0: return "left", max(ay, by), min(ab, bb)
+ if bx == ar and along_y > 0: return "right", max(ay, by), min(ab, bb)
+ if bb == ay and along_x > 0: return "top", max(ax, bx), min(ar, br)
+ if by == ab and along_x > 0: return "bottom", max(ax, bx), min(ar, br)
+ corners = {(ax, ay): "top_left", (ar, ay): "top_right", (ax, ab): "bottom_left", (ar, ab): "bottom_right"}
+ for point, corner in corners.items():
+ if point in ((bx, by), (bx+bw, by), (bx, by+bh), (bx+bw, by+bh)):
+ return "corner", corner, ""
+ return None
+
+
+def display_contacts(own, peer):
+ """[(screen, contact, target)]: each of `own`'s display frames that touches one of `peer`'s, with
+ their contact, as the engine finds its zones; a tile without displays is its own one frame."""
+ return [(screen, contact, target)
+ for screen in _display_frames(own)
+ for target in _display_frames(peer)
+ if (contact := _rect_contact(screen, target))]
+
+
+def side_contacts(own, peer):
+ """[(screen, contact)]: the side contacts of `display_contacts` for drawing, with those that abut
+ along the same one of `own`'s screens and sides (the peer's displays side by side) joined into one
+ stretch, so a join between the peer's displays is not drawn as a break."""
+ found = sorted(((screen, contact) for screen, contact, _target in display_contacts(own, peer)
+ if contact[0] in EDGES),
+ key=lambda item: (str(item[0]["display"]), item[1][0], item[1][1]))
+ joined = []
+ for screen, contact in found:
+ if joined:
+ held, (side, start, end) = joined[-1]
+ if held["display"] == screen["display"] and side == contact[0] and abs(end - contact[1]) < 1e-6:
+ joined[-1] = (held, (side, start, contact[2]))
+ continue
+ joined.append((screen, contact))
+ return joined
+
+
+def _overlaps(a, b):
+ return a["x"] < b["x"]+b["w"] and b["x"] < a["x"]+a["w"] and a["y"] < b["y"]+b["h"] and b["y"] < a["y"]+a["h"]
+
+
+def _display_frames(tile):
+ """Map the physical display arrangement over the full bounds of its group tile."""
+ screens = tile.get("displays")
+ if not isinstance(screens, dict) or not screens:
+ return [{"display": None, **{key: tile[key] for key in ("x", "y", "w", "h")}}]
+ left = min(rect["x"] for rect in screens.values())
+ top = min(rect["y"] for rect in screens.values())
+ right = max(rect["x"] + rect["w"] for rect in screens.values())
+ bottom = max(rect["y"] + rect["h"] for rect in screens.values())
+ scale_x = tile["w"] / (right - left)
+ scale_y = tile["h"] / (bottom - top)
+ offset_x, offset_y = tile["x"], tile["y"]
+ offsets = tile.get("display_offsets", {})
+ return [{"display": key,
+ "x": offset_x + (rect["x"] - left) * scale_x + offsets.get(key, {}).get("x", 0),
+ "y": offset_y + (rect["y"] - top) * scale_y + offsets.get(key, {}).get("y", 0),
+ "w": rect["w"] * scale_x, "h": rect["h"] * scale_y}
+ for key, rect in sorted(screens.items(), key=lambda item: (item[1]["y"], item[1]["x"], item[0]))]
+
+
+def snap_position(tile, own_id, layout, radius=12):
+ """Nearest free snap on a side's thirds, centre, flush alignments or a corner."""
+ own = layout.get(own_id, {"x": 0, "y": 0, "w": 160, "h": 100})
+ ox, oy, ow, oh = (own[k] for k in ("x", "y", "w", "h")); x, y, w, h = (tile[k] for k in ("x", "y", "w", "h"))
+ candidates = []
+ def add(cx, cy, centred=False):
+ candidates.append(({"x": round(cx), "y": round(cy), "w": w, "h": h}, centred))
+
+ for side in EDGES:
+ for i in range(4):
+ if side in ("left", "right"):
+ cx, cy = (ox-w if side == "left" else ox+ow), oy+i*oh/3-h/2
+ else:
+ cx, cy = ox+i*ow/3-w/2, (oy-h if side == "top" else oy+oh)
+ add(cx, cy)
+ if side in ("left", "right"):
+ cx = ox-w if side == "left" else ox+ow
+ add(cx, oy+(oh-h)/2, centred=True)
+ add(cx, oy)
+ add(cx, oy+oh-h)
+ else:
+ cy = oy-h if side == "top" else oy+oh
+ add(ox+(ow-w)/2, cy, centred=True)
+ add(ox, cy)
+ add(ox+ow-w, cy)
+ candidates.extend((({"x": round(ox-w), "y": round(oy-h), "w": w, "h": h}, False),
+ ({"x": round(ox+ow), "y": round(oy-h), "w": w, "h": h}, False),
+ ({"x": round(ox-w), "y": round(oy+oh), "w": w, "h": h}, False),
+ ({"x": round(ox+ow), "y": round(oy+oh), "w": w, "h": h}, False)))
+ free = [(candidate, centred) for candidate, centred in candidates
+ if not any(k != own_id and _overlaps(candidate, other) for k, other in layout.items())]
+ near = [(candidate, centred) for candidate, centred in free
+ if math.hypot(candidate["x"]-x, candidate["y"]-y) <= radius * (1.5 if centred else 1)]
+ return min(near or free,
+ key=lambda item: (abs(item[0]["x"]-x)+abs(item[0]["y"]-y), not item[1],
+ abs(item[0]["x"]-x), abs(item[0]["y"]-y)),
+ default=(dict(tile), False))[0]
+
+
+def within_snap_radius(tile, snap, own_id, layout, radius):
+ """Whether a free snap candidate is close enough to preview or accept."""
+ own = layout.get(own_id, {"x": 0, "y": 0, "w": 160, "h": 100})
+ ox, oy, ow, oh = (own[k] for k in ("x", "y", "w", "h"))
+ w, h = tile["w"], tile["h"]
+ centred = any(
+ (snap["x"], snap["y"]) == position
+ for position in ((round(ox-w), round(oy+(oh-h)/2)),
+ (round(ox+ow), round(oy+(oh-h)/2)),
+ (round(ox+(ow-w)/2), round(oy-h)),
+ (round(ox+(ow-w)/2), round(oy+oh)))
+ )
+ return math.hypot(snap["x"]-tile["x"], snap["y"]-tile["y"]) <= radius * (1.5 if centred else 1)
+
+
+def place_beside(layout, own_id, peer, side):
+ """`peer`'s tile centred against `own_id`'s on `side`, so its whole edge crosses; the nearest free
+ snap point when another tile is there already."""
+ own, tile = layout[own_id], layout[peer]
+ ox, oy, ow, oh = (own[k] for k in ("x", "y", "w", "h")); w, h = tile["w"], tile["h"]
+ x, y = {"left": (ox-w, oy+(oh-h)/2), "right": (ox+ow, oy+(oh-h)/2),
+ "top": (ox+(ow-w)/2, oy-h), "bottom": (ox+(ow-w)/2, oy+oh)}[side]
+ placed = {**tile, "x": round(x), "y": round(y)}
+ others = {key: value for key, value in layout.items() if key != peer}
+ if any(key != own_id and _overlaps(placed, other) for key, other in others.items()):
+ return {**tile, **snap_position(placed, own_id, others, radius=math.inf)}
+ return placed
+
+
+def share_side(layout, own_id, peer, side, ignore=()):
+ """`peer` joins the tiles already on `own_id`'s `side`, the row re-centred on that side as
+ derive_layout groups them, so every one still touches it; {} when they cannot all touch or the
+ row would overlap another tile. Tiles in `ignore` (shelved ones) never block."""
+ own = layout[own_id]
+ vertical = side in ("left", "right")
+ along, size = ("y", "h") if vertical else ("x", "w")
+ group = sorted((key for key, tile in layout.items() if key not in (own_id, peer, *ignore)
+ and (_rect_contact(own, tile) or ("",))[0] == side), key=lambda key: layout[key][along])
+ if not group:
+ return {}
+ placed, start = {}, own[along] + own[size]/2 - sum(layout[key][size] for key in (*group, peer))/2
+ for key in (*group, peer):
+ tile = layout[key]
+ across = {"left": own["x"]-tile["w"], "right": own["x"]+own["w"],
+ "top": own["y"]-tile["h"], "bottom": own["y"]+own["h"]}[side]
+ placed[key] = {**tile, along: round(start), ("x" if vertical else "y"): round(across)}
+ start += tile[size]
+ others = [tile for key, tile in layout.items() if key not in (own_id, *placed, *ignore)]
+ if any(not _rect_contact(own, tile) or _rect_contact(own, tile)[0] != side for tile in placed.values()) or any(
+ _overlaps(tile, other) for tile in placed.values() for other in others):
+ return {}
+ # A moved tile keeps every contact it had with the machines beyond it, or two of them stop crossing.
+ beyond = {key: tile for key, tile in layout.items() if key not in (own_id, peer, *placed, *ignore)}
+ if any(_rect_contact(layout[key], other) != _rect_contact(placed[key], other)
+ for key in group for other in beyond.values()):
+ return {}
+ return placed
+
+
+def corner_edge(corner, side):
+ """The edge a PC's corner zone crosses: its side when that is one of the corner's two edges, else
+ the corner's horizontal edge, as the Mac's always is. A corner push only fires through one of its
+ own edges (receiver.zone_models), so a top-left corner for a machine on the right crossing by the
+ right edge was silently never armed (Ledger harness, 10-10-2026)."""
+ return side if side in EDGES and side in corner.split("_") else corner.split("_")[1]
+
+
+def _valid_tile_displays(tile):
+ screens = tile.get("displays")
+ if screens is not None and not (isinstance(screens, dict) and 1 <= len(screens) <= 16
+ and all(isinstance(key, str) and key.isascii() and 1 <= len(key) <= 64
+ and isinstance(rect, dict)
+ and all(type(rect.get(name)) is int for name in ("x", "y", "w", "h"))
+ and rect["w"] > 0 and rect["h"] > 0
+ for key, rect in screens.items())):
+ return False
+ offsets = tile.get("display_offsets", {})
+ return (isinstance(offsets, dict) and len(offsets) <= 16
+ and (not offsets or isinstance(screens, dict))
+ and all(key in screens and isinstance(offset, dict)
+ and type(offset.get("x")) is int and type(offset.get("y")) is int
+ for key, offset in offsets.items()))
+
+
+def refresh_displays(settings, display_map, now=None):
+ """Record this machine's current logical display rectangles in the shared layout."""
+ own = settings.get("machine_id")
+ tile = (settings.get("layout") or {}).get(own)
+ if not isinstance(tile, dict) or not isinstance(display_map, dict) or not display_map:
+ return False
+ screens = {}
+ for key, rect in display_map.items():
+ if not isinstance(key, str) or not key.isascii() or not 1 <= len(key) <= 64:
+ return False
+ if not isinstance(rect, return_edge.Rect):
+ return False
+ screens[key] = {"x": rect.x, "y": rect.y, "w": rect.width, "h": rect.height}
+ if tile.get("displays") == screens:
+ return False
+ offsets = tile.get("display_offsets")
+ if isinstance(offsets, dict):
+ tile["display_offsets"] = {key: value for key, value in offsets.items() if key in screens}
+ tile["displays"] = screens
+ stamp = time.time() if now is None else now
+ settings["layout_set_at"] = next_stamp(settings.get("layout_set_at", 0), stamp)
+ settings["layout_by"] = own
+ return True
+
+
+def _read_intent(settings, peer):
+ """Read legacy zones once at migration; thereafter only the peer's saved intent."""
+ entry = _entry(settings, peer) or {}
+ held = entry.get("ways")
+ if isinstance(held, dict):
+ return {"edge": held.get("edge", True) is True,
+ "thirds": [part for part in PARTS if part in held.get("thirds", PARTS)] or list(PARTS),
+ "corner": held.get("corner", False) is True,
+ "corner_at": held.get("corner_at") if held.get("corner_at") in CORNERS else DEFAULT_CORNER,
+ "notch": held.get("notch", False) is True}
+ mine = [zone for zone in settings.get("zones", []) if zone.get("peer") == peer]
+ if not mine:
+ return dict(edge=True, thirds=list(PARTS), corner=False, corner_at=DEFAULT_CORNER, notch=False)
+ kept = entry.get("left_out_ways") if entry.get("left_out") is True else None
+ if isinstance(kept, list):
+ # Left out in rc12: every zone is off and the kinds in use were kept here for Put back.
+ on = lambda zone: zone.get("kind") in kept and zone.get("page_off") is not True
+ else:
+ # Off only by the page's own untick. A pick that touches no contact today (`unpicked`) and a
+ # way set aside while its machine slept (`aside`) were still on in rc12.
+ on = lambda zone: zone.get("page_off") is not True and (
+ zone.get("off") is not True or zone.get("unpicked") is True or zone.get("aside") is True)
+ active_edge = any(zone.get("kind") == "edge" and on(zone) for zone in mine)
+ active_part = [zone for zone in mine if zone.get("kind") == "part" and on(zone)]
+ picked = next((zone["page_parts"] for zone in mine
+ if zone.get("kind") == "part" and isinstance(zone.get("page_parts"), list)
+ and zone["page_parts"]), None)
+ # The whole edge in use wins over any thirds: over a pick left on an off part zone (the page showed
+ # the whole edge), and over a part zone also in use (1.4.x let both be on; the edge covered them).
+ if active_edge:
+ parts = list(PARTS)
+ else:
+ parts = picked if picked is not None else [part for zone in active_part for part in zone.get("parts", [])]
+ if not parts:
+ parts = next((zone.get("parts") for zone in mine if zone.get("kind") == "part"
+ and zone.get("parts")), list(PARTS))
+ corner = next((zone.get("corner") for zone in mine if zone.get("kind") == "corner"), DEFAULT_CORNER)
+ return dict(edge=active_edge or bool(active_part),
+ thirds=[part for part in PARTS if part in parts] or list(PARTS),
+ corner=any(zone.get("kind") == "corner" and on(zone) for zone in mine),
+ corner_at=corner if corner in CORNERS else DEFAULT_CORNER,
+ notch=any(zone.get("kind") == "notch" and on(zone) for zone in mine))
+
+
+def picture_capable(settings, capable=()):
+ """The machines that place by the picture: `capable` as the caller knows it, else the entries
+ that advertise `layout`. Empty means no capability information at all."""
+ peers = settings.get("peers", [])
+ if not capable and any("caps" in entry for entry in peers):
+ return {settings.get("machine_id", "")} | {entry.get("id") for entry in peers if "layout" in entry.get("caps", [])}
+ return set(capable)
+
+
+def compile_layout(settings, layout, moved=None, capable=(), now=None, platform="pc",
+ live=None, gone=None):
+ """Generate zones from the picture and saved intent, without changing the caller's settings.
+
+ An explicit capability set (including this machine) keeps old peers on their side-based path.
+ With no capability information, tiles are treated as picture peers for existing canvas callers.
+ """
+ if not isinstance(layout, dict):
+ return {"accepted": False, "tiles": {}}
+ layout = copy.deepcopy({key: tile for key, tile in layout.items() if key in layout_ids(settings, layout)})
+ own_id = settings.get("machine_id", "")
+ layout.setdefault(own_id, derive_layout(settings).get(own_id, dict(x=0, y=0, w=160, h=100)))
+ if any(not isinstance(tile, dict)
+ or any(type(tile.get(key)) is not int for key in ("x", "y", "w", "h"))
+ or tile["w"] < 1 or tile["h"] < 1 or not _valid_tile_displays(tile) for tile in layout.values()):
+ return {"accepted": False, "tiles": {}}
+ saved = copy.deepcopy(settings)
+ peers = {entry.get("id"): entry for entry in saved.get("peers", [])}
+ for peer, entry in peers.items():
+ if _zoned(entry):
+ entry["ways"] = _read_intent(settings, peer)
+ entry.pop("left_out_ways", None)
+ inactive = {peer for peer, entry in peers.items()
+ if entry.get("left_out") is True or entry.get("in_use", True) is False
+ or peerlist.dormant_reason(entry) is not None or (gone is not None and gone(peer))}
+ active = {peer: tile for peer, tile in layout.items() if peer not in inactive}
+ screens = {peer: _display_frames(tile) for peer, tile in active.items()}
+ surfaces = [(peer, screen) for peer, frames in screens.items() for screen in frames]
+ overlaps = {}
+ for index, (one, a) in enumerate(surfaces):
+ for two, b in surfaces[index + 1:]:
+ if one != two and _overlaps(a, b):
+ overlaps.setdefault(one, set()).add(two)
+ overlaps.setdefault(two, set()).add(one)
+ contacts = {}
+ for peer in peers:
+ contacts[peer] = [] if peer in overlaps or peer in inactive or peer not in active or own_id not in active \
+ else display_contacts(active[own_id], active[peer])
+ crowded = {}
+ for peer, found in contacts.items():
+ for screen, contact, target in found:
+ if contact[0] in EDGES:
+ crowded.setdefault((screen["display"], contact[0]), set()).add(peer)
+ if any(len(group) >= 4 for group in crowded.values()):
+ result = {"accepted": False, "tiles": {}}
+ if moved in active and moved != own_id:
+ result.update(snap={moved: snap_position(active[moved], own_id,
+ {key: tile for key, tile in active.items() if key != moved})},
+ tiles={moved: {"state": "overlap", "thirds": [], "sentence_keys": []}})
+ return result
+ capable = picture_capable(saved, capable)
+ picture_peers = set(capable) if capable else set(layout)
+ held_sides = {peer: entry.get("side", "") for peer, entry in peers.items()}
+ stamp = time.time() if now is None else now
+ if layout != saved.get("layout"):
+ saved.update(layout=copy.deepcopy(layout),
+ layout_set_at=next_stamp(saved.get("layout_set_at"), stamp), layout_by=own_id)
+ else:
+ saved["layout"] = copy.deepcopy(layout)
+ allocations = {}
+ for peer, found in contacts.items():
+ entry = peers[peer]
+ if peer not in picture_peers or not _zoned(entry) or not entry["ways"]["edge"]:
+ continue
+ for index, (screen, contact, target) in enumerate(found):
+ side, start, end = contact
+ if side not in EDGES:
+ continue
+ origin, length = (screen["y"], screen["h"]) if side in ("left", "right") else (screen["x"], screen["w"])
+ for third, part in enumerate(PARTS):
+ overlap = min(end, origin + (third + 1) * length / 3) - max(start, origin + third * length / 3)
+ if overlap + 1e-9 < length / 6:
+ continue
+ key = (screen["display"], side, part)
+ rank = (overlap, _id_bytes(peer) or peer.encode(), -index)
+ if key not in allocations or rank > allocations[key][0]:
+ allocations[key] = (rank, peer, index)
+ zones, tiles, corners = [], {}, set()
+ notch_taken = False
+ def add_zone(peer, kind, screen=None, side=None, target=None, **fields):
+ zone = dict(peer=peer, kind=kind, **fields)
+ if screen is not None:
+ if screen["display"] is not None:
+ zone["display"] = screen["display"]
+ zone["side"] = side
+ if target is not None and target["display"] is not None and side in EDGES:
+ zone.update(target_display=target["display"], target_side=return_edge.OPPOSITE[side])
+ zones.append(zone)
+ for peer, entry in peers.items():
+ if not _zoned(entry):
+ tiles[peer] = {"state": "gap", "thirds": [], "sentence_keys": ["gap"]}
+ continue
+ intent = entry["ways"]
+ found = contacts.get(peer, [])
+ if peer in inactive:
+ tiles[peer] = {"state": "dormant", "thirds": [], "sentence_keys": []}
+ continue
+ if peer in picture_peers:
+ side = next((contact[0] for screen, contact, target in found if contact[0] in EDGES), "")
+ if side != entry.get("side", ""):
+ entry.update(side=side, side_set_at=saved.get("layout_set_at", int(stamp)),
+ side_by=saved.get("layout_by") or own_id)
+ states, touched = [], set()
+ if peer in picture_peers:
+ for index, (screen, contact, target) in enumerate(found):
+ side = contact[0]
+ if side == "corner":
+ corner = contact[1]
+ key = (screen["display"], corner)
+ if (intent["edge"] or intent["corner"]) and key not in corners:
+ corners.add(key)
+ edge = corner.split("_")[1]
+ add_zone(peer, "corner", screen, edge, target, corner=corner, edge=edge)
+ states.append("corner")
+ continue
+ assigned = [part for part in PARTS if allocations.get((screen["display"], side, part), (None, None, None))[1:] == (peer, index)]
+ touched.update(assigned)
+ kept = [part for part in assigned if part in intent["thirds"]]
+ if intent["edge"] and kept:
+ kind = "edge" if len(kept) == 3 else "part"
+ add_zone(peer, kind, screen, side, target, **({"parts": kept} if kind == "part" else {}))
+ states.append(kind)
+ if intent["corner"]:
+ corner = intent["corner_at"]
+ key = (screen["display"], corner)
+ if key not in corners:
+ corners.add(key)
+ edge = corner.split("_")[1] if platform == "mac" else corner_edge(corner, side)
+ # A corner may cross a different edge from the contact; its landing pair follows that edge.
+ add_zone(peer, "corner", screen, edge, target, corner=corner, edge=edge)
+ states.append("corner")
+ else:
+ side = entry.get("side", "")
+ # Picture contacts reserve their thirds even when the local pick narrows them.
+ reserved = {part for (display, edge, part) in allocations if edge == side}
+ occupied = {part for zone in zones if zone["kind"] in ("edge", "part")
+ and zone.get("side", peers.get(zone["peer"], {}).get("side")) == side
+ for part in (PARTS if zone["kind"] == "edge" else zone["parts"])}
+ kept = [part for part in intent["thirds"] if part not in reserved | occupied]
+ if intent["edge"] and side in EDGES and kept:
+ kind = "edge" if len(kept) == 3 else "part"
+ add_zone(peer, kind, **({"parts": kept} if kind == "part" else {}))
+ states.append(kind)
+ touched.update(kept)
+ if intent["corner"] and (None, intent["corner_at"]) not in corners:
+ corners.add((None, intent["corner_at"]))
+ edge = intent["corner_at"].split("_")[1] if platform == "mac" else corner_edge(intent["corner_at"], side)
+ add_zone(peer, "corner", corner=intent["corner_at"], edge=edge)
+ states.append("corner")
+ if platform == "mac" and intent["notch"] and not notch_taken:
+ add_zone(peer, "notch")
+ notch_taken = True
+ state = next((kind for kind in ("edge", "part", "corner") if kind in states), "gap")
+ tiles[peer] = {"state": state, "thirds": [part for part in PARTS if part in touched],
+ "sentence_keys": ["gap"] if state == "gap" else []}
+ if found and not states and intent["edge"] and touched:
+ tiles[peer].update(unpicked=True, sentence_keys=["unpicked"])
+ for peer, found in contacts.items():
+ if peer in inactive or found or peer not in active:
+ continue
+ for other in contacts:
+ if other != peer and other not in inactive and not contacts[other] and other in active and _rect_contact(active[peer], active[other]):
+ state = "between" if peer in capable and other in capable else "set-elsewhere"
+ tiles[peer] = {"state": state, "thirds": [], "sentence_keys": ["between" if state == "between" else "set_elsewhere"]}
+ for peer, others in overlaps.items():
+ if peer in peers and peer not in inactive:
+ tiles[peer] = {"state": "overlap", "thirds": [], "sentence_keys": ["overlap"], "overlap_with": min(others)}
+ saved["zones"] = zones
+ arrangements = [{"peer": peer, "side": entry.get("side", ""), "set_at": entry.get("side_set_at", 0),
+ "by": entry.get("side_by", "")} for peer, entry in peers.items()
+ if held_sides[peer] != entry.get("side", "")]
+ result = dict(accepted=moved not in overlaps, tiles=tiles, layout=copy.deepcopy(layout),
+ arrangements=arrangements, settings=saved)
+ if moved in overlaps and moved != own_id:
+ result["snap"] = {moved: snap_position(layout[moved], own_id,
+ {key: tile for key, tile in active.items() if key != moved})}
+ return result
+
+
+def inverse_layout(settings, layout, width=160, height=100, gap=12, peer=None, old_side=None):
+ """Re-place peers after an incoming arrangement changes their settled side."""
+ updated = copy.deepcopy(layout)
+ if peer is None:
+ derived = derive_layout({**settings, "layout": {}}, width, height, gap)
+ else:
+ own = layout.get(settings.get("machine_id"), {"x": 0, "y": 0, "w": width, "h": height})
+ contact = _rect_contact(own, layout[peer]) if peer in layout else None
+ old_side = old_side or (contact[0] if contact and contact[0] != "corner" else "")
+ if not old_side and peer in layout:
+ tile = layout[peer]
+ if tile["x"] + tile["w"] == own["x"] - gap: old_side = "left"
+ elif tile["x"] == own["x"] + own["w"] + gap: old_side = "right"
+ elif tile["y"] + tile["h"] == own["y"] - gap: old_side = "top"
+ elif tile["y"] == own["y"] + own["h"] + gap: old_side = "bottom"
+ entry = next((item for item in settings.get("peers", []) if item.get("id") == peer), {})
+ affected = {side for side in (old_side, entry.get("side", "")) if side in EDGES}
+ saved = {key: value for key, value in settings.get("layout", {}).items() if key != peer}
+ derived = derive_layout({**settings, "layout": saved}, width, height, gap)
+ if peer in derived:
+ updated[peer] = derived[peer]
+ return updated
+
+
def part_names(edge: str) -> dict:
"""The labels for thirds along an edge, in the direction they run."""
if edge in ("left", "right"):
@@ -53,6 +717,94 @@ def toggle_part(parts, part, on) -> list:
return [name for name in PARTS if name in chosen]
+# The whole edge and Part of the edge are one choice in two forms: every third, or the thirds picked.
+def picked_thirds(methods, parts) -> list:
+ """The thirds that cross for these ways: all three for the whole edge, the picked ones for Part
+ of the edge, none when neither is on."""
+ if "edge" in methods:
+ return list(PARTS)
+ if "part" in methods:
+ return [part for part in PARTS if part in parts] or list(DEFAULT_PARTS)
+ return []
+
+
+def pick_thirds(methods, thirds):
+ """(methods, parts) with the edge's form set from `thirds`: all three is the whole edge, some is
+ Part of the edge, none turns both off. Other ways are kept, in their order."""
+ thirds = [part for part in PARTS if part in thirds]
+ kept = [way for way in methods if way not in ("edge", "part")]
+ if not thirds:
+ return kept, list(DEFAULT_PARTS)
+ form = "edge" if len(thirds) == len(PARTS) else "part"
+ order = ("shortcut", "edge", "part", "corner", "notch")
+ return [way for way in order if way in set(kept) | {form}] + [way for way in kept if way not in order], thirds
+
+
+def toggle_third(methods, parts, part):
+ """(methods, parts) after one third is clicked, in the ledger or on the map: the last lit third
+ turns Edge off, keeping it as the remembered thirds; with Edge off, a click lights that third alone."""
+ current = picked_thirds(methods, parts)
+ if not current:
+ return pick_thirds(methods, [part])
+ chosen = [third for third in current if third != part] if part in current else current + [part]
+ if not chosen:
+ return [way for way in methods if way not in ("edge", "part")], list(current)
+ return pick_thirds(methods, chosen)
+
+
+def toggle_edge(methods, parts):
+ """(methods, parts) after the Edge text is clicked: on in any form turns off, keeping the thirds;
+ off turns on as the whole edge, so the whole edge is always one click away."""
+ if picked_thirds(methods, parts):
+ return [way for way in methods if way not in ("edge", "part")], [p for p in PARTS if p in parts] or list(PARTS)
+ return pick_thirds(methods, PARTS)
+
+
+def corner_holder(settings: dict, corner: str, exclude: Optional[str] = None) -> Optional[str]:
+ """The machine, other than `exclude`, whose Corner is on at `corner` of this machine's screen:
+ one corner per machine, never shared, so the page refuses that corner to anyone else. Left-out,
+ not-in-use and phone entries hold none."""
+ for entry in settings.get("peers", []):
+ ident = entry.get("id")
+ if (ident == exclude or not _zoned(entry) or entry.get("left_out") is True
+ or entry.get("in_use", True) is False):
+ continue
+ intent = _read_intent(settings, ident)
+ if intent["corner"] and intent["corner_at"] == corner:
+ return ident
+ return None
+
+
+def edge_form_detail(side, methods, parts, here="This Mac") -> str:
+ """The Edge way's detail on the Crossing page: which form crosses, or where to place it first."""
+ if side not in EDGES:
+ return f"Place it beside {here} on the map"
+ thirds = picked_thirds(methods, parts)
+ if not thirds:
+ return "Whole edge or the thirds you pick"
+ if len(thirds) == len(PARTS):
+ return "Whole edge"
+ names = [part_names(side)[part] for part in thirds]
+ named = names[0] if len(names) == 1 else " and ".join([", ".join(names[:-1]), names[-1].lower()])
+ return f"{named.capitalize()} third{'s' if len(names) > 1 else ''}"
+
+
+def third_stretches(contact, own):
+ """[(third, side, low, high)]: each third of `own`'s side that a side contact covers, clipped to
+ the contact, for the map's click targets. None for a corner contact."""
+ side, start, end = contact
+ if side == "corner":
+ return []
+ origin, length = (own["y"], own["h"]) if side in ("left", "right") else (own["x"], own["w"])
+ found = []
+ for index, part in enumerate(PARTS):
+ low, high = max(start, origin + index * length / 3), min(end, origin + (index + 1) * length / 3)
+ if high > low:
+ found.append((part, side, low, high))
+ return found
+
+
+
def valid_jump_key(value) -> bool:
"""Whether a recorded jump key is one modifier chord with a single non-modifier key."""
if not isinstance(value, str) or not value or value != value.lower():
@@ -144,165 +896,114 @@ def _entry(settings: dict, peer: str) -> Optional[dict]:
return next((entry for entry in settings["peers"] if entry.get("id") == peer), None)
-def _mine(settings: dict, peer: str) -> dict:
- found = {}
- for zone in settings["zones"]:
- if zone.get("peer") == peer:
- found.setdefault(zone.get("kind"), zone)
- return found
+
+
+
+
def ways(settings: dict, peer: str) -> dict:
- """The ways across to one peer as the Crossing page shows them: its `side`, the kinds of zone in
- use in section 8's order of kinds, the thirds and the corner its zones hold (the defaults where
- it has none)."""
+ """Read the peer's saved intent, including thirds remembered while Edge is off."""
entry = _entry(settings, peer) or {}
- mine = _mine(settings, peer)
- parts = mine.get("part", {}).get("parts")
- corner = mine.get("corner", {}).get("corner")
- return {
- "side": entry.get("side") if entry.get("side") in EDGES else "",
- "methods": [kind for kind in KIND_WORDS if kind in mine and mine[kind].get("off") is not True],
- "parts": [part for part in PARTS if part in parts] if isinstance(parts, list) and parts else list(DEFAULT_PARTS),
- "corner": corner if corner in CORNERS else DEFAULT_CORNER,
- }
+ intent = _read_intent(settings, peer)
+ methods = []
+ if entry and intent["edge"]:
+ methods.append("edge" if len(intent["thirds"]) == 3 else "part")
+ methods += [kind for kind in ("corner", "notch") if entry and intent[kind]]
+ return dict(side=entry.get("side") if entry.get("side") in EDGES else "",
+ methods=methods, parts=list(intent["thirds"]), corner=intent["corner_at"])
def edit(settings: dict, peer: str, *, side: str, methods, parts, corner: str, kinds,
- corner_edge: Callable[[str, str], str], now: float) -> bool:
- """Writes one peer's ways: its `side`, and one zone of each of `kinds` (the kinds this app
- offers), in use when named in `methods` and `off` otherwise. The whole edge covers its thirds,
- so with both chosen the thirds are written `off` (section 8). `corner_edge(corner, side)` is
- the edge this app's corner crosses. A changed side is stamped by this machine, never below the
- stamp held plus one. Returns whether the side changed, which the caller sends as `arrangement`.
- KeyError when no entry has `peer`."""
+ corner_edge: Callable[[str, str], str], now: float, **legacy) -> bool:
+ """Compatibility wrapper: side edits place a tile; way edits save independent intent."""
+ from core import crossing_state
entry = _entry(settings, peer)
if entry is None:
raise KeyError(peer)
- if entry.get("port") == 0:
+ if not _zoned(entry):
raise ValueError("a phone cannot have a side or zones")
- side = side if side in EDGES else ""
- moved = bool(side) and side != entry.get("side")
+ moved = side in EDGES and side != entry.get("side")
+ held = copy.deepcopy(settings)
if moved:
- entry.update(side=side, side_set_at=next_stamp(entry.get("side_set_at"), now), side_by=settings["machine_id"])
- methods = set(methods)
- if "edge" in methods:
- methods.discard("part")
- parts = [part for part in PARTS if part in parts] or list(DEFAULT_PARTS)
- corner = corner if corner in CORNERS else DEFAULT_CORNER
- fields = {"edge": {}, "part": {"parts": parts}, "corner": {"corner": corner, "edge": corner_edge(corner, side)},
- "notch": {}}
- mine = _mine(settings, peer)
- for kind in kinds:
- zone = mine.get(kind)
- if zone is None:
- zone = {"peer": peer, "kind": kind}
- settings["zones"].append(zone)
- zone.update(fields[kind])
- zone.pop("aside", None)
- if kind in methods:
- zone.pop("off", None)
- else:
- zone["off"] = True
+ held["layout"] = derive_layout(held, gap=0)
+ held["layout"][peer] = place_beside(held["layout"], held["machine_id"], peer, side)
+ held["layout_set_at"] = next_stamp(held.get("layout_set_at"), now)
+ held["layout_by"] = held["machine_id"]
+ chosen = set(methods)
+ platform = "mac" if "notch" in kinds else "pc"
+ out = crossing_state.edit_ways(held, peer, platform=platform, edge=bool(chosen & {"edge", "part"}),
+ thirds=list(PARTS) if "edge" in chosen else parts, corner="corner" in chosen, corner_at=corner,
+ notch="notch" in chosen if platform == "mac" else None, live=None, gone=None, now=now)
+ settings.clear()
+ settings.update(out["settings"])
return moved
-def _stretch(zone: dict, sides: dict) -> set:
+
+
+def leave_out(settings: dict, peer: str, *, platform=None, capable=()) -> None:
+ """Compatibility wrapper: shelf the peer while keeping its intent."""
+ from core import crossing_state
+ out = crossing_state.leave_out(settings, peer, platform=platform or _platform(settings), capable=capable)
+ settings.clear()
+ settings.update(out["settings"])
+
+
+def put_back(settings: dict, peer: str, *, platform=None, capable=()) -> None:
+ """Compatibility wrapper: compile the peer's held intent again."""
+ from core import crossing_state
+ out = crossing_state.put_back(settings, peer, platform=platform or _platform(settings), capable=capable)
+ settings.clear()
+ settings.update(out["settings"])
+
+
+def _platform(settings):
+ return "mac" if sys.platform == "darwin" else "pc"
+
+
+def _stretch(zone: dict, sides: dict, peers=()) -> set:
"""What a zone in use covers, for the rule that two never share one (section 8); the notch is
one stretch of its own, as a Mac has one notch."""
+ owner = next((entry for entry in peers if entry.get("id") == zone.get("peer")), None)
+ if owner is not None and (owner.get("in_use", True) is False or owner.get("left_out") is True
+ or owner.get("dormant") is True):
+ return set()
if zone.get("kind") == "notch":
- return {("notch",)}
- side = sides.get(zone.get("peer"), "")
+ return {("notch", "all")}
+ side = zone.get("side", sides.get(zone.get("peer"), ""))
+ display = zone.get("display")
kind = zone.get("kind")
if kind == "corner" and zone.get("corner") in CORNERS:
- return {("corner", zone["corner"])}
+ return {(('display_corner', display), zone["corner"])} if display is not None else {("corner", zone["corner"])}
+ scope = ("display", display, side) if display is not None else side
if kind == "edge" and side in EDGES:
- return {(side, part) for part in PARTS}
+ return {(scope, part) for part in PARTS}
if kind == "part" and side in EDGES and isinstance(zone.get("parts"), list):
- return {(side, part) for part in zone["parts"] if part in PARTS}
+ return {(scope, part) for part in zone["parts"] if part in PARTS}
return set()
-def share_offer(settings: dict, peer: str, live: Optional[Callable[[str], bool]] = None) -> Optional[dict]:
- """Propose thirds for `peer` when another machine already uses part of its side. A machine with
- no link now is never offered a third: choosing the side takes it from that one (`give_way`)."""
- entry = _entry(settings, peer)
- side = entry.get("side") if entry else ""
- if side not in EDGES:
- return None
- sides = {item.get("id"): item.get("side", "") for item in settings["peers"]}
- holders = _side_holders(settings, peer, live)
- if not holders:
- return None
- holder_set = set(holders)
- assigned = {}
- for zone in settings["zones"]:
- owner = zone.get("peer")
- if owner not in holder_set or zone.get("off") is True or sides.get(owner) != side:
- continue
- if zone.get("kind") not in ("edge", "part"):
- continue
- covered = {part for stretch_side, part in _stretch(zone, sides) if stretch_side == side}
- if not covered:
- continue
- for part in PARTS:
- if part in covered:
- assigned.setdefault(part, owner)
- thirds = {part: assigned.get(part, peer) for part in PARTS}
- if peer not in thirds.values():
- thirds["end"] = peer
- return {"side": side, "holders": holders, "thirds": thirds}
+def _stretch_side(stretch):
+ scope = stretch[0]
+ return scope[2] if isinstance(scope, tuple) and scope[0] == "display" else scope
+
+
+def share_offer(settings: dict, peer: str, live=None) -> Optional[dict]:
+ """No-op: shared stretches are chosen by contacts on the map."""
+ return None
def share(settings: dict, side: str, thirds: dict, *, kinds) -> list:
- """Writes a side split by thirds (`thirds`: part -> machine id) after checking every third and its
- machine, before anything changes: each machine on that side gets its thirds as a part zone in use
- and its whole edge off; one left with none keeps its part zone off. Returns every machine to tell:
- those whose zones changed and those whose way back or way_back_by did (section 8)."""
+ """No-op retained for app imports: the map owns shared stretches."""
if side not in EDGES or not isinstance(thirds, dict) or set(thirds) != set(PARTS):
raise ValueError("a split needs every third of a known side")
- peers = {entry.get("id"): entry for entry in peerlist.desktops(settings["peers"])}
+ peers = {entry.get("id"): entry for entry in settings.get("peers", []) if _zoned(entry)}
if any(not isinstance(peer, str) or peers.get(peer, {}).get("side") != side for peer in thirds.values()):
- raise ValueError("every third must belong to a machine on that side")
+ raise ValueError("every third must belong to a desktop on that side")
if "part" not in kinds:
raise ValueError("this app does not offer parts of an edge")
- sides = {entry.get("id"): entry.get("side", "") for entry in settings["peers"]}
- owners = set(thirds.values())
- told = way_back_state(settings)
- changed = []
- for entry in settings["peers"]:
- if entry.get("port") == 0:
- continue
- peer = entry.get("id")
- mine = _mine(settings, peer)
- zones = [zone for zone in mine.values() if zone.get("off") is not True and
- any(stretch[0] == side for stretch in _stretch(zone, sides))]
- if entry.get("side") != side or (not zones and peer not in owners):
- continue
- edge = mine.get("edge")
- part = mine.get("part")
- expected = [name for name in PARTS if thirds[name] == peer]
- before = (dict(edge) if edge else None, dict(part) if part else None)
- if edge is not None:
- edge["off"] = True
- edge.pop("aside", None)
- if part is None:
- part = {"peer": peer, "kind": "part"}
- settings["zones"].append(part)
- part.pop("aside", None)
- if expected:
- part["parts"] = expected
- part.pop("off", None)
- else:
- # Off, never empty: the settings refuse a part zone that names no third.
- if not (isinstance(part.get("parts"), list) and part["parts"]):
- part["parts"] = list(DEFAULT_PARTS)
- part["off"] = True
- if before != (dict(edge) if edge else None, dict(part)):
- changed.append(peer)
- # A machine whose zones did not change can still be told something new: who holds its side.
- changed += [peer for peer, state in way_back_state(settings).items() if told.get(peer) != state and peer not in changed]
- return changed
+ return []
def _clashing(settings: dict):
@@ -312,7 +1013,7 @@ def _clashing(settings: dict):
for zone in settings["zones"]:
if zone.get("off") is True:
continue
- for stretch in sorted(_stretch(zone, sides)):
+ for stretch in sorted(_stretch(zone, sides, settings["peers"])):
if stretch in seen:
return seen[stretch], zone, stretch
seen[stretch] = zone
@@ -329,12 +1030,21 @@ def clash(settings: dict, here: str) -> Optional[str]:
peers = settings["peers"]
one = peerlist.label_for(peers, peer_id=first.get("peer")) or peerlist.UNNAMED
other = peerlist.label_for(peers, peer_id=second.get("peer")) or peerlist.UNNAMED
- where = {"notch": "the notch", "corner": f"the {stretch[-1].replace('_', ' ')} corner"}.get(
- stretch[0], f"the {stretch[0]} edge")
+ scope, part = stretch
+ if isinstance(scope, tuple) and scope[0] == "display":
+ where = f"the {scope[2]} edge of display {scope[1]}"
+ kind = scope[0]
+ elif isinstance(scope, tuple) and scope[0] == "display_corner":
+ where = f"the {part.replace('_', ' ')} corner of display {scope[1]}"
+ kind = "corner"
+ else:
+ where = {"notch": "the notch", "corner": f"the {part.replace('_', ' ')} corner"}.get(
+ scope, f"the {scope} edge")
+ kind = scope
if first.get("peer") == second.get("peer"):
return f"Two of the ways to {one} cover {where} of {here}. Keep one of them."
fix = {"notch": "Turn the notch off for one of them.", "corner": "Choose another corner for one of them."}.get(
- stretch[0], "Move one of them to another side, or give each its own thirds of the edge.")
+ kind, "Move one of them to another side, or give each its own thirds of the edge.")
return f"{one} and {other} would both lead from {where} of {here}. {fix}"
@@ -351,44 +1061,19 @@ def _id_bytes(text) -> Optional[bytes]:
def arrangement(settings: dict, peer: str, edge: str, set_at: int, by: str, here: str, way_back=None,
way_back_by=None, corner_edge: Optional[Callable[[str, str], str]] = None,
live: Optional[Callable[[str], bool]] = None):
- """A peer's `arrangement` (section 8): `edge` is the peer's edge that faces this machine, so this
- machine's side for it is the opposite. Taken when newer than the side held: a higher stamp, or the
- same stamp and the larger `by` as bytes. A machine with no zone yet gets its whole edge for that
- side, and a side that would put two zones in use over one stretch is applied and turns this peer's
- clashing zones off. `way_back` and `way_back_by`, when carried, are kept on the entry whether or
- not the side was newer. `corner_edge(corner, side)`, the app's own, rewrites the edge its corner zones
- for the peer cross, as `edit` does, since a PC's corner crosses the side. `live(id)`, when given,
- says whether a machine has a link up now: one that has not gives way (`give_way`). Returns
- (changed, notices), a sentence for each zone turned off; `here` is "this Mac" or "this PC"."""
- entry = _entry(settings, peer)
- by_bytes = _id_bytes(by)
- if entry is None or entry.get("port") == 0 or edge not in EDGES or by_bytes is None:
- return False, []
- told = isinstance(way_back, bool) and entry.get("way_back") is not way_back
- if told:
- entry["way_back"] = way_back
+ """Compatibility wrapper; advertised caps select the picture or old-peer path."""
+ from core import crossing_state, protocol
+ capable = {settings.get("machine_id", "")}
+ capable.update(p.get("id") for p in settings.get("peers", []) if "layout" in p.get("caps", []))
+ read = dict(edge=edge, set_at=set_at, by=protocol.read_id(by))
if isinstance(way_back, bool):
- holder = _id_bytes(way_back_by)
- valid_holder = holder is not None and way_back is False and holder != _id_bytes(settings.get("machine_id"))
- if valid_holder:
- valid_text = way_back_by
- if entry.get("way_back_by") != valid_text:
- entry["way_back_by"] = valid_text
- told = True
- elif "way_back_by" in entry:
- del entry["way_back_by"]
- told = True
- held = (int(entry.get("side_set_at") or 0), _id_bytes(entry.get("side_by")) or b"")
- if (int(set_at), by_bytes) <= held:
- return told, []
- entry.update(side=return_edge.OPPOSITE[edge], side_set_at=int(set_at), side_by=by)
- if corner_edge is not None:
- for zone in settings["zones"]:
- if zone.get("peer") == peer and zone.get("kind") == "corner" and zone.get("corner") in CORNERS:
- zone["edge"] = corner_edge(zone["corner"], entry["side"])
- if peer not in {zone.get("peer") for zone in settings["zones"]}:
- settings["zones"].append({"peer": peer, "kind": "edge"})
- return True, _turn_off_clashes(settings, entry, here, live)
+ read.update(way_back=way_back, way_back_by=protocol.read_id(way_back_by))
+ out = crossing_state.receive_arrangement(settings, peer, read,
+ platform="mac" if "mac" in here.lower() else "pc", capable=capable,
+ live=live, gone=None, now=time.time())
+ settings.clear()
+ settings.update(out["settings"])
+ return out["changed"], []
def _zoned(entry: dict) -> bool:
@@ -412,35 +1097,27 @@ def default_side(settings: dict) -> bool:
def ensure_zones(settings: dict) -> bool:
- """Gives every machine with no zone at all its whole edge, `off` when its side is another machine's
- already, so the settings stay readable (section 8, overlap). Pairing never made zones before
- 1.5.0-beta.5, so a machine paired since 1.4.x has none until this runs. True when it added any."""
- sides = {entry.get("id"): entry.get("side", "") for entry in settings["peers"]}
- covered = set()
- for zone in settings["zones"]:
- if zone.get("off") is not True:
- covered |= _stretch(zone, sides)
- zoned = {zone.get("peer") for zone in settings["zones"]}
- added = False
- for entry in settings["peers"]:
- if not _zoned(entry) or entry["id"] in zoned:
- continue
- zone = {"peer": entry["id"], "kind": "edge"}
- stretch = _stretch(zone, sides)
- if stretch & covered:
- zone["off"] = True
- else:
- covered |= stretch
- settings["zones"].append(zone)
- added = True
- return added
+ """Compatibility loader: seed intent and compile instead of persisting off zones."""
+ from core import crossing_state
+ out = crossing_state.migrate(settings, _platform(settings))
+ settings.clear()
+ settings.update(out["settings"])
+ return out["changed"]
def has_way(settings: dict, peer: str) -> bool:
"""Whether a zone in use leads to `peer` and can fire: a corner or the notch, or an edge or thirds
of a side that is set. What `arrangement`'s `way_back` says to that machine."""
sides = {entry.get("id"): entry.get("side", "") for entry in settings["peers"]}
- return any(zone.get("peer") == peer and zone.get("off") is not True and _stretch(zone, sides)
+ return any(zone.get("peer") == peer and zone.get("off") is not True and _stretch(zone, sides, settings["peers"])
+ for zone in settings["zones"])
+
+
+def crosses_on_map(settings: dict, peer: str) -> bool:
+ """Whether an active edge, part or corner crosses the peer's contact on the map."""
+ sides = {entry.get("id"): entry.get("side", "") for entry in settings["peers"]}
+ return any(zone.get("peer") == peer and zone.get("kind") in ("edge", "part", "corner")
+ and zone.get("off") is not True and _stretch(zone, sides, settings["peers"])
for zone in settings["zones"])
@@ -459,7 +1136,7 @@ def blocked_sentence(settings: dict, peer: str, here: str, live: Optional[Callab
name = peerlist.label_for(peers, peer_id=peer) or peerlist.UNNAMED
other = peerlist.label_for(peers, peer_id=holder) or peerlist.UNNAMED
return (f"{name} has no way in: {other} already leads from the {side} edge of {here}. Give each its own "
- "thirds of that edge under Part of the edge, or move one to another side.")
+ "thirds of that edge by moving the machines on the map, or move one to another side.")
def no_way_back_sentence(settings: dict, peer: str) -> str:
@@ -506,97 +1183,35 @@ def _side_holders(settings: dict, peer: str, live: Optional[Callable[[str], bool
if side not in EDGES:
return []
sides = {item.get("id"): item.get("side", "") for item in settings["peers"]}
- stretches = {(side, part) for part in PARTS}
holders = []
for zone in settings["zones"]:
owner = zone.get("peer")
if (owner != peer and owner not in holders and zone.get("off") is not True
- and zone.get("kind") in ("edge", "part") and _stretch(zone, sides) & stretches
+ and zone.get("kind") in ("edge", "part")
+ and any(_stretch_side(stretch) == side for stretch in _stretch(zone, sides, settings["peers"]))
and (live is None or live(owner))):
holders.append(owner)
return holders
-def settle(settings: dict, peer: str, here: str, live: Optional[Callable[[str], bool]] = None) -> list:
- """After a machine's side moved here: its zones that now clash with another machine's are turned
- off, as when the side arrives from that machine, and a sentence for each is returned. With
- `live`, a machine with no link now gives way instead (`give_way`)."""
- entry = _entry(settings, peer)
- return _turn_off_clashes(settings, entry, here, live) if entry is not None else []
+def settle(settings: dict, peer: str, here: str, live=None) -> list:
+ """No-op: compilation already assigns every stretch once."""
+ return []
-def give_way(settings: dict, peer: str, here: str, live: Optional[Callable[[str], bool]]) -> list:
- """Sets aside every zone in use of a machine with no link now (`live(id)` false) that covers a
- stretch one of `peer`'s zones in use covers, and returns a sentence for each. The zone is `off`
- and carries `aside`: a machine with its lid shut is not gone, so `settle_presence` puts the zone
- back when it connects, and turns it off for good only when it is found to have removed this one
- (06-10-2026). Nothing without `live`."""
- if live is None:
- return []
- sides = {item.get("id"): item.get("side", "") for item in settings["peers"]}
- wanted = set()
- for zone in settings["zones"]:
- if zone.get("peer") == peer and zone.get("off") is not True:
- wanted |= _stretch(zone, sides)
- peers = settings["peers"]
- name = peerlist.label_for(peers, peer_id=peer) or peerlist.UNNAMED
- notices = []
- for zone in settings["zones"]:
- owner = zone.get("peer")
- if owner == peer or zone.get("off") is True or not (_stretch(zone, sides) & wanted) or live(owner):
- continue
- zone["off"] = True
- zone["aside"] = True
- other = peerlist.label_for(peers, peer_id=owner) or peerlist.UNNAMED
- notices.append(f"{other} is not connected, so {name} takes that part of {here}'s screen for now and "
- f"{other}'s {KIND_WORDS.get(zone.get('kind'), 'zone')} is set aside until it connects.")
- return notices
-
-
-def presence_due(settings: dict, live: Callable[[str], bool], gone: Callable[[str], bool]) -> bool:
- """Whether `settle_presence` would change anything now: a zone is set aside (`give_way`) for a
- machine that has connected, or has removed this pairing, since."""
- if not any(zone.get("aside") is True for zone in settings["zones"]):
- return False
- probe = copy.deepcopy(settings)
- settle_presence(probe, "", live, gone)
- return probe != settings
+def give_way(settings: dict, peer: str, here: str, live=None) -> list:
+ """No-op: a sleeping machine retains its intent and picture."""
+ return []
-def settle_presence(settings: dict, here: str, live: Callable[[str], bool], gone: Callable[[str], bool]) -> list:
- """What became of the zones `give_way` set aside, as the links stand now: a machine with a link
- up has its zone back unless another zone in use covers that stretch (then it stays off, as when two
- machines that are both here want one stretch, and the Crossing page offers the thirds), and a machine
- `gone(id)` says has removed this pairing keeps its zone off for good. Returns a sentence for each
- zone it settled, apart from those put back; settings change in place."""
- sides = {item.get("id"): item.get("side", "") for item in settings["peers"]}
- peers = settings["peers"]
- notices = []
- for zone in settings["zones"]:
- if zone.get("aside") is not True:
- continue
- owner = zone.get("peer")
- if zone.get("off") is not True:
- del zone["aside"]
- continue
- name = peerlist.label_for(peers, peer_id=owner) or peerlist.UNNAMED
- word = KIND_WORDS.get(zone.get("kind"), "zone")
- if gone(owner):
- del zone["aside"]
- notices.append(f"{name} no longer has this pairing, so its {word} stays off. Remove {name} here and "
- "pair the two again.")
- elif live(owner):
- del zone["aside"]
- stretch = _stretch(zone, sides)
- holder = next((other.get("peer") for other in settings["zones"] if other is not zone
- and other.get("off") is not True and _stretch(other, sides) & stretch), None)
- if holder is None:
- del zone["off"]
- else:
- held = peerlist.label_for(peers, peer_id=holder) or peerlist.UNNAMED
- notices.append(f"{name} is connected again, but {held} leads from that part of {here}'s screen, so "
- f"{name}'s {word} stays off. Share the side on the Crossing page.")
- return notices
+def presence_due(settings: dict, live, gone) -> bool:
+ """No-op: no aside state remains to settle."""
+ return False
+
+
+def settle_presence(settings: dict, here: str, live, gone) -> list:
+ """No-op: events recompile instead of restoring zone history."""
+ return []
def gone_sentence(settings: dict, peer: str, here: str, gone: Callable[[str], bool]) -> str:
@@ -610,33 +1225,11 @@ def gone_sentence(settings: dict, peer: str, here: str, gone: Callable[[str], bo
return f"{name} no longer has this pairing, so it has no way in. Remove {name} here and pair the two again."
-def _turn_off_clashes(settings: dict, entry: dict, here: str, live: Optional[Callable[[str], bool]] = None) -> list:
- notices = give_way(settings, entry.get("id"), here, live)
- sides = {item.get("id"): item.get("side", "") for item in settings["peers"]}
- peers = settings["peers"]
- covered = {}
- mine = []
- for zone in settings["zones"]:
- if zone.get("off") is True:
- continue
- if zone.get("peer") == entry.get("id"):
- mine.append(zone)
- continue
- for stretch in _stretch(zone, sides):
- covered.setdefault(stretch, zone.get("peer"))
- name = peerlist.label_for(peers, peer_id=entry.get("id")) or peerlist.UNNAMED
- for zone in mine:
- stretch = _stretch(zone, sides)
- other = next((covered[item] for item in sorted(stretch) if item in covered), None)
- if other is None:
- for item in stretch:
- covered.setdefault(item, entry.get("id"))
- continue
- zone["off"] = True
- other_name = peerlist.label_for(peers, peer_id=other) or peerlist.UNNAMED
- notices.append(f"{other_name} and {name} now lead from the same part of {here}'s screen, so {name}'s "
- f"{KIND_WORDS.get(zone.get('kind'), 'zone')} is off.")
- return notices
+
+
+def _turn_off_clashes(settings: dict, entry: dict, here: str, live=None) -> list:
+ """No-op retained for older callers: compilation resolves overlap."""
+ return []
def _sendable(entry: dict) -> bool:
@@ -657,6 +1250,83 @@ def shortcut_peer(peers: list, last: Optional[str], ready: Callable[[str], bool]
return next((ident for ident in candidates if ready(ident)), fallback)
+def shortcut_order(peers: list, machine_id: str, positions: dict, mode: str = "next") -> list:
+ """Sendable peers in drawing reading order, rotated after this machine, followed by home.
+
+ `positions` maps machine ids to the frames returned by the arrangement drawing. Entries without
+ a frame follow in peers-list order; `None` at the end is home.
+ """
+ entries = [entry for entry in peers if _sendable(entry)
+ and (mode != "ticked" or entry.get("shortcut_cycle") is not False)]
+ placed = []
+ unplaced = []
+ for index, entry in enumerate(entries):
+ ident = entry["id"]
+ frame = positions.get(ident)
+ if frame is None:
+ unplaced.append((index, ident))
+ else:
+ x, y, _width, height = frame
+ placed.append((y + height / 2, x + _width / 2, height, index, ident))
+ placed.sort(key=lambda item: (item[0], item[1], item[3]))
+ rows = []
+ for item in placed:
+ centre_y, _centre_x, height, _index, ident = item
+ if not rows or centre_y - rows[-1][0][0] > min(height, rows[-1][0][2]) / 2:
+ rows.append([item])
+ else:
+ rows[-1].append(item)
+ reading = [item[4] for row in rows for item in sorted(row, key=lambda item: (item[1], item[3]))]
+ home = positions.get(machine_id)
+ if home is not None:
+ hx, hy, _hw, hh = home
+ hcy, hcx = hy + hh / 2, hx + _hw / 2
+ insertion = next((index for index, ident in enumerate(reading)
+ if positions[ident][1] + positions[ident][3] / 2 - hcy >
+ min(positions[ident][3], hh) / 2 or
+ (abs(positions[ident][1] + positions[ident][3] / 2 - hcy) <=
+ min(positions[ident][3], hh) / 2 and
+ positions[ident][0] + positions[ident][2] / 2 > hcx)), len(reading))
+ reading[insertion:insertion] = []
+ before = reading[:insertion]
+ after = reading[insertion:]
+ reading = after + before
+ reading.extend(ident for _index, ident in unplaced)
+ return reading + [None]
+
+
+def next_target(settings: dict, order: list, current: Optional[str], ready: Callable[[Optional[str]], bool]):
+ """Next ready peer or home, and the peer ids skipped because they are not ready."""
+ peers = [ident for ident in order if ident is not None]
+ if current is None:
+ start = 0
+ else:
+ start = peers.index(current) + 1 if current in peers else 0
+ candidates = peers[start:]
+ skipped = []
+ for ident in candidates:
+ if ready(ident):
+ return ident, skipped
+ skipped.append(ident)
+ if current is None and peers:
+ return peers[0], skipped
+ return None, skipped
+
+
+def hold_target(settings: dict, order: list, last: Optional[str], ready: Callable[[str], bool]):
+ """The Hold-style destination and any preceding peers that were not ready."""
+ peers = [ident for ident in order if ident is not None]
+ candidates = peers
+ if settings.get("shortcut_goes_to", "last") == "last" and last in peers:
+ candidates = [last] + [ident for ident in peers if ident != last]
+ skipped = []
+ for ident in candidates:
+ if ready(ident):
+ return ident, skipped
+ skipped.append(ident)
+ return (peers[0] if peers else None), skipped
+
+
def missing_pairings(settings: dict, peer: str) -> list:
"""The machines that may drive this one and that a zone to `peer` cannot take onward, because
they are not paired with `peer` (section 5, "What the Crossing page may offer"). A machine is
diff --git a/flatpak/uk.co.kalkman.beamer.desktop b/flatpak/uk.co.kalkman.beamer.desktop
index 5788541..b0700db 100644
--- a/flatpak/uk.co.kalkman.beamer.desktop
+++ b/flatpak/uk.co.kalkman.beamer.desktop
@@ -5,6 +5,7 @@ Comment=Share one keyboard and mouse between your computers
Exec=beamer
Icon=uk.co.kalkman.beamer
Terminal=false
-Categories=Utility;Network;
+Categories=Utility;
Keywords=keyboard;mouse;clipboard;sharing;
StartupNotify=true
+StartupWMClass=Beamer
diff --git a/flatpak/uk.co.kalkman.beamer.metainfo.xml b/flatpak/uk.co.kalkman.beamer.metainfo.xml
index 89c427e..3469063 100644
--- a/flatpak/uk.co.kalkman.beamer.metainfo.xml
+++ b/flatpak/uk.co.kalkman.beamer.metainfo.xml
@@ -2,17 +2,55 @@
<component type="desktop-application">
<id>uk.co.kalkman.beamer</id>
<name>Beamer</name>
- <summary>Share one keyboard and mouse between your computers</summary>
+ <summary>Share input across computers</summary>
<metadata_license>CC0-1.0</metadata_license>
<project_license>GPL-3.0-only</project_license>
<developer id="uk.co.kalkmancode"><name>Kalkman Code</name></developer>
<description>
- <p>Beamer shares your keyboard, mouse and clipboard between paired computers on your network. Move through a screen edge to control another computer.</p>
- <p>On Linux, Beamer uses the desktop's input capture, remote desktop and clipboard portals on Wayland, or X11. Wayland support depends on the portals your desktop provides. Crossing effects are unavailable on Wayland.</p>
+ <p>Use one keyboard and mouse across paired computers on your local network. Push the pointer through a screen edge or use a shortcut to switch machines, and take the clipboard with you.</p>
+ <p>On Wayland, the desktop controls input capture. Beamer can send input out when the pointer crosses an edge, but its shortcut only brings input back. It cannot hold an edge for a full-screen app, keep selected keys on the Linux computer while input is away, or draw crossing effects at the Linux screen edge.</p>
+ <p>On X11, Beamer can send and receive input across paired computers, including keyboard, pointer and clipboard. The Linux build has been tested on Fedora 44 with GNOME 50 under Wayland; X11 on real hardware and KDE Plasma have not been tested.</p>
</description>
<launchable type="desktop-id">uk.co.kalkman.beamer.desktop</launchable>
<url type="homepage">https://kalkmancode.co.uk/beamer</url>
<url type="bugtracker">https://github.com/kalkman-code/beamer/issues</url>
+ <url type="vcs-browser">https://github.com/kalkman-code/beamer</url>
+ <url type="contribute">https://github.com/kalkman-code/beamer/blob/v1.5.2/CONTRIBUTING.md</url>
+ <branding>
+ <color type="primary" scheme_preference="light">#006a88</color>
+ <color type="primary" scheme_preference="dark">#5fd4f4</color>
+ </branding>
+ <supports>
+ <control>keyboard</control>
+ <control>pointing</control>
+ </supports>
+ <recommends>
+ <display_length compare="ge">768</display_length>
+ </recommends>
+ <screenshots>
+ <screenshot type="default">
+ <image>https://raw.githubusercontent.com/kalkman-code/beamer/v1.5.2/assets/linux-overview.png</image>
+ <caption>See which machine has input and manage paired computers</caption>
+ </screenshot>
+ <screenshot>
+ <image>https://raw.githubusercontent.com/kalkman-code/beamer/v1.5.2/assets/linux-crossing.png</image>
+ <caption>Choose where input crosses between screens</caption>
+ </screenshot>
+ <screenshot>
+ <image>https://raw.githubusercontent.com/kalkman-code/beamer/v1.5.2/assets/linux-design.png</image>
+ <caption>Choose crossing styles and colours for screen edges and machine hand-offs</caption>
+ </screenshot>
+ </screenshots>
<content_rating type="oars-1.1"/>
- <releases><release version="@VERSION@" timestamp="@TIMESTAMP@"/></releases>
+ <releases>
+ <release version="1.5.2" date="2026-10-08">
+ <description><p>Adds the shared desk map, granular settings, dormant pairing repair and Linux crossing effects.</p></description>
+ </release>
+ <release version="1.5.1" date="2026-10-06">
+ <description><p>Fixes the Linux key-box hint and other issues found in the 1.5.0 release.</p></description>
+ </release>
+ <release version="1.5.0" date="2026-10-06">
+ <description><p>Adds Linux support and expands multi-computer support.</p></description>
+ </release>
+ </releases>
</component>
diff --git a/mac_app/bridge.py b/mac_app/bridge.py
index 57a9d3c..b4e9e03 100644
--- a/mac_app/bridge.py
+++ b/mac_app/bridge.py
@@ -23,6 +23,7 @@ import desktop_mac
from input_injector_mac import INJECTED_MARK
import gestures
from core import ignored
+from core import crossing_state
import keyboard_layout
import media_keys
from core import keytable
@@ -30,7 +31,9 @@ from core import link as link_module
from core import owner as owner_module
from core import peerlist
from core import protocol
+from core import special_keys
from core import receiver
+from core import settings_sync
from core import ways
from pointer_hide import PointerHider
from key_codes import (
@@ -58,14 +61,15 @@ SSH_FALLBACK_HOST = "127.0.0.1"
SSH_FALLBACK_PORT = 24822
DESKTOP_BOUNDS_MAX_AGE_SECONDS = 1.0
CROSSING_RETRY_SECONDS = 30.0
+TAP_HID_STALL_SECONDS = 2.0
ROUND_TRIP_SAMPLES = 8
ROUND_TRIP_MAX_AGE_SECONDS = 5.0
# A driven Mac that is asked to drive waits this long for its owner to let go (the responder ends
# the ownership by force after one second), then goes ahead.
LET_GO_WAIT_SECONDS = 1.3
OWN_PLATFORM = "macos"
-CAPABILITIES = ("clipboard", "clipboard_image", "gestures", "media_keys", "text", "settings", "design_sync")
-MEDIA_KEY_NAMES = frozenset({"volume_mute", "volume_down", "volume_up", "media_next", "media_prev", "media_stop", "media_play_pause"})
+CAPABILITIES = ("clipboard", "clipboard_image", "gestures", "media_keys", "text", "settings", "design_sync", "layout", "displays", "ping_rtt")
+MEDIA_KEY_NAMES = frozenset({"volume_mute", "volume_down", "volume_up", "media_next", "media_prev", "media_stop", "media_play_pause", "brightness_up", "brightness_down"})
# Why input came home, in words, for the alert. A why that is not here comes home quietly.
WHY_TEXT = {
@@ -571,6 +575,8 @@ class KVMController:
self.last_trigger_down = 0.0
self.trigger_suppressed = False
self.redirect_started_at = 0.0
+ self._last_tap_event_at = self.clock()
+ self._move_reason = None
self.ignore_gate = ignored.Gate(cfg.ignored_inputs)
# Crossing: the engine is pure and runs on the event-tap thread; the
# desktop bounds come from CoreGraphics (already in the top-left
@@ -647,8 +653,16 @@ class KVMController:
# The machines, and which one a shortcut or a status means
def _crossing_engine(self):
- """This Mac's zones for every machine it sends to (WIRE.md section 8). A controller made from a
- Config alone has the flat crossing settings for its one machine instead."""
+ """This Mac's zones for every machine it sends to (WIRE.md section 8), keeping the arrival grace
+ of the engine it replaces: a link up or a save just after a landing must not end it."""
+ engine = self._fresh_crossing_engine()
+ previous = getattr(self, "crossing", None)
+ if isinstance(previous, crossing.CrossingEngine):
+ engine.keep_grace(previous)
+ return engine
+
+ def _fresh_crossing_engine(self):
+ """A controller made from a Config alone has the flat crossing settings for its one machine."""
if self._memory is not None:
if not self.cfg.send_to_windows:
return crossing.CrossingEngine(resistance_px=self.cfg.crossing["resistance_px"],
@@ -662,6 +676,116 @@ class KVMController:
"""A machine's side or zones changed in the settings: the engine is built again from them."""
self.crossing = self._crossing_engine()
+ def crossing_capable(self):
+ known = getattr(self, "_crossing_known_caps", {})
+ known.update({peer: frozenset(link.caps) for peer, link in list(self._peers_up.items())})
+ if self.responder is not None:
+ known.update({protocol.id_text(peer): self.responder.caps_of(peer) or frozenset()
+ for peer in self.responder.links()})
+ with self.book.lock:
+ settings = self.book._load()
+ peers = {entry.get("id") for entry in settings.get("peers", [])}
+ inferred = {entry.get("id") for entry in settings.get("peers", [])
+ if entry.get("id") not in known and entry.get("from_1_4") is not True
+ and entry.get("id") in settings.get("layout", {})}
+ self._crossing_known_caps = {peer: caps for peer, caps in known.items() if peer in peers}
+ capable = inferred | {peer for peer, caps in self._crossing_known_caps.items() if "layout" in caps}
+ capable.add(protocol.id_text(self.identity()["id"]))
+ return capable
+
+ def _save_crossing(self, outcome, capable):
+ if not outcome["changed"]:
+ return
+ store = getattr(self.book._save, "__self__", None)
+ if store is not None and hasattr(store, "_config"):
+ store._crossing_capable = capable
+ self.book._save(outcome["settings"])
+ if store is not None and hasattr(store, "_config"):
+ from settings_store import MOVED_CROSSING
+
+ saved = store._config(store.current())
+ # Crossing events own peer ways, not local controls awaiting their debounced save.
+ with self._cfg_lock:
+ self.cfg = dataclasses.replace(self.cfg, crossing={
+ **self.cfg.crossing,
+ **{name: saved.crossing[name] for name in MOVED_CROSSING},
+ })
+
+ def crossing_event(self, handler, *args, arrived=None, **kwargs):
+ """Compute and save atomically, releasing the book before taking responder locks."""
+ capable = kwargs.setdefault("capable", self.crossing_capable())
+ with self.book.lock:
+ outcome = handler(self.book._load(), *args, **kwargs)
+ self._save_crossing(outcome, capable)
+ return self.carry_crossing(outcome, source=kwargs.get("source"), arrived=arrived, saved=True)
+
+ def carry_crossing(self, outcome, source=None, arrived=None, saved=False):
+ """Save, rebuild and re-arm before publishing a crossing event's messages."""
+ if not (outcome["changed"] or outcome["tell"] or outcome["send_picture"] or outcome["forward_picture"]):
+ return outcome
+ if outcome["changed"] and not saved:
+ capable = self.crossing_capable()
+ with self.book.lock:
+ self._save_crossing(outcome, capable)
+ self.zones_changed()
+ server = self.responder
+ if server is not None:
+ server.peers_changed()
+ server.rearm()
+ with self.book.lock:
+ held = copy.deepcopy(self.book._load())
+ for peer in outcome["tell"]:
+ entry = ways._entry(held, peer)
+ if entry is None or entry.get("side") not in crossing.EDGES:
+ continue
+ sent = self.send_arrangement(peer, entry["side"], entry.get("side_set_at", 0), entry.get("side_by"))
+ if not sent and server is not None:
+ server.send(protocol.read_id(peer), protocol.arrangement_v6(
+ entry["side"], int(entry.get("side_set_at", 0)),
+ protocol.read_id(entry.get("side_by")) or bytes(self.identity()["id"]),
+ way_back=self.way_back(peer), way_back_by=protocol.read_id(self.way_back_by(peer))))
+ if outcome["send_picture"]:
+ for message in self.announce():
+ if message.get("type") == protocol.MSG_SETTINGS:
+ self._send_crossing_picture(message["data"])
+ if outcome["forward_picture"] and arrived is not None:
+ self._send_crossing_picture(arrived, source=source)
+ return outcome
+
+ def _send_crossing_picture(self, data, source=None):
+ capable = self.crossing_capable()
+ outbound = set()
+ for peer, link in list(self._peers_up.items()):
+ if peer != source and peer in capable and link.live():
+ link.post(protocol.settings_msg(settings_sync.for_capabilities(data, link.caps)))
+ outbound.add(peer)
+ if self.responder is not None:
+ for ident in self.responder.links():
+ peer = protocol.id_text(ident)
+ if peer != source and peer in capable and peer not in outbound:
+ caps = self.responder.caps_of(ident) or ()
+ self.responder.send(ident, protocol.settings_msg(settings_sync.for_capabilities(data, caps)))
+
+ def crossing_link_up(self, peer):
+ return self.crossing_event(crossing_state.link_up, peer, platform="mac",
+ own_displays=self.crossing_display_map(), now=time.time())
+
+ def crossing_display_map(self):
+ try:
+ return desktop_mac.display_map()
+ except RuntimeError:
+ with self.book.lock:
+ return copy.deepcopy(self.book._load().get("layout", {}).get(
+ protocol.id_text(self.identity()["id"]), {}).get("displays", {}))
+
+ def crossing_displays_changed(self):
+ displays = self.crossing_display_map()
+ if displays == getattr(self, "_crossing_displays", None):
+ return
+ self.crossing_event(crossing_state.displays_changed, platform="mac",
+ own_displays=displays, now=time.time())
+ self._crossing_displays = copy.deepcopy(displays)
+
def _ready(self, peer):
"""Whether `peer` can take this Mac's input now: its link is up and it accepts input."""
link = self._peers_up.get(peer) if peer else None
@@ -703,6 +827,38 @@ class KVMController:
return link.peer_id if link is not None and link.peer_id else None
return ways.shortcut_peer(self.book.peers(), self._last_peer, self._ready)
+ def _shortcut_cycle(self):
+ peers = self.book.peers()
+ settings = self.book._load() or {}
+ derived = ways.derive_layout(settings, gap=0)
+ layout = derived if not settings.get("layout_set_at", 0) else {
+ **derived, **(settings.get("layout") or {})
+ }
+ shelf = {entry.get("id") for entry in peers if entry.get("left_out") is True
+ or entry.get("in_use", True) is False
+ or getattr(self.links.get(entry.get("token")), "kind", "") == "forgotten"}
+ layout = {peer: tile for peer, tile in layout.items() if peer not in shelf}
+ states = ways.compile_layout(settings, layout).get("tiles", {})
+ own = protocol.id_text(self.identity()["id"])
+ positions = {peer: tuple(tile[key] for key in ("x", "y", "w", "h"))
+ for peer, tile in layout.items() if peer == own or (
+ states.get(peer, {}).get("state") in ("edge", "part", "corner")
+ and ways.has_way(settings, peer))
+ or states.get(peer, {}).get("state") in ("between", "set-elsewhere")}
+ return ways.shortcut_order(peers, own, positions,
+ self.cfg.crossing.get("shortcut_goes_to", "last"))
+
+ def _cycle_target(self):
+ order = self._shortcut_cycle()
+ target, skipped = ways.next_target(self.cfg.crossing, order,
+ protocol.peer_id_text(self.owner.on) if self.owner.on else None, self._ready)
+ self._announce_shortcut_skips(skipped)
+ return target
+
+ def _announce_shortcut_skips(self, skipped):
+ for ident in skipped:
+ self._alert("Beamer", f"Skipped {self._name_of(ident)}: not connected.")
+
def _link_of(self, peer):
"""The link to `peer`, up or not; None when this Mac has none to it."""
link = self._peers_up.get(peer) if peer else None
@@ -962,7 +1118,8 @@ class KVMController:
self.crossing = self._crossing_engine()
self._crossing_failed = False
- def set_redirecting(self, value, edge=None, offset=None, came_home=True, peer=None):
+ def set_redirecting(self, value, edge=None, offset=None, came_home=True, peer=None, reason=None,
+ display=None, side=None):
"""`edge` and `offset` are the edge of the other machine and fraction along it a
crossing arrives at; absent for the shortcut, when it leaves its pointer where it is.
`peer` is the machine to send input to: a zone's, or one a menu names; without it, the
@@ -981,7 +1138,7 @@ class KVMController:
if value:
# A menu naming another machine while input is away moves it straight there (WIRE.md
# section 5, "Moving input"): the owner lets go of the one it leaves in the same route.
- return self._redirect(edge, offset, peer)
+ return self._redirect(edge, offset, peer, reason=reason, display=display, side=side)
self._return_local()
self.logger.info("input returned to this Mac")
if came_home:
@@ -1000,7 +1157,7 @@ class KVMController:
name = self._name_of(peer) if peer else None
return status if not name or name in status else f"{name}: {status}"
- def _redirect(self, edge, offset, peer=None):
+ def _redirect(self, edge, offset, peer=None, reason=None, display=None, side=None):
peer = peer or self._shortcut_peer()
link = self._peers_up.get(peer) if peer else None
if link is None or not link.live():
@@ -1012,7 +1169,7 @@ class KVMController:
# (the responder ends it by force after a second): a machine never does both.
send_home = self.send_peer_home
if send_home is not None and send_home():
- self._go_after_let_go(edge, offset, peer=peer)
+ self._go_after_let_go(edge, offset, peer=peer, display=display, side=side)
return True
self.logger.warning("cannot redirect: another machine is driving this Mac and cannot be reached")
return False
@@ -1021,7 +1178,11 @@ class KVMController:
return False
self.redirect_started_at = self.clock()
self._note_clipboard()
- self._step(lambda owner: owner.go(peer, edge, offset))
+ self._move_reason = reason or ("edge" if edge is not None else "shortcut")
+ try:
+ self._step(lambda owner: owner.go(peer, edge, offset, display=display, side=side))
+ finally:
+ self._move_reason = None
if not self.redirecting or self.owner.on != peer:
return False
responder = self.responder
@@ -1033,7 +1194,7 @@ class KVMController:
return False
return True
- def _go_after_let_go(self, edge, offset, step=None, peer=None):
+ def _go_after_let_go(self, edge, offset, step=None, peer=None, reason=None, display=None, side=None):
if self._letting_go:
return
self._letting_go = True
@@ -1049,7 +1210,8 @@ class KVMController:
if self.receiving or self.stop_event.is_set():
self.logger.warning("the machine driving this Mac did not let go; the move is dropped")
return
- if self.set_redirecting(True, edge, offset, peer=peer) and step is not None:
+ if self.set_redirecting(True, edge, offset, peer=peer, reason=reason,
+ display=display, side=side) and step is not None:
self._notify_crossing("cross", step)
finally:
self._letting_go = False
@@ -1132,6 +1294,7 @@ class KVMController:
except Exception:
self.logger.exception("failed to toggle local cursor association")
return
+ self.logger.debug("CGAssociateMouseAndMouseCursorPosition(%s) returned status %r", follows, status)
# CGAssociateMouseAndMouseCursorPosition's return value was
# previously ignored outright, which is how a macOS version where
# this call is silently ineffective (see _warp_cursor_to_pin, the
@@ -1141,7 +1304,7 @@ class KVMController:
if not self._cursor_assoc_status_logged:
self._cursor_assoc_status_logged = True
self.logger.info(
- "CGAssociateMouseAndMouseCursorPosition(%s) returned status %r (0 == success)",
+ "CGAssociateMouseAndMouseCursorPosition(%s) returned status %r (0 == success; logged once per run)",
follows,
status,
)
@@ -1263,6 +1426,11 @@ class KVMController:
def _event_tap_callback(self, proxy, event_type, event, refcon):
try:
+ if event_type not in (
+ self.quartz.kCGEventTapDisabledByTimeout,
+ self.quartz.kCGEventTapDisabledByUserInput,
+ ):
+ self._last_tap_event_at = self.clock()
if event_type in (
self.quartz.kCGEventTapDisabledByTimeout,
self.quartz.kCGEventTapDisabledByUserInput,
@@ -1522,9 +1690,11 @@ class KVMController:
if send_home is None or not send_home():
self.logger.warning("cannot cross: another machine is driving this Mac and cannot be reached")
return event
- self._go_after_let_go(step.edge, step.offset, step, peer=self._zone_peer(step))
+ self._go_after_let_go(step.edge, step.offset, step, peer=self._zone_peer(step), reason="edge",
+ display=getattr(step, "display", None), side=getattr(step, "side", None))
return event
- if self.set_redirecting(True, edge=step.edge, offset=step.offset, peer=self._zone_peer(step)):
+ if self.set_redirecting(True, edge=step.edge, offset=step.offset, peer=self._zone_peer(step), reason="edge",
+ display=getattr(step, "display", None), side=getattr(step, "side", None)):
self._notify_crossing("cross", step)
return None
return event
@@ -1574,7 +1744,7 @@ class KVMController:
if self.owner.on == peer:
self.set_redirecting(False)
else:
- self.set_redirecting(True, peer=peer)
+ self.set_redirecting(True, peer=peer, reason=f"jump chord {chord}")
return True
def _current_desktop_bounds(self):
@@ -1637,10 +1807,7 @@ class KVMController:
return self.crossing.pressure_at(self.clock())
def _handle_system_event(self, event):
- """Forward a media/volume key press. Anything that is not one --
- brightness, keyboard backlight, and the undocumented subtypes that
- share NSSystemDefined -- passes through to macOS untouched, as does a
- media key kept on this Mac and everything when not redirecting."""
+ """Forward recognised media and brightness presses; unrelated system-defined events pass through."""
if not self.redirecting:
return event
try:
@@ -1684,6 +1851,11 @@ class KVMController:
# the user is looking at Windows.
fields = self._read_dock_event(event)
messages = self.dock_classifier.translate(fields) if fields is not None else []
+ elif event_type == gestures.GESTURE_TYPE:
+ fields = self._read_cg_gesture_event(event)
+ if fields is None or fields.get(gestures.GESTURE_FIELD_HID_TYPE) != gestures.GESTURE_ZOOM_HID_TYPE:
+ return event
+ messages = self.gesture_translator.translate_cg_gesture(fields)
else:
gesture_view = self._convert_gesture_event(event)
if gesture_view is None:
@@ -1691,7 +1863,7 @@ class KVMController:
messages = self.gesture_translator.translate(event_type, gesture_view)
if not self._gesture_capture_logged:
self._gesture_capture_logged = True
- self.logger.info("gesture capture active")
+ self.logger.info("gesture capture active; logged once per run")
for message in messages:
try:
self.outbound.put_nowait(message)
@@ -1706,8 +1878,8 @@ class KVMController:
"""Counterpart to _handle_gesture_event for gestures captured by the
overlay NSPanel's ordinary AppKit responder methods (magnifyWithEvent_
/ swipeWithEvent_, see kvm_bridge_app.py) rather than the CGEventTap
- -- macOS 27 beta was observed to never deliver gesture event types
- 29-32 to the tap at all, so this is the path that actually works.
+ -- macOS 27 beta was observed not to deliver gesture event types 29-32
+ to the tap, so the overlay remains a fallback for those NSEvents.
Called from the AppKit main thread while the tap thread runs
concurrently; thread-safe for the same reason the tap path is: it
@@ -1720,7 +1892,7 @@ class KVMController:
return
if not self._overlay_gesture_capture_logged:
self._overlay_gesture_capture_logged = True
- self.logger.info("gesture capture active (overlay)")
+ self.logger.info("gesture capture active (overlay); logged once per run")
try:
messages = self.gesture_translator.translate(event_type, gesture_view)
except Exception:
@@ -1747,6 +1919,24 @@ class KVMController:
self.logger.debug("failed to read a DockControl event", exc_info=True)
return None
+ def _read_cg_gesture_event(self, event):
+ try:
+ quartz = self.quartz
+ return {
+ gestures.GESTURE_FIELD_HID_TYPE: quartz.CGEventGetIntegerValueField(
+ event, gestures.GESTURE_FIELD_HID_TYPE
+ ),
+ gestures.GESTURE_FIELD_MAGNIFICATION: quartz.CGEventGetDoubleValueField(
+ event, gestures.GESTURE_FIELD_MAGNIFICATION
+ ),
+ gestures.GESTURE_FIELD_PHASE: quartz.CGEventGetIntegerValueField(
+ event, gestures.GESTURE_FIELD_PHASE
+ ),
+ }
+ except Exception:
+ self.logger.debug("failed to read a type-29 gesture event", exc_info=True)
+ return None
+
def _default_dock_event_reader(self, event):
quartz = self.quartz
return types.SimpleNamespace(
@@ -1762,6 +1952,11 @@ class KVMController:
was_redirecting = self.redirecting
suppress = was_redirecting or self.trigger_suppressed
changed = False
+ if result.is_down and not result.is_repeat:
+ # rc14 (10-10-2026): a shortcut that "did not register" left no trace, so whether the key
+ # reached the tap at all could not be told from the log.
+ self.logger.info("shortcut key pressed (%s, input %s)", self.cfg.trigger_style,
+ f"on {self._name_of(self.owner.on)}" if self.owner.on else "home")
if self.cfg.trigger_style == "hold":
# Input is on Windows for exactly as long as the key is down. The
# key itself never reaches either machine: it would be a stray
@@ -1770,7 +1965,10 @@ class KVMController:
if result.is_repeat:
return None
if result.is_down:
- self.set_redirecting(True)
+ target, skipped = ways.hold_target(
+ self.cfg.crossing, self._shortcut_cycle(), self._last_peer, self._ready)
+ self._announce_shortcut_skips(skipped)
+ self.set_redirecting(True, peer=target, reason="hold")
else:
self.set_redirecting(False)
return None
@@ -1778,7 +1976,13 @@ class KVMController:
now = self.clock()
threshold = self.cfg.double_tap_ms / 1000.0
if self.last_trigger_down and now - self.last_trigger_down <= threshold:
- changed = self.set_redirecting(not was_redirecting)
+ mode = self.cfg.crossing.get("shortcut_goes_to", "last")
+ if mode == "last":
+ changed = self.set_redirecting(not was_redirecting, reason="shortcut double-tap")
+ else:
+ target = self._cycle_target()
+ changed = self.set_redirecting(target is not None,
+ peer=target, reason="shortcut double-tap")
self.last_trigger_down = 0.0
else:
self.last_trigger_down = now
@@ -1940,33 +2144,20 @@ class KVMController:
def _announce_to(self, link, fields):
"""What this Mac tells a peer the moment the link is up (WIRE.md section 3)."""
- entry = link.entry() or {}
- own = bytes(self.identity()["id"])
- if entry.get("side") in crossing.EDGES:
- by = protocol.read_id(entry.get("side_by")) or own
- link.post(protocol.arrangement_v6(
- entry["side"], entry.get("side_set_at", 0), by, way_back=self.way_back(link.peer_id),
- way_back_by=protocol.read_id(self.way_back_by(link.peer_id)),
- ))
- if "settings" in link.caps:
- try:
- announcements = list(self.announce())
- except Exception:
- self.logger.exception("announce failed")
- announcements = []
- for message in announcements:
- if message.get("type") == protocol.MSG_SETTINGS:
- link.post(message)
+ # `paired` goes before the shared picture: the receiver admits third-party tiles only from
+ # the paired list it holds, and a picture is applied once per stamp.
self._announce_paired(link)
+ self.crossing_link_up(link.peer_id)
+ if "settings" in link.caps and "layout" not in link.caps:
+ for message in self.announce():
+ if message.get("type") == protocol.MSG_SETTINGS:
+ link.post(dict(message, data=settings_sync.for_capabilities(message.get("data", {}), link.caps)))
def _pairing_ids(self):
- return tuple(peer.get("id") for peer in self.book.peers()
- if peer.get("in_use", True) is True and protocol.read_id(peer.get("id")) is not None)
+ return tuple(peerlist.paired_ids(self.book.peers()))
def _announce_paired(self, link):
- ids = [protocol.read_id(peer.get("id")) for peer in self.book.peers()
- if peer.get("in_use", True) is True and peer.get("id") != link.peer_id]
- ids = [ident for ident in ids if ident is not None][:protocol.MAX_PEERS]
+ ids = [protocol.read_id(ident) for ident in peerlist.paired_ids(self.book.peers(), exclude=link.peer_id)]
link.post(protocol.paired_msg(ids))
def _announce_changes(self):
@@ -2070,7 +2261,7 @@ class KVMController:
sent = False
for peer, link in list(self._peers_up.items()):
if peer != source and "settings" in link.caps and link.live():
- sent = link.post(protocol.settings_msg(data)) or sent
+ sent = link.post(protocol.settings_msg(settings_sync.for_capabilities(data, link.caps))) or sent
return sent
# The owner
@@ -2208,6 +2399,12 @@ class KVMController:
if link is None:
return
message = send.message
+ if message.get("type") == protocol.MSG_KEYDOWN and message.get("data", {}).get("key") == "tab":
+ for transition in self._switcher_transition(send.peer, link):
+ if not link.send_input(transition):
+ if link.live():
+ link.drop("The outbound queue filled")
+ return
if message.get("type") == gestures.CHORD:
receiver = "mac" if keytable.is_mac(link.peer_platform) else "windows"
for part in gestures.chord_for(message["data"]["action"], receiver):
@@ -2226,6 +2423,13 @@ class KVMController:
if not sent and link.live():
link.drop("The outbound queue filled")
+ def _switcher_transition(self, peer, link):
+ sent = {physical: name for (sent_peer, physical), name in self._sent_names.items() if sent_peer == peer}
+ messages, held_as = special_keys.switcher_transitions(OWN_PLATFORM, link.peer_platform, sent)
+ for physical, name in held_as.items():
+ self._sent_names[(peer, physical)] = name
+ return messages
+
def _key_style(self):
return config_module.key_map_style(self.cfg.key_map) or self.cfg.key_map
@@ -2240,13 +2444,18 @@ class KVMController:
return message if "media_keys" in link.caps else None
held = (link.peer_id, key)
if message["type"] == protocol.MSG_KEYUP and held in self._sent_names:
- name = self._sent_names.pop(held)
- if any(peer == held[0] and sent == name for (peer, _physical), sent in self._sent_names.items()):
+ sent = {physical: name for (peer, physical), name in self._sent_names.items() if peer == held[0]}
+ name = special_keys.release_key(key, sent)
+ self._sent_names.pop(held)
+ if name is None:
return None
elif message["type"] == protocol.MSG_KEYDOWN and held in self._sent_names:
name = self._sent_names[held]
else:
name = keytable.wire_name(key, OWN_PLATFORM, link.peer_platform, self._key_style())
+ name = special_keys.wire_name(name, OWN_PLATFORM, link.peer_platform)
+ if name is None:
+ return None
if message["type"] == protocol.MSG_KEYDOWN:
self._sent_names[held] = name
data["key"] = name
@@ -2261,7 +2470,13 @@ class KVMController:
f" at the {moved.edge} edge" if isinstance(moved.edge, str) else "",
threading.current_thread().name,
)
+ if moved.why == "switch":
+ self.logger.info("move started by peer request")
+ elif moved.to is not None:
+ cause = self._move_reason or ("edge" if moved.edge else "shortcut")
+ self.logger.info("move started by %s", cause)
if moved.to is not None:
+ self._last_tap_event_at = self.clock()
with self._repair_lock:
self._repair_disagreement_seen = False
if not self.redirecting:
@@ -2273,6 +2488,9 @@ class KVMController:
self._last_peer = moved.to
self.logger.info("redirecting input to %s", self._name_of(moved.to))
return
+ if moved.why == "switch" and moved.edge in crossing.EDGES:
+ # Before the cleanup hands the pointer back to the hand, so no event lands between.
+ self.crossing.start_grace(self.clock())
self._local_cleanup()
other = ""
if isinstance(moved.other, bytes) and moved.other != bytes(self.identity()["id"]):
@@ -2285,9 +2503,9 @@ class KVMController:
self.logger.warning("%s; input returned to this Mac", text)
self._alert("Beamer", text)
if moved.why == "switch":
- self._arrive(moved.edge, moved.offset)
+ self._arrive(moved.edge, moved.offset, moved.display, moved.side)
- def _arrive(self, edge, offset):
+ def _arrive(self, edge, offset, display=None, side=None):
"""The other machine sent input back: land the pointer where it left, `edge` being the edge
of this Mac to arrive at and `offset` the fraction along it. Without an edge the pointer
stays where it was and the arrival says so."""
@@ -2296,7 +2514,8 @@ class KVMController:
if crossed:
try:
point = crossing.CrossingEngine.arrival_point(
- edge, offset, self._current_desktop_bounds(), displays=self._current_displays())
+ edge, offset, self._current_desktop_bounds(), displays=self._current_displays(),
+ display=display, side=side)
except Exception:
self.logger.exception("failed to place the pointer on arrival")
else:
@@ -2395,10 +2614,30 @@ class KVMController:
self.logger.exception("outbound worker recovered")
def _owner_tick(self):
+ self._check_tap_watchdog()
deadline = self.owner.deadline()
if deadline is not None and self.clock() >= deadline:
self._step(lambda owner: owner.tick())
+ def _check_tap_watchdog(self):
+ if not self.redirecting:
+ return
+ try:
+ seconds_ago = float(self.quartz.CGEventSourceSecondsSinceLastEventType(
+ self.quartz.kCGEventSourceStateHIDSystemState,
+ self.quartz.kCGAnyInputEventType,
+ ))
+ except Exception:
+ self.logger.debug("could not read the last HID event time", exc_info=True)
+ return
+ latest_hid_event = self.clock() - seconds_ago
+ if latest_hid_event - self._last_tap_event_at <= TAP_HID_STALL_SECONDS:
+ return
+ self.logger.warning("the event tap is not receiving input while redirected")
+ self._return_local()
+ if self.event_tap is not None:
+ self.quartz.CGEventTapEnable(self.event_tap, True)
+
def _process_outbound(self, message):
"""Handle one dequeued item: input the tap captured, which the owner routes (to the machine
it is on, held for a hand-over, or dropped when it has already come home)."""
diff --git a/mac_app/config.py b/mac_app/config.py
index 8376695..39df0ef 100644
--- a/mac_app/config.py
+++ b/mac_app/config.py
@@ -6,7 +6,7 @@ import json
import os
from dataclasses import dataclass, field
-from core import effects
+from core import effects, settings_sync
from crossing import DEFAULT_CROSSING
DEFAULT_CONFIG_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), "config.json")
@@ -81,9 +81,13 @@ class Config:
# seconds of the last change to that or to a shared value; see settings_sync.
same_on_both: bool = False
same_set_at: int = 0
+ same_groups: list = field(default_factory=list)
# Who made the change the stamp above is for, as a machine id: the tie-break between two ends
# that changed it in the same second (WIRE.md section 10).
same_by: str = ""
+ # Each shared value's own (set_at, by) as `{key: [set_at, by]}`, so an edit carries only what a
+ # person changed (settings_sync.held_stamps; rc14, 10-10-2026).
+ same_stamps: dict = field(default_factory=dict)
design_set_at: int = 0
design_by: str = ""
design_follow_peer: str = ""
@@ -101,6 +105,15 @@ def _stamp(value) -> int:
return int(value) if not isinstance(value, bool) and isinstance(value, (int, float)) and value > 0 else 0
+def _same_stamps(value) -> dict:
+ """The saved per-value stamps, keeping only well-formed pairs for keys that are shared."""
+ if not isinstance(value, dict):
+ return {}
+ pairs = {key: settings_sync._stamp_pair(value.get(key), now=settings_sync.MAX_STAMP)
+ for key in settings_sync.STAMPED_KEYS}
+ return settings_sync.stored_stamps({key: pair for key, pair in pairs.items() if pair is not None})
+
+
def key_map_style(key_map):
"""The name of a key_map when it is one of the two offered styles, else None."""
for name, mapping in KEY_MAP_STYLES.items():
@@ -124,6 +137,10 @@ def load_config(path: str = None) -> Config:
def parse_config(raw: dict) -> Config:
"""A Config from a dict in config.json's shape, the one settings_store hands over from settings.json."""
+ groups = raw.get("same_groups", ["crossing", "design", "shortcut", "names"]
+ if raw.get("same_on_both", False) else [])
+ if not isinstance(groups, list) or any(group not in ("crossing", "design", "shortcut", "names") for group in groups):
+ raise ConfigError("same_groups must contain known group names")
missing = [k for k in ("host", "port", "auth_token") if k not in raw]
if missing:
raise ConfigError(f"config.json is missing required field(s): {', '.join(missing)}")
@@ -152,6 +169,16 @@ def parse_config(raw: dict) -> Config:
if not isinstance(saved_crossing, dict):
raise ConfigError("config.json crossing must be a JSON object")
crossing.update(saved_crossing)
+ if crossing.get("shortcut_goes_to") not in ("last", "next", "ticked"):
+ crossing["shortcut_goes_to"] = "last"
+ (crossing["effect_pace"], crossing["effect_size_fraction"],
+ crossing["effect_length"], crossing["effect_size"]) = effects.design_values(
+ saved_crossing.get("effect_pace"), saved_crossing.get("effect_size_fraction"),
+ saved_crossing.get("effect_length"), saved_crossing.get("effect_size"))
+ # Normalising would quietly replace a preset that is not one; the store's validation refuses it.
+ for name, presets in (("effect_length", effects.LENGTHS), ("effect_size", effects.SIZES)):
+ if name in saved_crossing and saved_crossing[name] not in {value for value, _label in presets}:
+ crossing[name] = saved_crossing[name]
crossing["glow_style"], crossing["glow_colour"], crossing["shortcut_arrival_style"] = effects.offered(
crossing["glow_style"], crossing["glow_colour"], crossing["shortcut_arrival_style"])
crossing["methods"] = list(crossing["methods"])
@@ -178,7 +205,9 @@ def parse_config(raw: dict) -> Config:
hide_addresses=raw.get("hide_addresses", False) is True,
same_on_both=raw.get("same_on_both", False) is True,
same_set_at=_stamp(raw.get("same_set_at", 0)),
+ same_groups=groups,
same_by=str(raw.get("same_by", "") or ""),
+ same_stamps=_same_stamps(raw.get("same_stamps")),
design_set_at=_stamp(raw.get("design_set_at", 0)),
design_by=str(raw.get("design_by", "") or ""),
design_follow_peer=str(raw.get("design_follow_peer", "") or ""),
diff --git a/mac_app/crossing.py b/mac_app/crossing.py
index e866257..ffa2179 100644
--- a/mac_app/crossing.py
+++ b/mac_app/crossing.py
@@ -7,8 +7,8 @@ back; kvm_bridge_app.py reads pressure for the glow. Coordinates are Quartz glob
union of every display as (left, top, right, bottom) with right and bottom exclusive.
Pressure is measured in raw pointer delta units, the same "pixels of travel" the trackpad reports,
-and decays at a rate that empties a full push in DECAY_S once the outward movement stops. That one
-mechanism is what keeps a slow lean against the edge from ever building a switch.
+and decays at a fixed rate so Resistance changes required travel without scaling the sustained-speed
+threshold. That mechanism is what keeps a slow lean against the edge from ever building a switch.
"""
from dataclasses import dataclass
@@ -28,6 +28,7 @@ OPPOSITE = {"left": "right", "right": "left", "top": "bottom", "bottom": "top"}
DEFAULT_CROSSING = {
"methods": ["shortcut", "edge"],
+ "shortcut_goes_to": "last",
"edge": "right",
"corner": "top_right",
"resistance_px": 120,
@@ -51,6 +52,8 @@ DEFAULT_CROSSING = {
# How long an effect takes to play through once the pointer crosses: see effects.LENGTHS.
"effect_length": "normal",
"effect_size": "medium",
+ "effect_pace": 1.0,
+ "effect_size_fraction": 0.045,
# Unix seconds at the moment this Mac last changed the arrangement -- which
# edge leads to the PC. Either machine may change it, so when two ends meet
# holding different answers the newer stamp wins. Never read by the engine;
@@ -59,6 +62,7 @@ DEFAULT_CROSSING = {
}
DECAY_S = 0.4
+DECAY_PX_PER_SECOND = 300.0
CORNER_PX = 8.0
# How close to the last pixel of the desktop counts as touching it. The cursor's reported
# location at an edge is fractional on a Retina display, so an exact comparison misses.
@@ -97,6 +101,8 @@ class Step:
region: tuple = None
via: str = None
peer: str = None
+ display: str = None
+ side: str = None
@dataclass(frozen=True)
@@ -109,6 +115,9 @@ class Ways:
edge: str
parts: frozenset
corner: str
+ display: str = None
+ target_display: str = None
+ target_side: str = None
class CrossingEngine:
@@ -127,8 +136,24 @@ class CrossingEngine:
self.ways = list(ways)
self.resistance_px = float(resistance_px)
self.block_while_dragging = block_while_dragging
+ # Outside reset(): a click while the pointer lands must not end the grace (keep_grace for a rebuild).
+ self._grace_inward = dict.fromkeys(EDGES, 0.0)
+ self._grace_at = None
self.reset()
+ def start_grace(self, now):
+ """The pointer has just landed here from another machine: for ARRIVAL_GRACE_SECONDS no zone
+ builds pressure until the pointer has moved ARRIVAL_GRACE_PX back from its edge, as on the PC.
+ The hand still moving from the push that brought it here otherwise crossed the zone beside the
+ landing, 14 ms after it (rc14, 10-10-2026)."""
+ self._grace_inward = dict.fromkeys(EDGES, 0.0)
+ self._grace_at = now
+
+ def keep_grace(self, previous):
+ """An engine built to replace `previous` (a link up, a settings save) keeps its grace."""
+ self._grace_inward = dict(previous._grace_inward)
+ self._grace_at = previous._grace_at
+
@classmethod
def from_config(cls, crossing):
return cls(
@@ -152,9 +177,14 @@ class CrossingEngine:
peer = zone.get("peer")
if zone.get("off") is True or peer not in sides:
continue
- held = found.setdefault(peer, {"methods": set(), "parts": ("middle",), "corner": "top_right"})
+ display = zone.get("display")
+ edge = zone.get("side", sides[peer])
+ key = (peer, display, edge)
+ held = found.setdefault(key, {"methods": set(), "parts": ("middle",), "corner": "top_right",
+ "target_display": zone.get("target_display"),
+ "target_side": zone.get("target_side")})
kind = zone.get("kind")
- if kind in ("edge", "part") and sides[peer] not in EDGES:
+ if kind in ("edge", "part") and edge not in EDGES:
continue
if kind == "part":
held["parts"] = tuple(part for part in zone.get("parts") or () if part in return_edge.PARTS)
@@ -165,9 +195,10 @@ class CrossingEngine:
elif kind not in ("edge", "notch"):
continue
held["methods"].add(kind)
- ways = [Ways(peer, frozenset(held["methods"]), sides[peer] if sides[peer] in EDGES else "right",
- frozenset(held["parts"]), held["corner"])
- for peer, held in found.items() if held["methods"]]
+ ways = [Ways(peer, frozenset(held["methods"]), edge if edge in EDGES else "right",
+ frozenset(held["parts"]), held["corner"], display, held["target_display"],
+ held["target_side"])
+ for (peer, display, edge), held in found.items() if held["methods"]]
return cls(resistance_px=crossing["resistance_px"], block_while_dragging=crossing["block_while_dragging"],
ways=ways)
@@ -205,6 +236,7 @@ class CrossingEngine:
self.region = None
self._quarter_reached = 0
self._peer = None
+ self._selected_way = None
self._last_at = None
self._last_x = None
self._last_y = None
@@ -226,6 +258,13 @@ class CrossingEngine:
self._last_at = now
previous_x, previous_y = self._last_x, self._last_y
self._last_x, self._last_y = x, y
+ if self._grace_at is not None:
+ if now - self._grace_at >= return_edge.ARRIVAL_GRACE_SECONDS:
+ self._grace_at = None
+ else:
+ for edge, inward in (("left", dx), ("right", -dx), ("top", dy), ("bottom", -dy)):
+ if inward > 0:
+ self._grace_inward[edge] += inward
if dragging and self.block_while_dragging:
self.touching = False
return self._release()
@@ -244,6 +283,8 @@ class CrossingEngine:
if edge_target is not None:
mac_edge, region, diagonal, via, peer = edge_target
outward, inward = self._push(mac_edge, diagonal, x, y, dx, dy, previous_x, previous_y, self._push_box)
+ if self._grace_at is not None and self._grace_inward.get(mac_edge, 0.0) < return_edge.ARRIVAL_GRACE_PX:
+ return self._release()
if self._peer is not None and peer != self._peer:
# Pressure built against one machine's zone is not a push on another's beside it.
self.pressure = 0.0
@@ -270,6 +311,9 @@ class CrossingEngine:
region=region,
via=via,
peer=peer,
+ display=self._selected_way.target_display if self._selected_way else None,
+ side=(self._selected_way.target_side or OPPOSITE[mac_edge])
+ if self._selected_way and self._selected_way.target_display else None,
)
self.reset()
return step
@@ -291,28 +335,48 @@ class CrossingEngine:
)
@staticmethod
- def arrival_point(edge, offset, bounds, inset=2.0, displays=None):
+ def arrival_point(edge, offset, bounds, inset=2.0, displays=None, display=None, side=None):
"""Where the pointer lands when input comes home through a Mac `edge`, `offset` of the
way along it, a couple of points inside so the arrival itself is not already a push. With
`displays`, on the display return_edge.landing_monitor picks, so a staggered or stacked
arrangement never lands it in a gap or on the wrong display."""
left, top, right, bottom = bounds
offset = max(0.0, min(1.0, float(offset)))
- side = edge in ("left", "right")
- along = top + offset * (bottom - 1 - top) if side else left + offset * (right - 1 - left)
+ along_side = edge in ("left", "right")
if displays:
rects = [return_edge.Rect(d[0], d[1], d[2] - d[0], d[3] - d[1]) for d in displays]
- owner = displays[rects.index(return_edge.landing_monitor(rects, edge, along))]
- left, top, right, bottom = owner
- along = min(max(along, top if side else left), (bottom if side else right) - 1)
- if side:
+ if isinstance(display, str) and display.isdigit() and int(display) < len(displays) and side in EDGES:
+ owner = displays[int(display)]
+ edge = side
+ left, top, right, bottom = owner
+ along = top + offset * (bottom - 1 - top) if edge in ("left", "right") else left + offset * (right - 1 - left)
+ else:
+ # The fraction is of the whole edge, as on the PC (return_edge.arrival_position): laid
+ # across the one display it lands on, it put the pointer up to a display's width off.
+ along = top + offset * (bottom - 1 - top) if along_side else left + offset * (right - 1 - left)
+ owner = displays[rects.index(return_edge.landing_monitor(rects, edge, along))]
+ left, top, right, bottom = owner
+ else:
+ along = top + offset * (bottom - 1 - top) if along_side else left + offset * (right - 1 - left)
+ # Clear of both ends, as on the PC (return_edge.LANDING_CLEAR_PX): at an end the pointer sat on
+ # the edge beside it, and the hand still moving crossed that edge to its machine.
+ low, high = (top, bottom - 1) if edge in ("left", "right") else (left, right - 1)
+ clear = return_edge.LANDING_CLEAR_PX if high - low > 2 * return_edge.LANDING_CLEAR_PX else 0
+ cleared = min(max(along, low + clear), high - clear)
+ beyond = {"left": (left - 1, cleared), "right": (right, cleared),
+ "top": (cleared, top - 1), "bottom": (cleared, bottom)}[edge]
+ if displays and any(d[0] <= beyond[0] < d[2] and d[1] <= beyond[1] < d[3] for d in displays):
+ # Moved in along a staggered neighbour's seam: the wall is the exposed end itself.
+ cleared = min(max(along, low), high)
+ along = cleared
+ if edge in ("left", "right"):
return (left + inset if edge == "left" else right - 1 - inset, along)
return (along, top + inset if edge == "top" else bottom - 1 - inset)
def _decay(self, elapsed):
if elapsed <= 0 or self.resistance_px <= 0:
return 0.0
- return self.resistance_px * elapsed / DECAY_S
+ return DECAY_PX_PER_SECOND * elapsed
def _release(self):
self.pressure = 0.0
@@ -321,6 +385,7 @@ class CrossingEngine:
self.region = None
self._quarter_reached = 0
self._peer = None
+ self._selected_way = None
return Step()
def _fraction(self, pressure):
@@ -339,6 +404,7 @@ class CrossingEngine:
section 8): a corner wins over the edge it sits on, since its box is inside that edge's strip.
`ready(peer)`, when given, leaves out the zones of machines that cannot take input now."""
ways = [way for way in self.ways if ready is None or ready(way.peer)]
+ display_frames = {str(index): frame for index, frame in enumerate(displays or ())}
left, top, right, bottom = bounds
x_max, y_max = right - 1, bottom - 1
at = {
@@ -367,19 +433,43 @@ class CrossingEngine:
if near_x and near_y and (at[horizontal] or at[vertical]):
box_x = left if horizontal == "left" else x_max - CORNER_PX + 1
box_y = top if vertical == "top" else y_max - CORNER_PX + 1
+ self._selected_way = way
return horizontal, (box_x, box_y, CORNER_PX, CORNER_PX), vertical, "corner", way.peer
for way in ways:
- if "edge" in way.methods and at[way.edge]:
- self._push_box = edge_box[way.edge]
- return way.edge, self._strip(way.edge, edge_box[way.edge]), None, "edge", way.peer
+ screen = display_frames.get(way.display) if way.display is not None else None
+ edge_at = at[way.edge]
+ if screen is not None:
+ sx, sy, sr, sb = screen
+ edge_at = (sx <= x < sr and sy <= y < sb and {
+ "left": x <= sx + EDGE_TOLERANCE,
+ "right": x >= sr - 1 - EDGE_TOLERANCE,
+ "top": y <= sy + EDGE_TOLERANCE,
+ "bottom": y >= sb - 1 - EDGE_TOLERANCE,
+ }[way.edge])
+ if "edge" in way.methods and edge_at:
+ self._push_box = screen or edge_box[way.edge]
+ self._selected_way = way
+ return way.edge, self._strip(way.edge, self._push_box), None, "edge", way.peer
for way in ways:
- if "part" in way.methods and at[way.edge]:
+ screen = display_frames.get(way.display) if way.display is not None else None
+ edge_at = at[way.edge]
+ if screen is not None:
+ sx, sy, sr, sb = screen
+ edge_at = (sx <= x < sr and sy <= y < sb and {
+ "left": x <= sx + EDGE_TOLERANCE,
+ "right": x >= sr - 1 - EDGE_TOLERANCE,
+ "top": y <= sy + EDGE_TOLERANCE,
+ "bottom": y >= sb - 1 - EDGE_TOLERANCE,
+ }[way.edge])
+ if "part" in way.methods and edge_at:
# The thirds are the pointer's own display's, as the PC measures them: along the whole
# desktop, a short display beside a tall one could hold none of the middle third.
- part = return_edge.part_of(self._offset(way.edge, (x, y), own or bounds))
+ local_bounds = screen or own or bounds
+ part = return_edge.part_of(self._offset(way.edge, (x, y), local_bounds))
if part in way.parts:
- self._push_box = edge_box[way.edge]
- return way.edge, self._part_strip(way.edge, own or bounds, part), None, "edge", way.peer
+ self._push_box = local_bounds
+ self._selected_way = way
+ return way.edge, self._part_strip(way.edge, local_bounds, part), None, "edge", way.peer
for way in ways:
if "notch" in way.methods and notch_range is not None and at["top"]:
notch_left, notch_right = notch_range
diff --git a/mac_app/desktop_mac.py b/mac_app/desktop_mac.py
index 5ce11fb..c8311b3 100644
--- a/mac_app/desktop_mac.py
+++ b/mac_app/desktop_mac.py
@@ -60,6 +60,10 @@ def monitors() -> List[Rect]:
return found
+def display_map() -> dict:
+ return {str(index): rect for index, rect in enumerate(monitors())}
+
+
def cursor_position() -> Tuple[int, int]:
quartz = _require()
location = quartz.CGEventGetLocation(quartz.CGEventCreate(None))
diff --git a/mac_app/diagram.py b/mac_app/diagram.py
index 1ee6049..925c0b8 100644
--- a/mac_app/diagram.py
+++ b/mac_app/diagram.py
@@ -5,6 +5,8 @@ far the pointer is pushed past the edge before it gives."""
from __future__ import annotations
import math
+import copy
+import platform
import AppKit
import Quartz
import objc
@@ -12,6 +14,8 @@ import objc
import motion
import pages
import theme
+from core.resistance_strip import MAX_RESISTANCE, resistance_x
+from core import ways as core_ways
def _rect(frame):
@@ -19,6 +23,16 @@ def _rect(frame):
return ((x, y), (w, h))
+def _set_layer_frame_if_changed(layer, frame):
+ x, y, width, height = frame[0][0], frame[0][1], frame[1][0], frame[1][1]
+ current = layer.frame()
+ if (abs(current.origin.x - x) < 0.01 and abs(current.origin.y - y) < 0.01
+ and abs(current.size.width - width) < 0.01
+ and abs(current.size.height - height) < 0.01):
+ return
+ layer.setFrame_(frame)
+
+
def _text_width(text, font):
return AppKit.NSAttributedString.alloc().initWithString_attributes_(
text, {AppKit.NSFontAttributeName: font}
@@ -68,6 +82,35 @@ def _collapsed(frame, side):
return (x + w / 2, y, 0.0, h)
+# The clear space centred on each third boundary of the selected machine's seam and tracks.
+THIRD_GAP = 2.0
+CYCLE_BOX = 16.0
+
+
+def _at_break(value, breaks):
+ return any(abs(value - point) < 1e-6 for point in breaks)
+
+
+def _split_at_breaks(stretch, breaks):
+ side, low, high = stretch
+ cuts = [low] + sorted(point for point in breaks if low + 1e-6 < point < high - 1e-6) + [high]
+ return [(side, one, two) for one, two in zip(cuts, cuts[1:])]
+
+
+def notch_span(notch_range, displays):
+ """(display key, left, right) of the notch as fractions of its display's width, or None: the
+ display whose x-range holds `notch_range` and whose top is the desktop's, from global rects with
+ x/y/width/height as `desktop_mac.display_map()` gives them."""
+ if not notch_range or not displays:
+ return None
+ left, right = notch_range
+ top = min(rect.y for rect in displays.values())
+ for key, rect in displays.items():
+ if rect.y == top and rect.width > 0 and rect.x <= left and right <= rect.x + rect.width:
+ return key, (left - rect.x) / rect.width, (right - rect.x) / rect.width
+ return None
+
+
class ArrangementDiagram(AppKit.NSView):
"""This Mac's screen in the middle, each placed machine's beside the side it is on, and this
Mac lit where a way in crosses: the chosen machine's ways in the signal colour, the others'
@@ -246,8 +289,7 @@ class ArrangementDiagram(AppKit.NSView):
layer.setFrame_(_rect(frame))
layer.setOpacity_(1.0 if on else 0.0)
return
- # Explicit animations from the collapsed mark: an implicit one would start from wherever
- # the mark was drawn before, inside this same transaction.
+ # An implicit animation would start from the prior frame, not the collapsed mark.
start = _collapsed(frame, side) if side else (frame[0] + frame[2] / 2, frame[1] + frame[3] / 2, 0, 0)
motion.transaction(False)
layer.setFrame_(_rect(frame))
@@ -266,15 +308,1269 @@ class ArrangementDiagram(AppKit.NSView):
grow.setDuration_(motion.DURATION)
grow.setTimingFunction_(motion.timing())
layer.addAnimation_forKey_(grow, key)
+ if not (on and was != state and animate):
+ layer.setFrame_(_rect(frame))
+ layer.setOpacity_(1.0 if on else 0.0)
+
+
+def outcome_for_tile(state, crosses, is_own=False):
+ if is_own:
+ return ""
+ if state == "overlap":
+ return "Overlaps"
+ if state in ("gap", "between", "set-elsewhere", "set_elsewhere"):
+ return "Drag to connect"
+ if not crosses:
+ return "Edge off"
+ return "Crosses"
+
+
+class AtlasAccessibleElement(AppKit.NSObject):
+ def initWithCanvas_key_kind_(self, canvas, key, kind):
+ self = objc.super(AtlasAccessibleElement, self).init()
+ if self is None:
+ return None
+ self.canvas, self.key, self.kind = canvas, key, kind
+ return self
+
+ def accessibilityRole(self):
+ return AppKit.NSAccessibilityCheckBoxRole if self.kind == "cycle" else AppKit.NSAccessibilityButtonRole
+
+ def accessibilityLabel(self):
+ if self.kind == "recentre":
+ name = self.canvas.labels.get(self.canvas.selected, "machine")
+ return f"Recentre {name}"
+ name = self.canvas.labels.get(self.key, f"Machine · {self.key[-6:]}")
+ return f"{name}, In the shortcut's cycle" if self.kind == "cycle" else name
+
+ def accessibilityValue(self):
+ if self.kind == "cycle":
+ return self.canvas.cycle.get(self.key, True) is True
+ return "Selected" if self.canvas.selected == self.key else ""
+
+ def accessibilityParent(self):
+ return self.canvas
+
+ def accessibilityFrame(self):
+ if self.kind == "recentre":
+ return self.canvas._recentre_screen_frame()
+ frames, _scale = self.canvas._map()
+ frame = frames.get(self.key)
+ if frame is None:
+ return AppKit.NSZeroRect
+ if self.kind == "cycle":
+ frame = self.canvas._cycle_hit_rect(frame)
+ rect = AppKit.NSMakeRect(*frame)
+ window = self.canvas.window()
+ if window is None:
+ return rect
+ return window.convertRectToScreen_(self.canvas.convertRect_toView_(rect, None))
+
+ def accessibilityPerformPress(self):
+ if self.kind == "recentre":
+ self.canvas.recentre_selected()
+ return True
+ if self.kind == "cycle":
+ self.canvas.toggle_cycle(self.key)
+ else:
+ self.canvas.select_tile(self.key)
+ return True
+
+
+class AtlasCanvas(AppKit.NSView):
+ """Interactive map of machine tiles; geometry stays in the shared core layout units."""
+
+ HEIGHT = 260.0
+ INSET = 14.0
+
+ @staticmethod
+ def snap_radius_for_scale(scale):
+ return 12 / max(float(scale), 0.01)
+
+ def isFlipped(self):
+ return True
+
+ @objc.python_method
+ def setup(self):
+ self.setTranslatesAutoresizingMaskIntoConstraints_(False)
+ self.heightAnchor().constraintGreaterThanOrEqualToConstant_(self.HEIGHT).setActive_(True)
+ self.setWantsLayer_(True)
+ theme.tint(self.layer(), background="well", border="edge")
+ self.layer().setBorderWidth_(1)
+ self.layer().setCornerRadius_(4)
+ self.tiles = {}
+ self.states = {}
+ self.labels = {}
+ self.older = set()
+ self.selected = None
+ self.own_id = ""
+ self.cycle = {}
+ self.cycle_enabled = False
+ self.keyboard_focus = False
+ self.hovered = None
+ self.focus_layer = _box(None, "ink_2", 4)
+ self.focus_layer.setBorderWidth_(2)
+ self.focus_layer.setHidden_(True)
+ self.layer().addSublayer_(self.focus_layer)
+ self.layer_for_tile = {}
+ self.display_layers = {}
+ self.label_for_tile = {}
+ self.state_for_tile = {}
+ self.outcome_for_tile = {}
+ self.dot_for_tile = {}
+ self.cycle_for_tile = {}
+ self.accessible_elements = {}
+ self.contact_layers = {}
+ self.seam_segments = []
+ self.mark_layers = {}
+ self.corner_halo_layers = {}
+ self.recentre_layer = _box("panel", None, 4)
+ self.recentre_label = _text_layer(theme.TYPE["note"], "ink_3")
+ self.recentre_layer.addSublayer_(self.recentre_label)
+ self.recentre_layer.setHidden_(True)
+ self.recentre_layer.setZPosition_(22)
+ self.layer().addSublayer_(self.recentre_layer)
+ self.recentre_hovered = False
+ self.snap_ghost = Quartz.CAShapeLayer.layer()
+ self.snap_ghost.setFillColor_(AppKit.NSColor.clearColor().CGColor())
+ self.snap_ghost.setStrokeColor_(theme.cg("signal"))
+ self.snap_ghost.setLineWidth_(1)
+ self.snap_ghost.setLineDashPattern_([4, 3])
+ self.snap_ghost.setOpacity_(0.4)
+ self.snap_ghost.setLineCap_(Quartz.kCALineCapRound)
+ self.snap_ghost.setHidden_(True)
+ self.layer().addSublayer_(self.snap_ghost)
+ self.snap_seam = Quartz.CAShapeLayer.layer()
+ self.snap_seam.setFillColor_(AppKit.NSColor.clearColor().CGColor())
+ self.snap_seam.setStrokeColor_(theme.cg("signal"))
+ self.snap_seam.setLineWidth_(4)
+ self.snap_seam.setLineCap_(Quartz.kCALineCapRound)
+ self.snap_seam.setOpacity_(0.5)
+ self.snap_seam.setHidden_(True)
+ self.layer().addSublayer_(self.snap_seam)
+ self.guide_layers = []
+ self.grid_layers = []
+ self.dragging = None
+ self.third_pressed = None
+ self.third_layers = {}
+ self.on_layout_change = None
+ self.on_select = None
+ self.on_third = None
+ self.on_rename = None
+ self.on_cycle_change = None
+ self.on_leave_out = None
+ self.reduced_motion = False
+ self.last_announcement = ""
+ self.setAccessibilityElement_(True)
+ self.setAccessibilityRole_(AppKit.NSAccessibilityGroupRole)
+ self.setAccessibilityLabel_("Whole desk layout")
+ return self
+
+ def acceptsFirstResponder(self):
+ return True
+
+ def resignFirstResponder(self):
+ self.keyboard_focus = False
+ self._draw(False)
+ return True
+
+ @objc.python_method
+ def refresh_keyboard_focus(self):
+ from widgets import keyboard_focus_visible
+
+ self.keyboard_focus = keyboard_focus_visible(self)
+ self._draw(False)
+
+ @objc.python_method
+ def show_layout(self, tiles, states, labels, own_id, selected, cycle=None, cycle_enabled=False,
+ older=(), animate=False):
+ cycle = dict(cycle or {})
+ older = set(older)
+ if (tiles == self.tiles and states == self.states and labels == self.labels
+ and own_id == self.own_id and selected == self.selected
+ and cycle == self.cycle and bool(cycle_enabled) == self.cycle_enabled
+ and older == self.older):
+ return
+ self.tiles = copy.deepcopy(tiles)
+ self.states = copy.deepcopy(states)
+ self.labels = dict(labels)
+ self.own_id = own_id
+ self.selected = selected
+ self.cycle = cycle
+ self.cycle_enabled = bool(cycle_enabled)
+ self.older = older
+ for key in list(self.layer_for_tile):
+ if key not in self.tiles:
+ for layer in self.display_layers.pop(key, []):
+ layer.removeFromSuperlayer()
+ for layer in (self.layer_for_tile.pop(key), self.label_for_tile.pop(key),
+ self.state_for_tile.pop(key), self.outcome_for_tile.pop(key),
+ self.dot_for_tile.pop(key), self.cycle_for_tile.pop(key)):
+ layer.removeFromSuperlayer()
+ self.setAccessibilityLabel_(self.last_announcement or self._description())
+ self.setNeedsLayout_(True)
+ self.setNeedsDisplay_(True)
+ if self.superview() is not None:
+ self.layoutSubtreeIfNeeded()
+ self._draw(animate and not self.reduced_motion)
+
+ @objc.python_method
+ def _description(self):
+ parts = []
+ for key, tile in self.tiles.items():
+ label = self.labels.get(key, f"Machine · {key[-6:]}")
+ state = self.states.get(key, {}).get("state")
+ sentence = self.states.get(key, {}).get("sentence", "")
+ if sentence:
+ parts.append(sentence)
+ elif key == self.own_id:
+ name = self.states.get(key, {}).get("machine_name")
+ parts.append(f"{label}, {name}, this Mac." if name else f"{label}, this Mac.")
+ else:
+ status = self.states.get(key, {})
+ outcome = ("Offline" if not status.get("linked") else
+ "Crosses" if status.get("crosses") else
+ "Edge off" if status.get("edge_off") else
+ outcome_for_tile(state, False))
+ parts.append(f"{label}, {outcome}.")
+ if self.cycle_enabled and key != self.own_id:
+ parts.append(f"{label} is {'in' if self.cycle.get(key, True) else 'out of'} the shortcut's cycle.")
+ return " ".join(parts) or "No machines paired."
+
+ def accessibilityChildren(self):
+ children = []
+ for key in self.tiles:
+ children.append(self.accessible_elements.setdefault(
+ key, AtlasAccessibleElement.alloc().initWithCanvas_key_kind_(self, key, "tile")))
+ if self.cycle_enabled and key != self.own_id:
+ children.append(self.accessible_elements.setdefault(
+ (key, "cycle"), AtlasAccessibleElement.alloc().initWithCanvas_key_kind_(self, key, "cycle")))
+ if self._show_recentre():
+ children.append(self.accessible_elements.setdefault(
+ "recentre", AtlasAccessibleElement.alloc().initWithCanvas_key_kind_(self, self.selected, "recentre")))
+ return children
+
+ @objc.python_method
+ def select_tile(self, key):
+ if key not in self.tiles or key == self.own_id:
+ return
+ self.selected = key
+ if self.on_select:
+ self.on_select(key)
+ self._draw(False)
+
+ @objc.python_method
+ def reading_order(self):
+ placed = sorted(((tile["y"] + tile["h"] / 2, tile["x"] + tile["w"] / 2,
+ tile["h"], key) for key, tile in self.tiles.items() if key != self.own_id))
+ rows = []
+ for item in placed:
+ if not rows or item[0] - rows[-1][0][0] > min(item[2], rows[-1][0][2]) / 2:
+ rows.append([item])
+ else:
+ rows[-1].append(item)
+ return [item[3] for row in rows for item in sorted(row, key=lambda entry: entry[1])]
+
+ @objc.python_method
+ def announce(self, sentence):
+ self.last_announcement = sentence
+ self.setAccessibilityLabel_(sentence)
+ AppKit.NSAccessibilityPostNotificationWithUserInfo(
+ self, AppKit.NSAccessibilityAnnouncementRequestedNotification,
+ {AppKit.NSAccessibilityAnnouncementKey: sentence,
+ AppKit.NSAccessibilityPriorityKey: AppKit.NSAccessibilityPriorityMedium})
+
+ @objc.python_method
+ def announce_move(self, peer, tile, state):
+ name = self.labels.get(peer, f"Machine · {peer[-6:]}")
+ own = self.tiles.get(self.own_id, {})
+ side = "right of" if tile["x"] >= own.get("x", 0) + own.get("w", 0) else \
+ "left of" if tile["x"] + tile["w"] <= own.get("x", 0) else \
+ "below" if tile["y"] >= own.get("y", 0) + own.get("h", 0) else "above"
+ thirds = state.get("thirds", [])
+ third = f", {thirds[0]} third" if len(thirds) == 1 else ""
+ map_state = state.get("state")
+ if not state.get("crosses") and core_ways._rect_contact(own, tile) is None:
+ map_state = "gap"
+ crosses = outcome_for_tile(map_state, state.get("crosses")) + "."
+ self.announce(f"{name}, {side} This Mac{third}. {crosses}")
+
+ @objc.python_method
+ def _layer(self, key):
+ if key not in self.layer_for_tile:
+ tile = _box("panel", "rule", 4)
+ title = _text_layer(theme.TYPE["body"], "ink")
+ title.setFont_(theme.font(theme.TYPE["body"], 600))
+ state = _text_layer(theme.TYPE["eyebrow"], "ink_3")
+ outcome = _text_layer(theme.TYPE["note"], "ink_2")
+ dot = _box("signal", None, 3)
+ cycle = _box("well", "edge", 3)
+ check = Quartz.CAShapeLayer.layer()
+ # The sublayer inherits the view's flipped geometry, so the tick is authored y-down.
+ path = Quartz.CGPathCreateMutable()
+ Quartz.CGPathMoveToPoint(path, None, 4.5, 8.5)
+ Quartz.CGPathAddLineToPoint(path, None, 7, 11)
+ Quartz.CGPathAddLineToPoint(path, None, 11.5, 5)
+ check.setPath_(path)
+ check.setFillColor_(AppKit.NSColor.clearColor().CGColor())
+ theme.tint(check, stroke="ground")
+ check.setLineWidth_(1.8)
+ check.setLineCap_(Quartz.kCALineCapRound)
+ check.setLineJoin_(Quartz.kCALineJoinRound)
+ check.setFrame_(((0, 0), (CYCLE_BOX, CYCLE_BOX)))
+ check.setHidden_(True)
+ cycle.addSublayer_(check)
+ self.layer().addSublayer_(tile)
+ self.layer().addSublayer_(title)
+ self.layer().addSublayer_(state)
+ self.layer().addSublayer_(outcome)
+ self.layer().addSublayer_(dot)
+ self.layer().addSublayer_(cycle)
+ self.layer_for_tile[key] = tile
+ self.label_for_tile[key] = title
+ self.state_for_tile[key] = state
+ self.outcome_for_tile[key] = outcome
+ self.dot_for_tile[key] = dot
+ self.cycle_for_tile[key] = cycle
+ return (self.layer_for_tile[key], self.label_for_tile[key], self.state_for_tile[key],
+ self.outcome_for_tile[key], self.dot_for_tile[key], self.cycle_for_tile[key])
+
+ @staticmethod
+ def _title_top(frame):
+ return frame[1] + (frame[3] - 20) / 2 if frame[3] < 56 else frame[1] + 10
+
+ @objc.python_method
+ def _shows_cycle(self, key):
+ return self.cycle_enabled and key != self.own_id
+
+ @objc.python_method
+ def _title_rect(self, key, frame):
+ """The name's text rect. Beside the shortcut-cycle tick the name stays centred on the tile while
+ it fits the room left symmetric by the tick, else takes the room left of the tick; a tile 44 to
+ 56pt tall puts the name on its own row above the tick."""
+ x, y, width, height = frame
+ if not self._shows_cycle(key):
+ return x + 8, self._title_top(frame), max(1, width - 16), 20
+ if 44 <= height < 56:
+ return x + 8, y + 4, max(1, width - 16), 20
+ room = 8 + CYCLE_BOX + 6
+ label = self.labels.get(key, f"Machine · {key[-6:]}")
+ if height >= 56 and _text_width(label, theme.font(theme.TYPE["body"], 600)) <= width - 2 * room:
+ return x + room, self._title_top(frame), width - 2 * room, 20
+ return x + 8, self._title_top(frame), max(1, self._cycle_box(frame)[0] - 6 - x - 8), 20
+
+ @staticmethod
+ def _cycle_box(frame):
+ """The shortcut-cycle tick: its own column at the right end of the name's line, or in the
+ bottom-right corner of a tile 44 to 56pt tall, under the name."""
+ x, y, width, height = frame
+ if 44 <= height < 56:
+ return x + width - 8 - CYCLE_BOX, y + height - 4 - CYCLE_BOX, CYCLE_BOX, CYCLE_BOX
+ return x + width - 8 - CYCLE_BOX, AtlasCanvas._title_top(frame) + 10 - CYCLE_BOX / 2, CYCLE_BOX, CYCLE_BOX
+
+ @staticmethod
+ def _cycle_hit_rect(frame):
+ x, y, width, height = AtlasCanvas._cycle_box(frame)
+ return x - 4, y - 4, width + 8, height + 8
+
+ @objc.python_method
+ def _map(self):
+ width, height = self.bounds().size.width, self.bounds().size.height
+ if not self.tiles or width <= 0 or height <= 0:
+ return {}, 1.0
+ if self.dragging is not None and all(key in self.dragging for key in ("scale", "map_x", "map_y")):
+ scale = self.dragging["scale"]
+ offset_x, offset_y = self.dragging["map_x"], self.dragging["map_y"]
+ return {key: (tile["x"] * scale + offset_x, tile["y"] * scale + offset_y,
+ tile["w"] * scale, tile["h"] * scale)
+ for key, tile in self.tiles.items()}, scale
+ panels = [frame for tile in self.tiles.values() for frame in core_ways._display_frames(tile)]
+ horizontal = [(tile["x"], tile["x"] + tile["w"]) for tile in self.tiles.values()]
+ vertical = [(tile["y"], tile["y"] + tile["h"]) for tile in self.tiles.values()]
+ horizontal.extend((frame["x"], frame["x"] + frame["w"]) for frame in panels)
+ vertical.extend((frame["y"], frame["y"] + frame["h"]) for frame in panels)
+ left = min(edge for pair in horizontal for edge in pair)
+ right = max(edge for pair in horizontal for edge in pair)
+ top = min(edge for pair in vertical for edge in pair)
+ bottom = max(edge for pair in vertical for edge in pair)
+ cx, cy = (left+right)/2, (top+bottom)/2
+ scale = min((width-2*self.INSET) / max(1, right-left),
+ (height-2*self.INSET) / max(1, bottom-top), 1.15)
+ offset_x = width / 2 - cx * scale
+ offset_y = height / 2 - cy * scale
+ frames = {key: (tile["x"] * scale + offset_x, tile["y"] * scale + offset_y,
+ tile["w"] * scale, tile["h"] * scale)
+ for key, tile in self.tiles.items()}
+ return frames, scale
+
+ def layout(self):
+ objc.super(AtlasCanvas, self).layout()
+ if self.tiles:
+ self._draw(False)
+
+ @objc.python_method
+ def _draw(self, animate):
+ frames, _scale = self._map()
+ if not frames:
+ return
+ motion.transaction(animate and motion.live(self))
+ for key, frame in frames.items():
+ tile, title, state_layer, outcome_layer, dot, cycle_layer = self._layer(key)
+ state = self.states.get(key, {}).get("state", "")
+ is_own = key == self.own_id
+ inactive = self.states.get(key, {}).get("in_use") is False
+ selected = key == self.selected
+ gap = state in ("gap", "set-elsewhere", "between", "overlap")
+ hover = key == self.hovered and not self.keyboard_focus
+ _set_layer_frame_if_changed(tile, _rect(frame))
+ tile.setBorderWidth_(1 if is_own else 2 if selected or gap else 1)
+ theme.tint(tile, background="well" if is_own else "panel",
+ border="edge" if is_own else "ink_2" if selected else
+ "ink_3" if hover else "amber" if gap else "edge")
+ tile.setOpacity_(0.42 if inactive else 1.0)
+ screens = core_ways._display_frames(self.tiles[key]) if self.tiles[key].get("displays") else []
+ layers = self.display_layers.setdefault(key, [])
+ while len(layers) < len(screens):
+ screen_layer = Quartz.CALayer.layer()
+ screen_layer.setBorderWidth_(1)
+ screen_layer.setCornerRadius_(2)
+ # Directly above the tile, under its labels: a snapshot (cacheDisplayInRect) draws
+ # sublayers in array order and ignores zPosition, so appended they hid the name.
+ self.layer().insertSublayer_above_(screen_layer, layers[-1] if layers else tile)
+ layers.append(screen_layer)
+ for index, layer in enumerate(layers):
+ if index >= len(screens):
+ layer.setHidden_(True)
+ continue
+ screen = screens[index]
+ scale_x = frame[2] / self.tiles[key]["w"]
+ scale_y = frame[3] / self.tiles[key]["h"]
+ _set_layer_frame_if_changed(
+ layer, ((screen["x"] * scale_x + frame[0] - self.tiles[key]["x"] * scale_x,
+ screen["y"] * scale_y + frame[1] - self.tiles[key]["y"] * scale_y),
+ (screen["w"] * scale_x, screen["h"] * scale_y)))
+ layer.setHidden_(False)
+ theme.tint(layer, background="well", border="edge")
+ title.setString_(self.labels.get(key, f"Machine · {key[-6:]}"))
+ _set_layer_frame_if_changed(title, _rect(self._title_rect(key, frame)))
+ status_info = self.states.get(key, {})
+ status = (f"{status_info.get('machine_name') or platform.node().split('.')[0] or 'This Mac'} · macOS"
+ if is_own else
+ f"{status_info.get('platform', 'Computer')} · {'Linked' if status_info.get('linked') else 'Offline'}")
+ if key in self.older:
+ status = f"Beamer {status_info.get('version') or '1.5.2'} · only sees which side"
+ if inactive:
+ status = "Not in use"
+ state_layer.setString_(status)
+ state_layer.setAlignmentMode_(Quartz.kCAAlignmentLeft)
+ _set_layer_frame_if_changed(state_layer, ((frame[0] + 24, frame[1] + 35),
+ (max(1, frame[2] - 32), 16)))
+ state_layer.setHidden_(frame[3] < 72)
+ theme.tint(state_layer, foreground="amber" if gap else "ink_3")
+ crosses = status_info.get("crosses", is_own)
+ outcome = ("Offline" if not is_own and not status_info.get("linked") else
+ "Crosses" if crosses and (status_info.get("corner_way") or status_info.get("notch_way")) else
+ "Edge off" if status_info.get("edge_off") or status_info.get("unpicked") else
+ outcome_for_tile(state, crosses, is_own))
+ if is_own:
+ outcome = ""
+ outcome_layer.setString_(outcome)
+ _set_layer_frame_if_changed(
+ outcome_layer, ((frame[0] + 8, frame[1] + frame[3] - 22),
+ (max(1, frame[2] - 16), 14)))
+ outcome_layer.setHidden_(frame[3] < 56)
+ theme.tint(outcome_layer, foreground="signal" if outcome == "Crosses" else
+ "amber" if outcome in ("Drag to connect", "Overlaps") else "ink_3")
+ _set_layer_frame_if_changed(dot, ((frame[0] + 12, frame[1] + 40), (6, 6)))
+ dot.setCornerRadius_(3)
+ dot.setHidden_(frame[3] < 72)
+ theme.tint(dot, background="amber" if key in self.older else
+ "signal" if status_info.get("linked") else "ink_3")
+ cycle_layer.setHidden_(not self._shows_cycle(key))
+ _set_layer_frame_if_changed(cycle_layer, _rect(self._cycle_box(frame)))
+ ticked = self.cycle.get(key, True) is True
+ cycle_layer.setBorderWidth_(0 if ticked else 1)
+ theme.tint(cycle_layer, background="ink_2" if ticked else "well", border="edge")
+ cycle_layer.sublayers()[0].setHidden_(not ticked)
+ if self.display_layers.get(key):
+ z_position = max(layer.zPosition() for layer in self.display_layers[key]) + 1.0
+ for layer in (title, state_layer, outcome_layer, dot, cycle_layer):
+ layer.setZPosition_(z_position)
+ focus = frames.get(self.selected) if self.keyboard_focus else None
+ self.focus_layer.setHidden_(focus is None)
+ if focus is not None:
+ _set_layer_frame_if_changed(
+ self.focus_layer, _rect((focus[0] - 3, focus[1] - 3, focus[2] + 6, focus[3] + 6)))
+ self._draw_guides(frames.get(self.own_id))
+ self._draw_contacts(frames)
+ self._draw_marks(frames)
+ self._draw_snap_preview(frames, _scale)
+ show_recentre = self._show_recentre()
+ self.recentre_layer.setHidden_(not show_recentre)
+ if show_recentre:
+ button = self._recentre_frame()
+ _set_layer_frame_if_changed(self.recentre_layer, _rect(button))
+ self.recentre_layer.setBorderWidth_(1 if self.keyboard_focus or self.recentre_hovered else 0)
+ theme.tint(self.recentre_layer, background="panel",
+ border="ink_2" if self.keyboard_focus or self.recentre_hovered else "rule")
+ self.recentre_label.setString_("Recentre")
+ self.recentre_label.setAlignmentMode_(Quartz.kCAAlignmentCenter)
+ _set_layer_frame_if_changed(self.recentre_label, ((4, 2), (button[2] - 8, button[3] - 4)))
+ theme.tint(self.recentre_label, foreground="ink_2" if self.recentre_hovered or self.keyboard_focus else "ink_3")
+ self.removeAllToolTips()
+ for _peer, _third, _side, start, end in self._third_segments(frames):
+ rect = (AppKit.NSMakeRect(start[0] - 5, start[1], 10, end[1] - start[1])
+ if start[0] == end[0] else
+ AppKit.NSMakeRect(start[0], start[1] - 5, end[0] - start[0], 10))
+ self.addToolTipRect_owner_userData_(rect, self, 1)
+ for key, frame in frames.items():
+ if self._shows_cycle(key):
+ self.addToolTipRect_owner_userData_(AppKit.NSMakeRect(*self._cycle_hit_rect(frame)), self, 0)
+ Quartz.CATransaction.commit()
+
+ @objc.python_method
+ def _draw_contacts(self, frames):
+ self.seam_segments = []
+ contacts = {}
+ own = self.own_id
+ for peer, state in self.states.items():
+ if (peer != own and own in frames and peer in frames
+ and state.get("state") in ("edge", "part", "corner") and state.get("crosses")
+ and state.get("picked_thirds", ["start"])):
+ found = [(screen, stretch, self._third_breaks(contact, screen) if peer == self.selected else set())
+ for screen, contact in self._side_contacts(peer)
+ for stretch in core_ways.crossing_stretches(contact, screen, state.get("lit_thirds", []))]
+ if found:
+ contacts[(own, peer, "signal")] = found
+ peers = [key for key, state in self.states.items()
+ if key in frames and state.get("state") in ("between", "set-elsewhere")]
+ for index, one in enumerate(peers):
+ for two in peers[index + 1:]:
+ if core_ways._rect_contact(self.tiles[one], self.tiles[two]):
+ pair = tuple(sorted((one, two)))
+ contacts[(pair[0], pair[1], "amber")] = [(None, core_ways._rect_contact(
+ self.tiles[pair[0]], self.tiles[pair[1]]), set())]
+ for key in list(self.contact_layers):
+ if key not in contacts:
+ self.contact_layers.pop(key).removeFromSuperlayer()
+ for key, stretches in contacts.items():
+ one, two, kind = key
+ a, b = frames[one], frames[two]
+ layer = self.contact_layers.get(key)
+ if layer is None:
+ layer = Quartz.CAShapeLayer.layer()
+ layer.setFillColor_(AppKit.NSColor.clearColor().CGColor())
+ layer.setStrokeColor_(theme.cg("signal" if kind == "signal" else "amber"))
+ for _screen, (side, start, end), _breaks in stretches:
+ if kind == "signal":
+ layer.setFillColor_(theme.cg("signal"))
+ layer.setLineWidth_(4 if kind == "signal" else 2)
+ if kind == "amber":
+ layer.setLineDashPattern_([4, 3])
+ layer.setLineCap_(Quartz.kCALineCapRound)
+ layer.setZPosition_(20)
+ self.layer().addSublayer_(layer)
+ self.contact_layers[key] = layer
+ path = Quartz.CGPathCreateMutable()
+ scale = a[2] / self.tiles[one]["w"]
+ layer.setStrokeColor_(theme.cg("signal" if kind == "signal" else "amber"))
+ layer.setOpacity_(0.55 if kind == "signal" and not self.states.get(two, {}).get("linked", True) else 1.0)
+ for screen, (side, start, end), breaks in stretches:
+ if side == "corner":
+ corner = start
+ x = a[0] if corner.endswith("left") else a[0] + a[2]
+ y = a[1] if corner.startswith("top") else a[1] + a[3]
+ Quartz.CGPathMoveToPoint(path, None, x - 2, y - 2)
+ Quartz.CGPathAddLineToPoint(path, None, x + 2, y + 2)
+ elif kind == "signal":
+ for piece in _split_at_breaks((side, start, end), breaks):
+ ends = self._seam_ends(frames, screen, *piece, breaks, 4.0)
+ if ends is not None:
+ Quartz.CGPathMoveToPoint(path, None, *ends[0])
+ Quartz.CGPathAddLineToPoint(path, None, *ends[1])
+ self.seam_segments.append({"peer": two, "kind": "seam", "side": side,
+ "start": ends[0], "end": ends[1], "width": 4.0})
+ elif side in ("left", "right"):
+ x = (a[0] + a[2]) if side == "right" else a[0]
+ inset = min(2.0, max(0.0, (end - start) * scale / 2))
+ y1 = a[1] + (start - self.tiles[one]["y"]) * scale + inset
+ y2 = a[1] + (end - self.tiles[one]["y"]) * scale - inset
+ if y2 > y1:
+ Quartz.CGPathMoveToPoint(path, None, x, y1)
+ Quartz.CGPathAddLineToPoint(path, None, x, y2)
+ else:
+ y = (a[1] + a[3]) if side == "bottom" else a[1]
+ inset = min(2.0, max(0.0, (end - start) * scale / 2))
+ x1 = a[0] + (start - self.tiles[one]["x"]) * scale + inset
+ x2 = a[0] + (end - self.tiles[one]["x"]) * scale - inset
+ if x2 > x1:
+ Quartz.CGPathMoveToPoint(path, None, x1, y)
+ Quartz.CGPathAddLineToPoint(path, None, x2, y)
+ layer.setPath_(path)
+ self._draw_thirds(frames)
+
+ @objc.python_method
+ def _side_contacts(self, peer):
+ """[(screen, contact)]: this Mac's display frames that meet `peer`'s along a side, as the engine
+ finds them; thirds are measured along `screen`, the pointer's own display."""
+ return core_ways.side_contacts(self.tiles[self.own_id], self.tiles[peer])
+
+ @objc.python_method
+ def _third_breaks(self, contact, screen):
+ """The third boundaries of `screen`'s side inside `contact`, where the selected machine's
+ seam and tracks break."""
+ if not contact or contact[0] == "corner":
+ return set()
+ stretches = core_ways.third_stretches(contact, screen)
+ return {before[3] for before, after in zip(stretches, stretches[1:])
+ if before[1] == after[1] and abs(before[3] - after[2]) < 1e-6}
+
+ @objc.python_method
+ def _seam_ends(self, frames, screen, side, low, high, breaks, width):
+ """The path ends, in view points, of the stretch `low`..`high` of `screen`'s `side`: 2pt in
+ from an outer end and stopped at a corner halo; at a third boundary, far enough short that
+ the round cap leaves half of THIRD_GAP clear. None when nothing is left to draw."""
+ tile, frame = self.tiles[self.own_id], frames[self.own_id]
+ scale = frame[2] / tile["w"]
+ vertical = side in ("left", "right")
+ origin, base = (frame[1], tile["y"]) if vertical else (frame[0], tile["x"])
+ first, last = origin + (low - base) * scale, origin + (high - base) * scale
+ outer = min(2.0, max(0.0, (last - first) / 2))
+ first += THIRD_GAP / 2 + width / 2 if _at_break(low, breaks) else outer
+ last -= THIRD_GAP / 2 + width / 2 if _at_break(high, breaks) else outer
+ if vertical:
+ fixed = frame[0] + (screen["x"] + (screen["w"] if side == "right" else 0) - tile["x"]) * scale
+ start, end = self._stop_at_corner_halos(frames, side, (fixed, first), (fixed, last))
+ else:
+ fixed = frame[1] + (screen["y"] + (screen["h"] if side == "bottom" else 0) - tile["y"]) * scale
+ start, end = self._stop_at_corner_halos(frames, side, (first, fixed), (last, fixed))
+ along = 1 if vertical else 0
+ return (start, end) if end[along] > start[along] else None
+
+ @objc.python_method
+ def _stop_at_corner_halos(self, frames, side, start, end):
+ x, y, width, height = frames[self.own_id]
+ corners = {state.get("corner_way") for peer, state in self.states.items()
+ if peer != self.own_id and peer in frames and state.get("in_use") is not False}
+ if side in ("left", "right"):
+ low = y + (11 if f"top_{side}" in corners else 0)
+ high = y + height - (11 if f"bottom_{side}" in corners else 0)
+ return (start[0], max(start[1], low)), (end[0], min(end[1], high))
+ low = x + (11 if f"{side}_left" in corners else 0)
+ high = x + width - (11 if f"{side}_right" in corners else 0)
+ return (max(start[0], low), start[1]), (min(end[0], high), end[1])
+
+ @objc.python_method
+ def _third_segments(self, frames):
+ peer, own = self.selected, self.own_id
+ state = self.states.get(peer, {})
+ if (peer == own or peer not in frames or own not in frames
+ or state.get("in_use") is False):
+ return []
+ tile, frame = self.tiles[own], frames[own]
+ scale = frame[2] / tile["w"]
+ segments = []
+ for screen, contact in self._side_contacts(peer):
+ for third, side, low, high in core_ways.third_stretches(contact, screen):
+ if side in ("left", "right"):
+ x = frame[0] + (screen["x"] + (screen["w"] if side == "right" else 0) - tile["x"]) * scale
+ start, end = (x, frame[1] + (low - tile["y"]) * scale), (x, frame[1] + (high - tile["y"]) * scale)
+ else:
+ y = frame[1] + (screen["y"] + (screen["h"] if side == "bottom" else 0) - tile["y"]) * scale
+ start, end = (frame[0] + (low - tile["x"]) * scale, y), (frame[0] + (high - tile["x"]) * scale, y)
+ segments.append((peer, third, side, start, end))
+ return segments
+
+ @objc.python_method
+ def _draw_thirds(self, frames):
+ marks = {}
+ segments = self._third_segments(frames)
+ peer = segments[0][0] if segments else None
+ state = self.states.get(peer, {})
+ if segments and not state.get("edge_off") and state.get("picked_thirds"):
+ contacts = self._side_contacts(peer)
+ for index, (screen, contact) in enumerate(contacts):
+ breaks = self._third_breaks(contact, screen)
+ for third, side, low, high in core_ways.third_stretches(contact, screen):
+ if third in (state.get("lit_thirds") or state["picked_thirds"]):
+ continue
+ ends = self._seam_ends(frames, screen, side, low, high, breaks, 2.0)
+ if ends is not None:
+ marks[(peer, third, "track") if len(contacts) == 1 else (peer, index, third, "track")] = ends
+ self.seam_segments.append({"peer": peer, "kind": "track", "side": side,
+ "start": ends[0], "end": ends[1], "width": 2.0})
+ for key in list(self.third_layers):
+ if key not in marks:
+ self.third_layers.pop(key).removeFromSuperlayer()
+ for key, (start, end) in marks.items():
+ layer = self.third_layers.get(key)
+ if layer is None:
+ layer = Quartz.CAShapeLayer.layer()
+ layer.setFillColor_(AppKit.NSColor.clearColor().CGColor())
+ layer.setLineCap_(Quartz.kCALineCapRound)
+ layer.setZPosition_(21)
+ self.layer().addSublayer_(layer)
+ self.third_layers[key] = layer
+ layer.setStrokeColor_(theme.cg("signal"))
+ layer.setLineWidth_(2)
+ layer.setOpacity_(0.3)
+ path = Quartz.CGPathCreateMutable()
+ Quartz.CGPathMoveToPoint(path, None, *start)
+ Quartz.CGPathAddLineToPoint(path, None, *end)
+ layer.setPath_(path)
+
+ @objc.python_method
+ def _third_hit_segment(self, point):
+ frames, _scale = self._map()
+ for peer, third, side, start, end in self._third_segments(frames):
+ if side in ("left", "right"):
+ hit = abs(point.x - start[0]) <= 5 and start[1] <= point.y <= end[1]
+ else:
+ hit = abs(point.y - start[1]) <= 5 and start[0] <= point.x <= end[0]
+ if hit:
+ return peer, third, side
+ return None
+
+ @objc.python_method
+ def _third_hit(self, point):
+ hit = self._third_hit_segment(point)
+ return hit[:2] if hit else None
+
+ @objc.python_method
+ def _third_tooltip(self, peer, third, side=None):
+ side = side or core_ways._rect_contact(self.tiles[self.own_id], self.tiles[peer])[0]
+ name = core_ways.part_names(side)[third]
+ picked = self.states.get(peer, {}).get("picked_thirds", [])
+ detail = f"click to turn it {'off' if third in picked else 'on'}"
+ return f"{name} third: {detail}"
+
+ @objc.python_method
+ def _draw_marks(self, frames):
+ marks = {}
+ own_frame = frames.get(self.own_id)
+ if own_frame is not None:
+ x, y, width, height = own_frame
+ for peer, state in self.states.items():
+ if peer == self.own_id or peer not in frames or state.get("in_use") is False:
+ continue
+ corner = state.get("corner_way")
+ if corner in core_ways.CORNERS:
+ px = x if corner.endswith("left") else x + width
+ py = y if corner.startswith("top") else y + height
+ path = Quartz.CGPathCreateMutable()
+ Quartz.CGPathAddRoundedRect(path, None, Quartz.CGRectMake(px - 8, py - 8, 16, 16), 4, 4)
+ marks[(peer, "corner", corner)] = (path, (px, py))
+ if state.get("notch_way"):
+ path = Quartz.CGPathCreateMutable()
+ Quartz.CGPathAddRoundedRect(path, None, Quartz.CGRectMake(*self._notch_rect(own_frame)), 2, 2)
+ marks[(peer, "notch")] = (path, None)
+ for key in list(self.mark_layers):
+ if key not in marks:
+ self.mark_layers.pop(key).removeFromSuperlayer()
+ if key in self.corner_halo_layers:
+ self.corner_halo_layers.pop(key).removeFromSuperlayer()
+ for key, (path, vertex) in marks.items():
+ layer = self.mark_layers.get(key)
+ if layer is None:
+ layer = Quartz.CAShapeLayer.layer()
+ layer.setLineWidth_(4)
+ layer.setLineCap_(Quartz.kCALineCapRound)
+ layer.setLineJoin_(Quartz.kCALineJoinRound)
+ if vertex is not None:
+ halo = Quartz.CAShapeLayer.layer()
+ halo.setFillColor_(theme.cg("ground"))
+ self.layer().addSublayer_(halo)
+ self.corner_halo_layers[key] = halo
+ chevron = Quartz.CAShapeLayer.layer()
+ chevron.setFillColor_(AppKit.NSColor.clearColor().CGColor())
+ chevron.setStrokeColor_(theme.cg("ground"))
+ chevron.setLineWidth_(1.8)
+ chevron.setLineCap_(Quartz.kCALineCapRound)
+ chevron.setLineJoin_(Quartz.kCALineJoinRound)
+ layer.addSublayer_(chevron)
+ self.layer().addSublayer_(layer)
+ self.mark_layers[key] = layer
+ clear = AppKit.NSColor.clearColor().CGColor()
+ layer.setFillColor_(theme.cg("signal"))
+ layer.setStrokeColor_(clear)
+ if vertex is not None:
+ px, py = vertex
+ halo = self.corner_halo_layers[key]
+ chevron = layer.sublayers()[0]
+ halo_path = Quartz.CGPathCreateMutable()
+ Quartz.CGPathAddRoundedRect(halo_path, None, Quartz.CGRectMake(px - 11, py - 11, 22, 22), 5, 5)
+ halo.setPath_(halo_path)
+ dx = 1 if key[2].endswith("left") else -1
+ dy = 1 if key[2].startswith("top") else -1
+ chevron_path = Quartz.CGPathCreateMutable()
+ Quartz.CGPathMoveToPoint(chevron_path, None, px - 4 * dx, py + 3 * dy)
+ Quartz.CGPathAddLineToPoint(chevron_path, None, px - 4 * dx, py - 4 * dy)
+ Quartz.CGPathAddLineToPoint(chevron_path, None, px + 3 * dx, py - 4 * dy)
+ chevron.setPath_(chevron_path)
+ selected = key[0] == self.selected
+ layer.setOpacity_(1.0 if selected else 0.55)
+ layer.setZPosition_(21 if selected else 20)
+ if vertex is not None:
+ halo.setZPosition_(19.5)
+ layer.setPath_(path)
+
+ @objc.python_method
+ def _notch_rect(self, frame):
+ """The notch dash, 4pt tall across the top edge: over the notch on the built-in display when
+ this Mac's tile has its displays and `notch_span`, else a 14pt dash at the tile's top centre."""
+ x, y, width, _height = frame
+ own = self.tiles[self.own_id]
+ span = self.states.get(self.own_id, {}).get("notch_span")
+ screen = next((screen for screen in core_ways._display_frames(own)
+ if span and own.get("displays") and screen["display"] == span[0]), None)
+ if screen is None:
+ return x + width / 2 - 7, y - 2, 14, 4
+ scale = width / own["w"]
+ left = x + (screen["x"] - own["x"]) * scale
+ top = y + (screen["y"] - own["y"]) * scale
+ span_width = screen["w"] * scale
+ return left + span[1] * span_width, top - 2, (span[2] - span[1]) * span_width, 4
+
+ @objc.python_method
+ def snap_preview(self):
+ if self.dragging is None or self.dragging.get("display") is not None:
+ return None
+ key = self.dragging.get("key")
+ if key in (None, self.own_id) or key not in self.tiles or self.own_id not in self.tiles:
+ return None
+ _frames, scale = self._map()
+ radius = self.snap_radius_for_scale(scale)
+ tile = self.tiles[key]
+ layout = {ident: value for ident, value in self.tiles.items() if ident != key}
+ snapped = core_ways.snap_position(tile, self.own_id, layout, radius=radius)
+ if ((snapped["x"], snapped["y"]) == (tile["x"], tile["y"])
+ or not core_ways.within_snap_radius(tile, snapped, self.own_id, layout, radius)):
+ return None
+ return {**tile, **snapped}
+
+ @objc.python_method
+ def _draw_snap_preview(self, frames, scale):
+ snapped = self.snap_preview()
+ if snapped is None:
+ self.snap_ghost.setHidden_(True)
+ self.snap_seam.setHidden_(True)
+ return
+ key = self.dragging["key"]
+ own = self.tiles[self.own_id]
+ own_frame = frames[self.own_id]
+ offset_x = own_frame[0] - own["x"] * scale
+ offset_y = own_frame[1] - own["y"] * scale
+ peer_frame = (snapped["x"] * scale + offset_x, snapped["y"] * scale + offset_y,
+ snapped["w"] * scale, snapped["h"] * scale)
+ path = Quartz.CGPathCreateMutable()
+ Quartz.CGPathAddRect(path, None, Quartz.CGRectMake(*peer_frame))
+ self.snap_ghost.setPath_(path)
+ self.snap_ghost.setZPosition_(19)
+ self.snap_ghost.setHidden_(False)
+ contact = core_ways._rect_contact(own, snapped)
+ self.snap_seam.setHidden_(contact is None)
+ if contact is None:
+ return
+ side, start, end = contact
+ x, y, width, height = frames[self.own_id]
+ seam = Quartz.CGPathCreateMutable()
+ if side == "corner":
+ px = x if start.endswith("left") else x + width
+ py = y if start.startswith("top") else y + height
+ Quartz.CGPathAddEllipseInRect(seam, None, Quartz.CGRectMake(px - 3.5, py - 3.5, 7, 7))
+ self.snap_seam.setStrokeColor_(AppKit.NSColor.clearColor().CGColor())
+ elif side in ("left", "right"):
+ px = x if side == "left" else x + width
+ inset = min(2.0, max(0.0, (end - start) * scale / 2))
+ self.snap_seam.setStrokeColor_(theme.cg("signal"))
+ Quartz.CGPathMoveToPoint(seam, None, px, y + (start - own["y"]) * scale + inset)
+ Quartz.CGPathAddLineToPoint(seam, None, px, y + (end - own["y"]) * scale - inset)
+ else:
+ py = y if side == "top" else y + height
+ inset = min(2.0, max(0.0, (end - start) * scale / 2))
+ self.snap_seam.setStrokeColor_(theme.cg("signal"))
+ Quartz.CGPathMoveToPoint(seam, None, x + (start - own["x"]) * scale + inset, py)
+ Quartz.CGPathAddLineToPoint(seam, None, x + (end - own["x"]) * scale - inset, py)
+ self.snap_seam.setPath_(seam)
+ self.snap_seam.setFillColor_(theme.cg("signal"))
+ self.snap_seam.setZPosition_(21)
+
+ @objc.python_method
+ def _draw_guides(self, frame):
+ own_frame = frame
+ while len(self.grid_layers) < 4:
+ grid = _box(("edge", 0.24), None)
+ self.layer().insertSublayer_atIndex_(grid, 0)
+ self.grid_layers.append(grid)
+ for layer in self.grid_layers:
+ layer.setHidden_(own_frame is None)
+ if own_frame is not None:
+ x, y, width, height = own_frame
+ for index, layer in enumerate(self.grid_layers):
+ if index < 2:
+ gx = x + width * (index + 1) / 3
+ layer.setFrame_(_rect((gx, 0, 1, self.bounds().size.height)))
+ else:
+ gy = y + height * (index - 1) / 3
+ layer.setFrame_(_rect((0, gy, self.bounds().size.width, 1)))
+ visible = self.dragging is not None and frame is not None
+ while len(self.guide_layers) < 16:
+ guide = _box(("ink_3", 0.36), None)
+ self.layer().addSublayer_(guide)
+ self.guide_layers.append(guide)
+ for guide in self.guide_layers:
+ guide.setHidden_(not visible)
+ if not visible:
+ return
+ x, y, width, height = frame
+ marks = []
+ for part in range(4):
+ cx, cy = x + width * part / 3, y + height * part / 3
+ marks.extend(((cx - 0.8, y - 7, 1.6, 6), (cx - 0.8, y + height + 1, 1.6, 6),
+ (x - 7, cy - 0.8, 6, 1.6), (x + width + 1, cy - 0.8, 6, 1.6)))
+ for layer, rect in zip(self.guide_layers, marks):
+ layer.setFrame_(_rect(rect))
+
+ @objc.python_method
+ def _recentre_frame(self):
+ width = self.bounds().size.width
+ return width - 84, 7, 74, 24
+
+ @objc.python_method
+ def _recentre_screen_frame(self):
+ rect = AppKit.NSMakeRect(*self._recentre_frame())
+ window = self.window()
+ if window is None:
+ return rect
+ return window.convertRectToScreen_(self.convertRect_toView_(rect, None))
+
+ @objc.python_method
+ def _nearest_side(self, own, peer):
+ targets = {side: core_ways.place_beside({self.own_id: own, self.selected: peer},
+ self.own_id, self.selected, side)
+ for side in ("left", "right", "top", "bottom")}
+ return min(targets, key=lambda side: (targets[side]["x"] - peer["x"]) ** 2
+ + (targets[side]["y"] - peer["y"]) ** 2)
+
+ @objc.python_method
+ def _recentre_side(self, peer):
+ own = self.tiles.get(self.own_id)
+ tile = self.tiles.get(peer)
+ if own is None or tile is None:
+ return None
+ contact = core_ways._rect_contact(own, tile)
+ if contact and contact[0] != "corner":
+ return contact[0]
+ return self._nearest_side(own, tile)
+
+ @objc.python_method
+ def _is_centred(self, peer):
+ if peer not in self.tiles or self.own_id not in self.tiles:
+ return False
+ own, tile = self.tiles[self.own_id], self.tiles[peer]
+ for side in ("left", "right", "top", "bottom"):
+ target = core_ways.place_beside({self.own_id: own, peer: tile}, self.own_id, peer, side)
+ if target["x"] == tile["x"] and target["y"] == tile["y"]:
+ return True
+ return False
+
+ @objc.python_method
+ def _show_recentre(self):
+ return (self.selected not in (None, self.own_id) and self.selected in self.tiles
+ and self.own_id in self.tiles and not self._is_centred(self.selected))
+
+ @objc.python_method
+ def recentre_selected(self):
+ if self.dragging is not None:
+ return False
+ peer = self.selected
+ side = self._recentre_side(peer) if peer not in (None, self.own_id) else None
+ if side is None:
+ return False
+ self.tiles[peer] = core_ways.place_beside(self.tiles, self.own_id, peer, side)
+ self._draw(True)
+ if self.on_layout_change:
+ self.on_layout_change(self.tiles, peer, snap=False)
+ return True
+
+ @objc.python_method
+ def _recentre_hit(self, point):
+ if not self._show_recentre():
+ return False
+ x, y, width, height = self._recentre_frame()
+ return x <= point.x <= x + width and y <= point.y <= y + height
+
+ @objc.python_method
+ def tile_at(self, point):
+ frames, _scale = self._map()
+ return next((key for key, frame in reversed(list(frames.items()))
+ if frame[0] <= point.x <= frame[0] + frame[2]
+ and frame[1] <= point.y <= frame[1] + frame[3]), None)
+
+ @objc.python_method
+ def display_at(self, point):
+ frames, scale = self._map()
+ for key in reversed(list(self.tiles)):
+ if not self.tiles[key].get("displays"):
+ continue
+ frame = frames[key]
+ map_x, map_y = frame[0] - self.tiles[key]["x"] * scale, frame[1] - self.tiles[key]["y"] * scale
+ screens = reversed(core_ways._display_frames(self.tiles[key]))
+ for screen in screens:
+ rect = (screen["x"] * scale + map_x, screen["y"] * scale + map_y,
+ screen["w"] * scale, screen["h"] * scale)
+ if rect[0] <= point.x <= rect[0] + rect[2] and rect[1] <= point.y <= rect[1] + rect[3]:
+ return key, screen["display"]
+ return None, None
+
+ @objc.python_method
+ def _cycle_hit(self, key, point):
+ frames, _scale = self._map()
+ x, y, width, height = self._cycle_hit_rect(frames[key])
+ return self._shows_cycle(key) and x <= point.x <= x + width and y <= point.y <= y + height
+
+ @objc.python_method
+ def _stop_tile_animations(self, key):
+ layers = [self.layer_for_tile.get(key), self.label_for_tile.get(key),
+ self.state_for_tile.get(key), self.outcome_for_tile.get(key),
+ self.dot_for_tile.get(key), self.cycle_for_tile.get(key), self.focus_layer]
+ layers.extend(self.display_layers.get(key, ()))
+ for layer in layers:
+ if layer is not None:
+ layer.removeAllAnimations()
+
+ @objc.python_method
+ def toggle_cycle(self, key):
+ if not self.cycle_enabled or key == self.own_id or key not in self.tiles:
+ return
+ self.cycle[key] = not self.cycle.get(key, True)
+ if self.on_cycle_change:
+ self.on_cycle_change(key, self.cycle[key])
+ self._draw(False)
+
+ def updateTrackingAreas(self):
+ for area in self.trackingAreas():
+ self.removeTrackingArea_(area)
+ area = AppKit.NSTrackingArea.alloc().initWithRect_options_owner_userInfo_(
+ self.bounds(), AppKit.NSTrackingMouseEnteredAndExited | AppKit.NSTrackingMouseMoved |
+ AppKit.NSTrackingActiveInKeyWindow,
+ self, None)
+ self.addTrackingArea_(area)
+ objc.super(AtlasCanvas, self).updateTrackingAreas()
+
+ def mouseEntered_(self, event):
+ self.mouseMoved_(event)
+
+ def mouseMoved_(self, event):
+ point = self.convertPoint_fromView_(event.locationInWindow(), None)
+ recentre_hovered = self._recentre_hit(point)
+ hovered = self.tile_at(point)
+ if self._third_hit(point):
+ AppKit.NSCursor.pointingHandCursor().set()
+ elif hovered is not None and hovered != self.own_id:
+ AppKit.NSCursor.openHandCursor().set()
+ else:
+ AppKit.NSCursor.arrowCursor().set()
+ if hovered != self.hovered or recentre_hovered != self.recentre_hovered:
+ self.hovered = hovered
+ self.recentre_hovered = recentre_hovered
+ self._draw(False)
+
+ def mouseExited_(self, _event):
+ self.hovered = None
+ self.recentre_hovered = False
+ if self.dragging is None:
+ AppKit.NSCursor.arrowCursor().set()
+ self._draw(False)
+
+ def view_stringForToolTip_point_userData_(self, _view, _tag, point, _data):
+ hit = self._third_hit_segment(point)
+ if hit:
+ return self._third_tooltip(*hit)
+ return "In the shortcut's cycle"
+
+ def accessibilityPerformPress(self):
+ if self.selected in self.tiles and self.selected != self.own_id:
+ self.toggle_cycle(self.selected)
+ return True
+ return False
+
+ def mouseDown_(self, event):
+ self.window().makeFirstResponder_(self)
+ point = self.convertPoint_fromView_(event.locationInWindow(), None)
+ self.third_pressed = self._third_hit(point)
+ if self.third_pressed:
+ return
+ if self._recentre_hit(point):
+ self.recentre_selected()
+ return
+ key, display = self.display_at(point)
+ if key is None:
+ key = self.tile_at(point)
+ if key is None:
+ return
+ if event.clickCount() > 1 and key != self.own_id and self.on_rename:
+ self.selected = key
+ self.on_rename(key)
+ return
+ if event.clickCount() > 1 and key == self.own_id:
+ self.announce("Rename this Mac on Overview.")
+ return
+ if self._cycle_hit(key, point):
+ self.cycle[key] = not self.cycle.get(key, True)
+ if self.on_cycle_change:
+ self.on_cycle_change(key, self.cycle[key])
+ self._draw(False)
+ return
+ if key == self.own_id:
+ return
+ self._stop_tile_animations(key)
+ self.keyboard_focus = False
+ self.selected = key
+ self.last_announcement = ""
+ frames, scale = self._map()
+ origin_id = self.own_id if self.own_id in frames else key
+ origin = self.tiles[origin_id]
+ map_x = frames[origin_id][0] - origin["x"] * scale
+ map_y = frames[origin_id][1] - origin["y"] * scale
+ if self.on_select:
+ self.on_select(key)
+ offsets = self.tiles[key].get("display_offsets", {})
+ split = display is not None and display in offsets
+ option = bool(event.modifierFlags() & AppKit.NSEventModifierFlagOption)
+ if display is not None and (split or option):
+ self.dragging = {"key": key, "display": display, "display_offset": dict(offsets.get(display, {"x": 0, "y": 0})),
+ "pointer_x": point.x, "pointer_y": point.y,
+ "scale": scale,
+ "map_x": map_x, "map_y": map_y,
+ "moved": False,
+ "split_toggle": option and not split, "group_toggle": option and split}
+ AppKit.NSCursor.closedHandCursor().set()
+ self._draw(False)
+ return
+ frame = frames[key]
+ self.dragging = {"key": key, "pointer_x": point.x - frame[0], "pointer_y": point.y - frame[1],
+ "map_x": map_x, "map_y": map_y, "scale": scale,
+ "moved": False}
+ AppKit.NSCursor.closedHandCursor().set()
+ self._draw(False)
+
+ def mouseDragged_(self, event):
+ if self.dragging is None:
+ return
+ point = self.convertPoint_fromView_(event.locationInWindow(), None)
+ scale = self.dragging["scale"]
+ key = self.dragging["key"]
+ if self.dragging.get("display") is not None:
+ display = self.dragging["display"]
+ dx = round((point.x - self.dragging["pointer_x"]) / scale)
+ dy = round((point.y - self.dragging["pointer_y"]) / scale)
+ tile = dict(self.tiles[key])
+ offsets = dict(tile.get("display_offsets", {}))
+ start = self.dragging["display_offset"]
+ offsets[display] = {"x": start["x"] + dx, "y": start["y"] + dy}
+ tile["display_offsets"] = offsets
+ self.tiles[key] = tile
+ self.dragging["moved"] = self.dragging["moved"] or bool(dx or dy)
+ self._draw(False)
+ return
+ tile = dict(self.tiles[key])
+ tile["x"] = round((point.x - self.dragging["pointer_x"] - self.dragging["map_x"]) / scale)
+ tile["y"] = round((point.y - self.dragging["pointer_y"] - self.dragging["map_y"]) / scale)
+ self.dragging["moved"] = self.dragging["moved"] or tile["x"] != self.tiles[key]["x"] or tile["y"] != self.tiles[key]["y"]
+ self.tiles[key] = tile
+ self._draw(False)
+
+ def mouseUp_(self, event):
+ if self.third_pressed:
+ pressed, self.third_pressed = self.third_pressed, None
+ point = self.convertPoint_fromView_(event.locationInWindow(), None)
+ if self._third_hit(point) == pressed and self.on_third:
+ self.on_third(*pressed)
+ return
+ if self.dragging is None:
+ return
+ key, moved = self.dragging["key"], self.dragging["moved"]
+ display = self.dragging.get("display")
+ split_toggle = self.dragging.get("split_toggle", False)
+ group_toggle = self.dragging.get("group_toggle", False)
+ preview = self.snap_preview() if moved and display is None else None
+ if preview is not None:
+ self.tiles[key] = preview
+ self.dragging = None
+ if preview is not None:
+ self._draw(True)
+ AppKit.NSCursor.arrowCursor().set()
+ if key != self.own_id and self.on_layout_change and (moved or (display is not None and (split_toggle or group_toggle))):
+ point = self.convertPoint_fromView_(event.locationInWindow(), None)
+ if display is not None and not moved and (split_toggle or group_toggle):
+ tile = dict(self.tiles[key])
+ offsets = dict(tile.get("display_offsets", {}))
+ if split_toggle:
+ offsets[display] = {"x": 0, "y": 0}
+ else:
+ offsets.pop(display, None)
+ updated = {**tile, "display_offsets": offsets}
+ if not offsets:
+ updated.pop("display_offsets", None)
+ self.tiles[key] = updated
+ self.on_layout_change(self.tiles, key, snap=False)
+ return
+ if display is None and point.y > self.bounds().size.height and self.on_leave_out:
+ self.on_leave_out(key)
+ return
+ # The preview already decided any snap; a second snap in the app, on the scale after the
+ # drop, could move a tile the preview said would stay.
+ self.on_layout_change(self.tiles, key, snap=False)
+
+ def keyDown_(self, event):
+ self.keyboard_focus = True
+ if event.keyCode() == 8 and self._show_recentre():
+ self.recentre_selected()
+ return
+ vectors = {123: (-1, 0), 124: (1, 0), 125: (0, 1), 126: (0, -1)}
+ vector = vectors.get(event.keyCode())
+ if event.keyCode() in (36, 120) and self.selected not in (None, self.own_id) and self.on_rename:
+ self.on_rename(self.selected)
+ return
+ if event.keyCode() == 49 and self.cycle_enabled and self.selected not in (None, self.own_id):
+ self.toggle_cycle(self.selected)
+ return
+ if event.keyCode() == 48 and self.selected is not None:
+ ordered = self.reading_order()
+ backwards = bool(event.modifierFlags() & AppKit.NSEventModifierFlagShift)
+ next_index = ordered.index(self.selected) + (-1 if backwards else 1) if self.selected in ordered else 0
+ if 0 <= next_index < len(ordered):
+ self.select_tile(ordered[next_index])
+ return
+ self.keyboard_focus = False
+ self._draw(False)
+ if vector is not None and self.selected not in self.tiles:
+ return
+ if vector is None or self.selected is None or self.selected == self.own_id:
+ objc.super(AtlasCanvas, self).keyDown_(event)
+ return
+ tile = dict(self.tiles[self.selected])
+ tile["x"] += round(tile["w"] / 3) * vector[0]
+ tile["y"] += round(tile["h"] / 3) * vector[1]
+ self.tiles[self.selected] = tile
+ sentence = f"{self.labels.get(self.selected, 'Machine')} moved one third."
+ self._draw(True)
+ if self.on_layout_change:
+ self.on_layout_change(self.tiles, self.selected, snap=False)
+ else:
+ self.announce(sentence)
class PushStrip(AppKit.NSView):
- """The last stretch of this Mac's screen, the edge, and the other machine beyond it, with the push past the
- edge drawn in: its depth is the resistance, out of the ruler's 500 px."""
+ """A single accessible resistance slider with live pressure on the same 0–500 track."""
- HEIGHT = 44.0
- EDGE_AT = 0.36
- REST = 0.55
+ HEIGHT = 72.0
+ MAXIMUM = MAX_RESISTANCE
+ INSET = 18.0
+ TRACK_TOP = 20.0
+ TRACK_HEIGHT = 12.0
+ drawn_focus = False
def isFlipped(self):
return True
@@ -290,72 +1586,247 @@ class PushStrip(AppKit.NSView):
root.setMasksToBounds_(True)
theme.tint(root, background="ground", border="rule")
root.setBorderWidth_(1)
- self.this = _box("well")
- self.fill = Quartz.CAGradientLayer.layer()
- theme.tint(self.fill, colours=[("signal", 0.9), ("signal", 0.15)])
- self.fill.setStartPoint_((0.0, 0.5))
- self.fill.setEndPoint_((1.0, 0.5))
- self.fill.setOpacity_(self.REST)
- self.edge = _box("ink_3")
- self.pointer = Quartz.CAShapeLayer.layer()
- path = Quartz.CGPathCreateMutable()
- for index, (x, y) in enumerate(((0, 0), (0, 14), (3.6, 10.6), (6.2, 16), (8.2, 15), (5.7, 9.8), (10, 9.8))):
- (Quartz.CGPathMoveToPoint if index == 0 else Quartz.CGPathAddLineToPoint)(path, None, x, y)
- Quartz.CGPathCloseSubpath(path)
- self.pointer.setPath_(path)
- theme.tint(self.pointer, fill="ink", stroke="ground")
- self.pointer.setLineWidth_(1)
- self.pointer.setBounds_(((0, 0), (10, 16)))
- self.pointer.setAnchorPoint_((0.0, 0.0))
- self.this_label = _text_layer(theme.TYPE["eyebrow"], "ink_3", Quartz.kCAAlignmentLeft)
- self.other_label = _text_layer(theme.TYPE["eyebrow"], "ink_3", Quartz.kCAAlignmentRight)
- for layer in (self.this, self.fill, self.edge, self.this_label, self.other_label, self.pointer):
- root.addSublayer_(layer)
- self.fraction = None
+ self._value = 120
+ self._pressure = 0.0
+ self._active_edge = "right"
+ self._crossing = False
+ self._flash_timer = None
+ self.on_change = None
self.other_name = "Other machine"
- self.setAccessibilityElement_(False)
+ self.setAccessibilityElement_(True)
+ self.setAccessibilityRole_(AppKit.NSAccessibilitySliderRole)
+ self.setAccessibilityLabel_("Resistance")
+ self.setAccessibilityValue_(self._value)
+ self._update_accessibility_description()
return self
- def layout(self):
- objc.super(PushStrip, self).layout()
- if self.fraction is not None:
- self._draw(False)
+ def acceptsFirstResponder(self):
+ return True
+
+ def becomeFirstResponder(self):
+ self.setNeedsDisplay_(True)
+ return True
+
+ def resignFirstResponder(self):
+ self.setNeedsDisplay_(True)
+ return True
@objc.python_method
- def show(self, fraction, other_name="Other machine"):
- fraction = min(1.0, max(0.0, float(fraction)))
- if fraction == self.fraction and other_name == self.other_name:
+ def refresh_keyboard_focus(self):
+ from widgets import keyboard_focus_visible
+
+ if keyboard_focus_visible(self) != self.drawn_focus:
+ self.setNeedsDisplay_(True)
+
+ @objc.python_method
+ def set_value(self, value, notify=False):
+ value = max(0, min(self.MAXIMUM, int(round(float(value)))))
+ if value == self._value:
return
- moving = self.fraction is not None and motion.live(self)
- self.fraction, self.other_name = fraction, other_name
- self._draw(moving)
- if moving and fraction > 0:
- # The push brightens as it moves, then settles back.
- pulse = Quartz.CABasicAnimation.animationWithKeyPath_("opacity")
- pulse.setFromValue_(1.0)
- pulse.setToValue_(self.REST)
- pulse.setDuration_(0.6)
- pulse.setTimingFunction_(motion.timing())
- self.fill.addAnimation_forKey_(pulse, "pulse")
+ self._value = value
+ self.setAccessibilityValue_(value)
+ self._update_accessibility_description()
+ self.setNeedsDisplay_(True)
+ if notify and self.on_change is not None:
+ self.on_change(value)
@objc.python_method
- def _draw(self, animate):
- width, height = self.bounds().size.width, self.bounds().size.height
+ def set_other_name(self, name):
+ name = name or "Other machine"
+ if name != self.other_name:
+ self.other_name = name
+ self.setNeedsDisplay_(True)
+
+ @objc.python_method
+ def peer_label_text(self, width=None):
+ width = self.bounds().size.width if width is None else width
+ font = theme.font(theme.TYPE["eyebrow"], 600)
+ attributes = {AppKit.NSFontAttributeName: font,
+ AppKit.NSForegroundColorAttributeName: theme.colour("ink_3"),
+ AppKit.NSKernAttributeName: 1.45}
+ text = AppKit.NSString.stringWithString_(self.other_name.upper())
+ available = max(1.0, width / 2 - 16)
+ value = self.other_name.upper()
+ while value and AppKit.NSString.stringWithString_(value + "…").sizeWithAttributes_(attributes).width > available:
+ value = value[:-1]
+ return value + "…" if value != self.other_name.upper() else self.other_name.upper()
+
+ @objc.python_method
+ def show(self, fraction, other_name="Other machine"):
+ self.set_value(float(fraction) * self.MAXIMUM)
+ self.set_other_name(other_name)
+
+ @objc.python_method
+ def set_pressure(self, pressure, edge=None, crossed=False):
+ if self._flash_timer is not None:
+ self._flash_timer.invalidate()
+ self._flash_timer = None
+ self._crossing = bool(crossed)
+ if edge:
+ self._active_edge = edge
+ self._pressure = max(0.0, min(float(pressure), self.MAXIMUM))
+ if self._crossing:
+ timer = AppKit.NSTimer.timerWithTimeInterval_target_selector_userInfo_repeats_(
+ 0.12, self, "clearCrossingFlash:", None, False
+ )
+ AppKit.NSRunLoop.mainRunLoop().addTimer_forMode_(timer, AppKit.NSRunLoopCommonModes)
+ self._flash_timer = timer
+ self._update_accessibility_description()
+ self.setNeedsDisplay_(True)
+
+ def clearCrossingFlash_(self, _timer):
+ self._flash_timer = None
+ self._crossing = False
+ self._pressure = 0.0
+ self._update_accessibility_description()
+ self.setNeedsDisplay_(True)
+
+ def accessibilityHelp(self):
+ return self._accessibility_description
+
+ def accessibilityPerformIncrement(self):
+ self.nudge(1)
+ return True
+
+ def accessibilityPerformDecrement(self):
+ self.nudge(-1)
+ return True
+
+ @objc.python_method
+ def _update_accessibility_description(self):
+ pressure = int(round(self._pressure))
+ self._accessibility_description = (
+ f"Current pressure {pressure} of {self._value} pointer units at the {self._active_edge} edge."
+ if pressure > 0 else f"No push. Current pressure is 0 of {self._value} pointer units."
+ )
+ self.setAccessibilityHelp_(self._accessibility_description)
+
+ @objc.python_method
+ def move_to(self, fraction):
+ self.set_value(max(0, min(1, float(fraction))) * self.MAXIMUM, notify=True)
+
+ @objc.python_method
+ def nudge(self, direction, fine=False):
+ self.set_value(self._value + direction * (1 if fine else 10), notify=True)
+
+ @property
+ def value(self):
+ return self._value
+
+ @value.setter
+ def value(self, value):
+ self.set_value(value)
+
+ def mouseDown_(self, event):
+ self._drag(event)
+
+ def mouseDragged_(self, event):
+ self._drag(event)
+
+ @objc.python_method
+ def _drag(self, event):
+ self.window().makeFirstResponder_(self)
+ point = self.convertPoint_fromView_(event.locationInWindow(), None)
+ width = self.bounds().size.width
+ self.move_to((point.x - self.INSET) / max(1.0, width - 2 * self.INSET))
+
+ def keyDown_(self, event):
+ keys = event.charactersIgnoringModifiers()
+ steps = {AppKit.NSLeftArrowFunctionKey: -1, AppKit.NSDownArrowFunctionKey: -1,
+ AppKit.NSRightArrowFunctionKey: 1, AppKit.NSUpArrowFunctionKey: 1}
+ direction = steps.get(keys[0]) if keys else None
+ if direction is None:
+ objc.super(PushStrip, self).keyDown_(event)
+ return
+ self.nudge(direction, fine=bool(event.modifierFlags() & AppKit.NSEventModifierFlagOption))
+
+ def drawRect_(self, _rect):
+ from Foundation import NSMakeRect, NSString
+
+ width = self.bounds().size.width
if width <= 0:
return
- edge = max(round(width * self.EDGE_AT), 20 + _text_width("THIS MAC", self.this_label.font()))
- needed_height = max(self.HEIGHT, math.ceil(_text_height(
- self.other_name.upper(), self.other_label.font(), width - edge - 20)) + 8)
- if self.minimum_height.constant() != needed_height:
- self.minimum_height.setConstant_(needed_height)
- # The full 500 px stops short of the other machine's name, so the name is never under the push.
- room = max(0, width - edge - min(120, _text_width(self.other_name.upper(), self.other_label.font()) + 20))
- depth = room * self.fraction
- motion.transaction(animate)
- self.this.setFrame_(((0, 0), (edge, height)))
- self.edge.setFrame_(((edge - 1, 0), (2, height)))
- self.fill.setFrame_(((edge, 0), (depth, height)))
- self.pointer.setPosition_((edge + depth - 1, (height - 16) / 2))
- _fit_text(self.this_label, "THIS MAC", (10, 0, edge - 20, height))
- _fit_text(self.other_label, self.other_name.upper(), (edge + 10, 0, width - edge - 20, height))
- Quartz.CATransaction.commit()
+ left = resistance_x(width, 0)
+ right = resistance_x(width, self.MAXIMUM)
+ span = max(0.0, right - left)
+
+ def color(role):
+ theme.colour(role).set()
+
+ def text(value, x, y, w, h, font, role, align="center", kern=None):
+ value = str(value)
+ attributes = {AppKit.NSFontAttributeName: font,
+ AppKit.NSForegroundColorAttributeName: theme.colour(role)}
+ if kern is not None:
+ attributes[AppKit.NSKernAttributeName] = kern
+ drawing = NSString.stringWithString_(value)
+ if align in ("left", "right") and drawing.sizeWithAttributes_(attributes).width > w:
+ while value and NSString.stringWithString_(value + "…").sizeWithAttributes_(attributes).width > w:
+ value = value[:-1]
+ drawing = NSString.stringWithString_(value + "…")
+ size = drawing.sizeWithAttributes_(attributes)
+ if align == "right":
+ x += max(0, w - size.width)
+ w = size.width
+ elif align == "center":
+ x += max(0, (w - size.width) / 2)
+ w = size.width
+ drawing.drawInRect_withAttributes_(NSMakeRect(x, y, w, h), attributes)
+
+ track = AppKit.NSBezierPath.bezierPathWithRoundedRect_xRadius_yRadius_(
+ NSMakeRect(left, self.TRACK_TOP, span, self.TRACK_HEIGHT), 3, 3
+ )
+ color("well")
+ track.fill()
+ color("ink_3")
+ track.setLineWidth_(1.0)
+ track.stroke()
+
+ head = resistance_x(width, self._pressure)
+ if self._pressure > 0:
+ fill = AppKit.NSBezierPath.bezierPathWithRoundedRect_xRadius_yRadius_(
+ NSMakeRect(left, self.TRACK_TOP + 0.5, max(0.0, head - left), self.TRACK_HEIGHT - 1), 2.5, 2.5
+ )
+ color("signal")
+ fill.fill()
+
+ thumb_x = resistance_x(width, self._value)
+ path = AppKit.NSBezierPath.bezierPath()
+ path.moveToPoint_((thumb_x, 17.5))
+ path.lineToPoint_((thumb_x, 38.0))
+ from widgets import keyboard_focus_visible
+ focused = keyboard_focus_visible(self)
+ self.drawn_focus = focused
+ color("signal" if focused else "ink")
+ path.setLineWidth_(2.0)
+ path.stroke()
+
+ path = AppKit.NSBezierPath.bezierPath()
+ path.moveToPoint_((left, 17.0))
+ path.lineToPoint_((left, 41.0))
+ color("resistance_flash" if self._crossing else "signal" if self._pressure > 0 else "edge")
+ path.setLineWidth_(3.0 if self._crossing else 2.0)
+ path.stroke()
+
+ top_font = theme.font(theme.TYPE["eyebrow"], 600)
+ local_label = "THIS MAC"
+ peer_label = self.peer_label_text(width)
+ text(local_label, 8, 2, width / 2 - 8, 15, top_font, "ink_3", align="left", kern=1.45)
+ text(peer_label, width / 2, 2, width / 2 - 8, 15, top_font, "ink_3", align="right", kern=1.45)
+
+ scale_font = theme.mono_font(theme.TYPE["eyebrow"])
+ for value in range(0, self.MAXIMUM + 1, 25):
+ x = resistance_x(width, value)
+ major = value % 100 == 0
+ tick = AppKit.NSBezierPath.bezierPath()
+ tick.moveToPoint_((x, self.TRACK_TOP + self.TRACK_HEIGHT))
+ tick.lineToPoint_((x, self.TRACK_TOP + self.TRACK_HEIGHT + (12 if major else 4)))
+ color("ink_3" if major else "edge")
+ tick.setLineWidth_(1.0)
+ tick.stroke()
+ if major:
+ text(value, x - 22, 52, 44, 17, scale_font, "ink_2")
+
+ @property
+ def fraction(self):
+ return self._value / self.MAXIMUM
diff --git a/mac_app/dock_visibility.py b/mac_app/dock_visibility.py
new file mode 100644
index 0000000..0c533fe
--- /dev/null
+++ b/mac_app/dock_visibility.py
@@ -0,0 +1,17 @@
+"""Pure policy selection for the Mac app's Dock presence."""
+
+DEFAULT_SHOW_IN_DOCK = True
+
+
+def complete_settings(settings):
+ settings.setdefault("show_in_dock", DEFAULT_SHOW_IN_DOCK)
+ return settings
+
+
+def validate_settings(settings):
+ if not isinstance(settings.get("show_in_dock"), bool):
+ raise ValueError("show_in_dock must be true or false")
+
+
+def activation_policy(show_in_dock, window_open):
+ return "regular" if show_in_dock or window_open else "accessory"
diff --git a/mac_app/effects_overlay.py b/mac_app/effects_overlay.py
index 946faf4..ac8d045 100644
--- a/mac_app/effects_overlay.py
+++ b/mac_app/effects_overlay.py
@@ -3,7 +3,7 @@ desktop while a crossing plays and in the Design page's previews.
`replay` is the whole port of the Pen to Quartz, and takes the Quartz module as an argument so the
tests can hand it a recording fake. `EffectsOverlay` owns one effects.Player, fed the same events
-today's glow is fed, and shows its frames in click-through panels at 60Hz only while something is
+today's glow is fed, and shows its frames in click-through panels only while something is
playing. It keeps one panel per display the frame touches, because a window spanning two displays
shows on only one of them while displays have separate Spaces, which is macOS's default.
@@ -17,19 +17,22 @@ import time
import AppKit
import Quartz
import objc
-import rumps
import crossing
import desktop_mac
from core import effects
+from frame_clock import FrameClock
import notch_beam
import notch_island
+import theme
# Canvas's line caps and joins, as Core Graphics names them.
_CAPS = {"butt": "kCGLineCapButt", "round": "kCGLineCapRound", "square": "kCGLineCapSquare"}
_JOINS = {"miter": "kCGLineJoinMiter", "round": "kCGLineJoinRound", "bevel": "kCGLineJoinBevel"}
CONIC_WEDGES = 72
NOTCH_RADIUS = 10.0
+SEAM_TICK = 10
+SPECIMEN_FEATHER = 0.1
def replay(cg, ctx, pens):
@@ -208,8 +211,8 @@ def region_of(via, mac_edge, region, box):
# The screens in a preview, drawn the way the settings window draws everything else.
-_SCREEN_DARK = ("#2a2b26", "#161714")
-_SCREEN_LIGHT = ("#d9d8cf", "#b9b8ae")
+_SCREEN_DARK = (effects.PREVIEW_TILE_GROUND, effects.PREVIEW_TILE_GROUND)
+_SCREEN_LIGHT = _SCREEN_DARK
def _rgb(hex_value, alpha=1.0):
@@ -218,9 +221,7 @@ def _rgb(hex_value, alpha=1.0):
def draw_scene(cg, ctx, scene, width, height, method, dark, crop=None, pointer=18.0):
- """One effects.preview_scene frame fitted into `width` x `height`: the screens, the pens, the
- pointer (`pointer` points tall however far the scene is scaled), then the notch. `crop`
- (x, y, w, h) shows only that part of the scene."""
+ """One real preview frame fitted to its camera, with screen fragments round a crossing seam."""
scene_w, scene_h = effects.preview_size(method) if crop is None else crop[2:]
ox, oy = (0.0, 0.0) if crop is None else crop[:2]
scale = min(width / scene_w, height / scene_h)
@@ -230,17 +231,43 @@ def draw_scene(cg, ctx, scene, width, height, method, dark, crop=None, pointer=1
cg.CGContextScaleCTM(ctx, scale, scale)
cg.CGContextTranslateCTM(ctx, -ox, -oy)
cg.CGContextClipToRect(ctx, ((ox, oy), (scene_w, scene_h)))
- top, bottom = _SCREEN_DARK if dark else _SCREEN_LIGHT
- space = cg.CGColorSpaceCreateWithName(cg.kCGColorSpaceSRGB)
- ground = cg.CGGradientCreateWithColorComponents(space, list(_rgb(top) + _rgb(bottom)), [0.0, 1.0], 2)
- for x, y, w, h, _os in scene["screens"]:
- cg.CGContextSaveGState(ctx)
- path = cg.CGPathCreateWithRoundedRect(((x, y), (w, h)), 14.0, 14.0, None)
- cg.CGContextAddPath(ctx, path)
- cg.CGContextClip(ctx)
- cg.CGContextDrawLinearGradient(ctx, ground, (x, y), (x, y + h), 0)
- cg.CGContextRestoreGState(ctx)
+ specimen = "seam" in scene
+ if specimen and scene["screens"]:
+ for x, y, w, h, _os in scene["screens"]:
+ left, top = max(x, ox) + 1 / scale, max(y, oy) + 1 / scale
+ right, bottom = min(x + w, ox + scene_w) - 1 / scale, min(y + h, oy + scene_h) - 1 / scale
+ if right <= left or bottom <= top:
+ continue
+ radius = theme.RADIUS["field"] / scale
+ path = cg.CGPathCreateWithRoundedRect(((left, top), (right - left, bottom - top)), radius, radius, None)
+ cg.CGContextAddPath(ctx, path)
+ cg.CGContextSetFillColorWithColor(ctx, theme.cg("ground"))
+ cg.CGContextSetStrokeColorWithColor(ctx, theme.cg("rule"))
+ cg.CGContextSetLineWidth(ctx, 1 / scale)
+ cg.CGContextDrawPath(ctx, cg.kCGPathFillStroke)
+ if specimen:
+ ground = theme.rgb(theme.T["ground"])
+ shadow = cg.CGColorCreateGenericRGB(*(tuple(value * 0.8 for value in ground) + (0.35,)))
+ cg.CGContextSetShadowWithColor(ctx, (0.0, 1.0 / scale), 1.0 / scale, shadow)
+ cg.CGContextBeginTransparencyLayer(ctx, None)
+ else:
+ top, bottom = _SCREEN_DARK if dark else _SCREEN_LIGHT
+ space = cg.CGColorSpaceCreateWithName(cg.kCGColorSpaceSRGB)
+ ground = cg.CGGradientCreateWithColorComponents(space, list(_rgb(top) + _rgb(bottom)), [0.0, 1.0], 2)
+ for x, y, w, h, _os in scene["screens"]:
+ cg.CGContextSaveGState(ctx)
+ path = cg.CGPathCreateWithRoundedRect(((x, y), (w, h)), 14.0, 14.0, None)
+ cg.CGContextAddPath(ctx, path)
+ cg.CGContextClip(ctx)
+ cg.CGContextDrawLinearGradient(ctx, ground, (x, y), (x, y + h), 0)
+ cg.CGContextRestoreGState(ctx)
replay(cg, ctx, scene["pens"])
+ if specimen:
+ _feather_specimen(cg, ctx, ox, oy, scene_w, scene_h)
+ cg.CGContextEndTransparencyLayer(ctx)
+ cg.CGContextSetShadowWithColor(ctx, (0.0, 0.0), 0.0, None)
+ if scene["seam"] is not None:
+ _paint_seam_tick(cg, ctx, scene["seam"], ox, oy, scene_w, scene_h, scale)
if scene["pointer"] is not None:
_pointer(cg, ctx, scene["pointer"][0], scene["pointer"][1], pointer / scale)
if scene["notch"] is not None:
@@ -252,10 +279,46 @@ def draw_scene(cg, ctx, scene, width, height, method, dark, crop=None, pointer=1
cg.CGContextRestoreGState(ctx)
+def _feather_specimen(cg, ctx, x, y, width, height):
+ space = cg.CGColorSpaceCreateWithName(cg.kCGColorSpaceSRGB)
+ components = (1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0)
+ positions = (0, SPECIMEN_FEATHER, 1 - SPECIMEN_FEATHER, 1)
+ cg.CGContextSetBlendMode(ctx, cg.kCGBlendModeDestinationIn)
+ for start, end in (((x, y), (x + width, y)), ((x, y), (x, y + height))):
+ gradient = cg.CGGradientCreateWithColorComponents(space, components, positions, 4)
+ cg.CGContextDrawLinearGradient(ctx, gradient, start, end, 0)
+ cg.CGContextSetBlendMode(ctx, cg.kCGBlendModeNormal)
+
+
+def _paint_seam_tick(cg, ctx, seam, x, y, width, height, scale):
+ x0, y0, x1, _y1 = seam
+ cg.CGContextSetStrokeColorWithColor(ctx, theme.cg("ink_2"))
+ cg.CGContextSetLineWidth(ctx, 1 / scale)
+ cg.CGContextBeginPath(ctx)
+ if x0 == x1:
+ start = (x0, y + height)
+ end = (x0, y + height - SEAM_TICK / scale)
+ else:
+ start = (x, y0)
+ end = (x + SEAM_TICK / scale, y0)
+ start = _pixel_centre(cg, ctx, start)
+ end = _pixel_centre(cg, ctx, end)
+ cg.CGContextMoveToPoint(ctx, *start)
+ cg.CGContextAddLineToPoint(ctx, *end)
+ cg.CGContextStrokePath(ctx)
+
+
+def _pixel_centre(cg, ctx, point):
+ device = cg.CGContextConvertPointToDeviceSpace(ctx, point)
+ aligned = (math.floor(device.x) + 0.5, math.floor(device.y) + 0.5)
+ user = cg.CGContextConvertPointToUserSpace(ctx, aligned)
+ return user.x, user.y
+
+
def _pointer(cg, ctx, x, y, size):
"""The arrow pointer, `size` tall in the scene's own units."""
unit = size / 18.0
- shape = ((0.0, 0.0), (0.0, 1.0), (0.26, 0.76), (0.44, 1.12), (0.56, 1.06), (0.39, 0.7), (0.72, 0.7))
+ shape = effects.PREVIEW_POINTER
cg.CGContextBeginPath(ctx)
for index, (px, py) in enumerate(shape):
(cg.CGContextMoveToPoint if index == 0 else cg.CGContextAddLineToPoint)(ctx, x + px * size, y + py * size)
@@ -299,7 +362,6 @@ class EffectsOverlay:
crossing lands the pointer on this Mac, and `switched` when input arrives any other way.
Coordinates in are Quartz global points."""
- FRAME_S = 1 / 60
PAD = 2.0
def __init__(self, controller, logger):
@@ -316,7 +378,7 @@ class EffectsOverlay:
self.displays = []
self.pressure_now = None
self.panels = {}
- self.timer = rumps.Timer(self._tick, self.FRAME_S)
+ self.timer = FrameClock(None, lambda: self._tick(None))
# Every module up front: a bundle without them (build 329) turns the effects off here, once,
# and today's glow draws everything, instead of the first crossing finding out.
try:
@@ -428,8 +490,9 @@ class EffectsOverlay:
if self.fx is None:
raise ValueError(f"no crossing effect called {feel['glow_style']!r}")
self.palette = palette(feel["glow_colour"])
- self.player.pace = effects.pace(feel.get("effect_length"))
+ self.player.pace = feel.get("effect_pace", effects.pace(feel.get("effect_length")))
self.player.effect_size = feel.get("effect_size", "medium")
+ self.player.effect_size_fraction = feel.get("effect_size_fraction")
self.reduced = reduce_motion()
self.dark = dark_appearance()
self.box = tuple(self.controller._current_desktop_bounds())
diff --git a/mac_app/frame_clock.py b/mac_app/frame_clock.py
new file mode 100644
index 0000000..81dd689
--- /dev/null
+++ b/mac_app/frame_clock.py
@@ -0,0 +1,60 @@
+"""Frame callbacks on the display refresh, with a common-mode timer fallback."""
+
+import AppKit
+import Quartz
+
+# The Design page's tiles are thumbnails: at a ProMotion panel's 120Hz their hover doubled the
+# page's work for nothing anyone can see, so they play at 60 at most.
+PREVIEW_MAX_RATE = 60
+
+
+class _Fire(AppKit.NSObject):
+ def fire_(self, _sender):
+ self.callback()
+
+
+class FrameClock:
+ """Calls `callback()` on the display refresh where macOS provides a display link."""
+
+ def __init__(self, view, callback, max_rate=None):
+ self.view = view
+ self.callback = callback
+ self.max_rate = max_rate
+ self.source = None
+
+ def start(self):
+ if self.source is not None:
+ return
+ target = _Fire.alloc().init()
+ target.callback = self.callback
+ runloop = AppKit.NSRunLoop.mainRunLoop()
+ window = None if self.view is None else self.view.window()
+ # An overlay with no view yet plays on whichever display the crossing is at: paced to the
+ # fastest, a ProMotion panel is never held to an external display's 60Hz.
+ screen = window.screen() if window is not None else max(
+ AppKit.NSScreen.screens() or [None], key=lambda each: getattr(each, "maximumFramesPerSecond", lambda: 0)() if each else 0)
+ link_owner = screen if self.view is None else self.view
+ if (screen is not None and (self.view is None or window is not None)
+ and hasattr(link_owner, "displayLinkWithTarget_selector_")
+ and hasattr(screen, "maximumFramesPerSecond")):
+ link = link_owner.displayLinkWithTarget_selector_(target, "fire:")
+ rate = max(1, int(screen.maximumFramesPerSecond()))
+ if self.max_rate:
+ rate = min(rate, self.max_rate)
+ link.setPreferredFrameRateRange_(Quartz.CAFrameRateRangeMake(min(30, rate), rate, rate))
+ link.addToRunLoop_forMode_(runloop, AppKit.NSRunLoopCommonModes)
+ self.source = link
+ else:
+ timer = AppKit.NSTimer.timerWithTimeInterval_target_selector_userInfo_repeats_(
+ 1.0 / 60.0, target, "fire:", None, True
+ )
+ runloop.addTimer_forMode_(timer, AppKit.NSRunLoopCommonModes)
+ self.source = timer
+
+ def stop(self):
+ source, self.source = self.source, None
+ if source is not None:
+ source.invalidate()
+
+ def is_alive(self):
+ return self.source is not None
diff --git a/mac_app/gestures.py b/mac_app/gestures.py
index 312af7f..c7abd49 100644
--- a/mac_app/gestures.py
+++ b/mac_app/gestures.py
@@ -18,20 +18,18 @@ raw values:
32 NSEventTypeSmartMagnify (reserved; not translated)
`DockSwipeClassifier` handles the tap's DockControl events and emits one
-`gesture` message per completed movement. `GestureTranslator` handles the
-overlay's NSEvents, turning a pinch into zoom steps and a page swipe into back
-or forward, each a CHORD that `chord_for` shapes for the machine it is sent to:
+`gesture` message per completed movement. `GestureTranslator` handles the tap's
+raw zoom fields and the overlay's NSEvents, turning a pinch into zoom steps and
+a page swipe into back or forward, each a CHORD shaped for its receiver:
Ctrl+wheel and Alt+Arrow for a PC, Command with = - [ ] for a Mac, with no
-change on the receiving side. A zoom gesture was never observed to
-reach the tap, so the overlay is the only route for it, and it remains
-best-effort.
+change on the receiving side. Type-29 CGEvents whose HID subtype is zoom (8)
+are read directly from their private fields in the tap; overlay NSEvents still
+use their public magnification accessor.
Everything here is defensive: an unreadable field is logged once and treated
as "no gesture" rather than raised, so a bug or a changed private field on a
-future macOS can never take down keyboard/mouse capture. Neither class needs
-AppKit or Quartz -- `ns_event` only has to expose `.magnification`,
-`.deltaX`, `.deltaY` and `.phase`, and dock `fields` only `.hid`, `.motion`,
-`.phase`, `.progress` and `.velocity` -- which keeps the tests free of both.
+future macOS can never take down keyboard/mouse capture. Translation tests need
+neither AppKit nor Quartz.
"""
import logging
@@ -56,6 +54,18 @@ DOCK_FIELD_PROGRESS = 124
DOCK_FIELD_VELOCITY_X = 129
DOCK_FIELD_VELOCITY_Y = 130
+# Private CGEvent fields for type-29 gesture events. WebKit names field 113
+# kCGEventGestureZoomValue and 132 kCGEventGesturePhase; Mac Mouse Fix reads
+# these on type-29 events with field 110 set to the IOHID zoom subtype (8):
+# https://www.mail-archive.com/webkit-changes%40lists.webkit.org/msg113473.html
+# https://github.com/noah-nuebling/mac-mouse-fix/discussions/366
+GESTURE_FIELD_HID_TYPE = 110
+GESTURE_FIELD_MAGNIFICATION = 113
+GESTURE_FIELD_PHASE = 132
+GESTURE_ZOOM_HID_TYPE = 8
+CG_GESTURE_PHASE_ENDED = 4
+CG_GESTURE_PHASE_CANCELLED = 8
+
DOCK_SWIPE_HID_TYPE = 23
MOTION_HORIZONTAL = 1
MOTION_VERTICAL = 2
@@ -185,13 +195,30 @@ class GestureTranslator:
return self._translate_magnify(ns_event)
if event_type == SWIPE_TYPE:
return self._translate_swipe(ns_event)
- # Gesture (29) and SmartMagnify (32) are reserved -- no
- # translation defined for them yet.
+ # Gesture (29) and SmartMagnify (32) are translated separately
+ # only when the raw CGEvent fields identify a zoom.
return []
except Exception:
self._warn_once(event_type)
return []
+ def translate_cg_gesture(self, fields):
+ """Translate the raw private fields of a type-29 CGEvent zoom."""
+ try:
+ if int(fields.get(GESTURE_FIELD_HID_TYPE, -1)) != GESTURE_ZOOM_HID_TYPE:
+ return []
+ return self._translate_magnification(
+ float(fields[GESTURE_FIELD_MAGNIFICATION]),
+ int(fields[GESTURE_FIELD_PHASE]),
+ int(fields[GESTURE_FIELD_PHASE]) in (
+ CG_GESTURE_PHASE_ENDED,
+ CG_GESTURE_PHASE_CANCELLED,
+ ),
+ )
+ except Exception:
+ self._warn_once(GESTURE_TYPE)
+ return []
+
def _warn_once(self, event_type):
if event_type in self._warned_types:
return
@@ -201,14 +228,21 @@ class GestureTranslator:
)
def _translate_magnify(self, ns_event):
- self._magnify_accum += float(ns_event.magnification)
+ phase = int(getattr(ns_event, "phase", 0) or 0)
+ return self._translate_magnification(
+ float(ns_event.magnification),
+ phase,
+ bool(phase & _PHASE_RESET_MASK),
+ )
+
+ def _translate_magnification(self, magnification, phase, reset):
+ self._magnify_accum += magnification
messages = []
while abs(self._magnify_accum) >= MAGNIFY_STEP:
direction = 1 if self._magnify_accum > 0 else -1
messages.extend(self._zoom_step_messages(direction))
self._magnify_accum -= direction * MAGNIFY_STEP
- phase = int(getattr(ns_event, "phase", 0) or 0)
- if phase & _PHASE_RESET_MASK:
+ if reset:
self._magnify_accum = 0.0
return messages
diff --git a/mac_app/input_injector_mac.py b/mac_app/input_injector_mac.py
index 8b37dda..6a918b2 100644
--- a/mac_app/input_injector_mac.py
+++ b/mac_app/input_injector_mac.py
@@ -71,6 +71,9 @@ DOUBLE_CLICK_SLOP_PX = 5
# notch a line, so this is 1; it is named rather than inlined because it is
# the knob to turn if a mouse wheel feels wrong on the Mac.
LINES_PER_NOTCH = 1.0
+# A PC scrolls three lines a notch by default, so its notch posted as one line here moved a page a
+# third as far as on the PC.
+PC_LINES_PER_NOTCH = 3.0
# Media keys are not key events on a Mac: they arrive as NSSystemDefined events of subtype 8, the
# reverse of media_keys.decode. The NX key codes are IOKit's ev_keymap.h. There is no stop key on
@@ -84,6 +87,8 @@ MEDIA_NX_KEYS = {
"media_play_pause": 16,
"media_next": 17,
"media_prev": 18,
+ "brightness_up": 2,
+ "brightness_down": 3,
}
_MEDIA_STATE_DOWN = 0x0A
_MEDIA_STATE_UP = 0x0B
@@ -241,7 +246,7 @@ def plan_key_event(name: str, down: bool, mods_down: Set[str], held: Optional[Di
def handles_key(name: str) -> bool:
"""Whether `name` is a key this module posts by some route other than a key code."""
lowered = name.lower()
- return lowered in MEDIA_NX_KEYS or lowered in BROWSER_KEY_CHORDS
+ return lowered in MEDIA_NX_KEYS or lowered in BROWSER_KEY_CHORDS or lowered in ("search", "spotlight", "dictation")
def _inject_media_key(nx_key: int, down: bool) -> None:
@@ -279,6 +284,22 @@ def _inject_browser_key(character: str) -> None:
_post(event)
+def _inject_shortcut(modifier: str, key: str) -> None:
+ quartz = _require()
+ modifier_code = KEY_NAME_TO_CODE[modifier]
+ key_code = KEY_NAME_TO_CODE[key]
+ held = current_flags(_mods_down)
+ held_with_modifier = held | quartz.kCGEventFlagMaskCommand
+ steps = ((modifier_code, True, held_with_modifier), (key_code, True, held_with_modifier),
+ (key_code, False, held_with_modifier), (modifier_code, False, held))
+ for code, down, flags in steps:
+ event = quartz.CGEventCreateKeyboardEvent(None, code, down)
+ if event is None:
+ raise RuntimeError(f"CGEventCreateKeyboardEvent failed for {key!r}")
+ quartz.CGEventSetFlags(event, flags)
+ _post(event)
+
+
@_locked
def inject_key(name: str, down: bool, us: Optional[str] = None) -> None:
quartz = _require()
@@ -291,6 +312,12 @@ def inject_key(name: str, down: bool, us: Optional[str] = None) -> None:
if down:
_inject_browser_key(BROWSER_KEY_CHORDS[lowered])
return
+ if lowered in ("search", "spotlight"):
+ if down:
+ _inject_shortcut("cmd", "space")
+ return
+ if lowered == "dictation":
+ name = lowered = "f5"
plan = plan_key_event(name, down, _mods_down, _held_codes, us)
if plan is None:
return
@@ -467,7 +494,9 @@ def inject_mouse_button(button: str, down: bool) -> None:
_post(event)
-def plan_scroll_units(dy, dx, mode: str, remainders: Dict[str, List[float]]) -> Tuple[int, int, int]:
+def plan_scroll_units(
+ dy, dx, mode: str, remainders: Dict[str, List[float]], lines_per_notch=LINES_PER_NOTCH
+) -> Tuple[int, int, int]:
"""Pure planning: (unit, whole vertical steps, whole horizontal steps) for one scroll, the
fraction not yet whole kept in `remainders` for the next. The same arithmetic the PC's
plan_scroll_units does, truncating toward zero so a remainder never reverses direction."""
@@ -475,7 +504,7 @@ def plan_scroll_units(dy, dx, mode: str, remainders: Dict[str, List[float]]) ->
if mode == "pixel":
unit, key, scale = quartz.kCGScrollEventUnitPixel, "pixel", 1.0
else:
- unit, key, scale = quartz.kCGScrollEventUnitLine, "line", LINES_PER_NOTCH
+ unit, key, scale = quartz.kCGScrollEventUnitLine, "line", lines_per_notch
accum = remainders[key]
accum[0] += float(dy) * scale
accum[1] += float(dx) * scale
@@ -485,10 +514,9 @@ def plan_scroll_units(dy, dx, mode: str, remainders: Dict[str, List[float]]) ->
return unit, whole_y, whole_x
-@_locked
-def inject_scroll(dy, dx=0.0, mode: str = "line") -> None:
+def _inject_scroll(dy, dx, mode, lines_per_notch) -> None:
quartz = _require()
- unit, wheel_y, wheel_x = plan_scroll_units(dy, dx, mode, _scroll_remainders)
+ unit, wheel_y, wheel_x = plan_scroll_units(dy, dx, mode, _scroll_remainders, lines_per_notch)
if not wheel_y and not wheel_x:
return
event = quartz.CGEventCreateScrollWheelEvent(None, unit, 2, wheel_y, wheel_x)
@@ -498,6 +526,17 @@ def inject_scroll(dy, dx=0.0, mode: str = "line") -> None:
_post(event)
+@_locked
+def inject_scroll(dy, dx=0.0, mode: str = "line") -> None:
+ _inject_scroll(dy, dx, mode, LINES_PER_NOTCH)
+
+
+@_locked
+def inject_scroll_from_peer(dy, dx=0.0, mode: str = "line", peer_platform="") -> None:
+ lines_per_notch = PC_LINES_PER_NOTCH if peer_platform in ("windows", "linux") else LINES_PER_NOTCH
+ _inject_scroll(dy, dx, mode, lines_per_notch)
+
+
def reset_scroll_remainders() -> None:
for accum in _scroll_remainders.values():
accum[0] = accum[1] = 0.0
diff --git a/mac_app/instance_signal.py b/mac_app/instance_signal.py
new file mode 100644
index 0000000..4a8cf61
--- /dev/null
+++ b/mac_app/instance_signal.py
@@ -0,0 +1,48 @@
+import socket
+import socketserver
+import time
+from pathlib import Path
+
+
+def _handle_instance_request(request, _client_address, server):
+ with request.makefile("rb") as stream:
+ if stream.readline(32).strip() == b"activate":
+ server.activate()
+
+
+class InstanceSignalServer(socketserver.ThreadingUnixStreamServer):
+ allow_reuse_address = True
+ daemon_threads = True
+
+ def __init__(self, path: Path, activate):
+ self.path = Path(path)
+ self.activate = activate
+ self.path.parent.mkdir(parents=True, exist_ok=True)
+ self.path.unlink(missing_ok=True)
+ super().__init__(str(self.path), _handle_instance_request)
+ self.path.chmod(0o600)
+
+ def close(self):
+ self.shutdown()
+ self.server_close()
+ self.path.unlink(missing_ok=True)
+
+
+def request_running_instance(path: Path, timeout: float = 2.0) -> bool:
+ deadline = time.monotonic() + timeout
+ while True:
+ client = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+ try:
+ client.connect(str(path))
+ client.sendall(b"activate\n")
+ return True
+ except (FileNotFoundError, ConnectionRefusedError):
+ if time.monotonic() >= deadline:
+ return False
+ time.sleep(0.05)
+ finally:
+ client.close()
+
+
+def instance_socket_path() -> Path:
+ return Path.home() / "Library" / "Application Support" / "Beamer" / "Beamer.sock"
diff --git a/mac_app/kvm_bridge_app.py b/mac_app/kvm_bridge_app.py
index cdc6870..bd3a7b0 100644
--- a/mac_app/kvm_bridge_app.py
+++ b/mac_app/kvm_bridge_app.py
@@ -1,11 +1,15 @@
import argparse
import collections
+import copy
import fcntl
import logging
import logging.handlers
+import math
import os
+import socket
import subprocess
import sys
+import threading
import time
from dataclasses import replace
from pathlib import Path
@@ -20,10 +24,13 @@ from PyObjCTools import AppHelper
sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
import bridge
+from instance_signal import InstanceSignalServer, instance_socket_path, request_running_instance
import config as config_module
import crossing
from core import return_edge
import desktop_mac
+from frame_clock import FrameClock
+import dock_visibility
from core import crash_log
from core import effects
from core.locale import americanise
@@ -35,6 +42,7 @@ import keyboard_layout
import notch_beam
import previews
import diagram
+import ledger
import motion
from notch_beam import NotchBeam
from notch_island import NotchIsland
@@ -43,6 +51,7 @@ from key_codes import KEY_NAME_TO_CODE
import link_state
import machines_panel
import login_item
+import machines
import notices
import pages
from core import updates
@@ -51,6 +60,7 @@ from core import pairing
from core import peerlist
from core import settings_sync
from core import ways as core_ways
+from core import crossing_state
from settings_store import (
SettingsError,
SettingsStore,
@@ -499,7 +509,7 @@ class EdgeGlow:
it sits above a full-screen app.
Main thread only, like GestureOverlay. Pressure changes arrive through `update`; a timer
- then redraws at 30Hz until both the pressure and the flash have faded, since nothing
+ then redraws on each display refresh until both the pressure and the flash have faded, since nothing
arrives from the tap once the push stops. Any failure disables the glow for the run."""
dark_appearance = staticmethod(notch_beam.dark_appearance)
@@ -533,7 +543,7 @@ class EdgeGlow:
self.preview_until = 0.0
# The pressure of a push home while the PC drives, which the Mac's own engine never sees.
self.level_now = None
- self.timer = rumps.Timer(self._tick, 1 / 30)
+ self.timer = FrameClock(None, lambda: self._tick(None))
def update(self, kind, step):
if self.disabled:
@@ -618,7 +628,7 @@ class EdgeGlow:
self.drawn_at = now
feel = self.controller.cfg.crossing
beam = feel["glow_style"] == "beam"
- pace = effects.pace(feel.get("effect_length"))
+ pace = feel.get("effect_pace", effects.pace(feel.get("effect_length")))
level = (self.level_now or self.controller.crossing_pressure_now)()
if now < self.preview_until:
level = max(level, self.preview_level)
@@ -648,7 +658,7 @@ class EdgeGlow:
display = effects_overlay.display_at((self.region[0] + self.region[2] / 2.0,
self.region[1] + self.region[3] / 2.0), box)
full_depth = effects.edge_depth(display[2] - display[0], display[3] - display[1],
- feel.get("effect_size", "medium"))
+ feel.get("effect_size", "medium"), feel.get("effect_size_fraction"))
band = full_depth if beam else full_depth * (0.35 + 0.65 * max(level, flash))
if self._corner() is not None:
self._draw_corner(feel, beam, band, full_depth, level, flash, strength)
@@ -942,7 +952,7 @@ class FlippedView(AppKit.NSTableRowView):
def window_fill_frame(window):
screen = window.screen() or AppKit.NSScreen.mainScreen()
- return screen.visibleFrame()
+ return screen.visibleFrame() if screen else AppKit.NSMakeRect(0, 0, 1728, 1084)
def page_column_width(free):
@@ -1013,7 +1023,7 @@ class SettingsWindow(AppKit.NSWindow):
responder = self.firstResponder()
if isinstance(responder, widgets.Pressable):
responder._ring(True)
- elif isinstance(responder, widgets._RulerView):
+ elif isinstance(responder, (widgets._RulerView, diagram.PushStrip, diagram.AtlasCanvas)):
responder.refresh_keyboard_focus()
delegate = self.delegate()
if delegate is not None and hasattr(delegate, 'sidebar'):
@@ -1087,6 +1097,89 @@ class SettingsWindow(AppKit.NSWindow):
objc.super(SettingsWindow, self).sendEvent_(event)
+def design_slider_key_value(key, current, minimum, maximum, step, page_step):
+ movement = {123: -step, 124: step, 125: -step, 126: step,
+ 116: page_step, 121: -page_step, 115: minimum, 119: maximum}
+ if key not in movement:
+ return None
+ if key in (115, 119):
+ return movement[key]
+ return min(maximum, max(minimum, current + movement[key]))
+
+
+def design_readout():
+ label = widgets.Label("", theme.TYPE["readout_key"], mono=True,
+ align=AppKit.NSTextAlignmentRight)
+ label.width_constraint = label.view.widthAnchor().constraintEqualToConstant_(effects.DESIGN_READOUT_WIDTH)
+ label.width_constraint.setActive_(True)
+ return label
+
+
+class _DesignSlider(AppKit.NSSlider):
+ def keyDown_(self, event):
+ if not self.isEnabled():
+ return
+ value = design_slider_key_value(int(event.keyCode()), self.doubleValue(),
+ self._design_minimum, self._design_maximum,
+ self._design_step, self._design_page_step)
+ if value is None:
+ return objc.super(_DesignSlider, self).keyDown_(event)
+ self.setDoubleValue_(value)
+ self.target().fire_(self)
+
+
+class _DesignSliderChoice:
+ def __init__(self, title, minimum, maximum, step, scale, stops, presets, callback, description):
+ self.scale, self.stops, self.presets = scale, stops, presets
+ self.description = description
+ self.slider = _DesignSlider.alloc().initWithFrame_(((0, 0), (240, 26)))
+ self.slider.setMinValue_(minimum)
+ self.slider.setMaxValue_(maximum)
+ self.slider.setDoubleValue_(stops[1] * scale)
+ self.slider.setContinuous_(True)
+ self.slider._design_step = step
+ self.slider._design_page_step = step * 5
+ self.slider._design_minimum = minimum
+ self.slider._design_maximum = maximum
+ self.slider.setAccessibilityLabel_(title)
+ self.slider.setAccessibilityHelp_(description)
+ self.target = widgets.callback_target(lambda: callback(self, self.slider))
+ self.slider.setTarget_(self.target)
+ self.slider.setAction_("fire:")
+ widgets.squeeze(self.slider)
+ self.view = self.slider
+ self.focusable_views = (self.slider,)
+
+ @property
+ def enabled(self):
+ return self.slider.isEnabled()
+
+ @property
+ def value(self):
+ numeric = self.slider.doubleValue() / self.scale
+ return effects.length_preset(numeric) if self.presets is effects.LENGTHS else effects.size_preset(numeric)
+
+ @value.setter
+ def value(self, preset):
+ self.set_value(preset)
+
+ def set_numeric(self, value):
+ self.slider.setDoubleValue_(round(value * self.scale))
+
+ def set_value(self, preset):
+ index = next((i for i, (key, _name) in enumerate(self.presets) if key == preset), 1)
+ self.set_numeric(self.stops[index])
+
+ def numeric_value(self):
+ return self.slider.doubleValue() / self.scale
+
+ def set_enabled(self, enabled):
+ self.slider.setEnabled_(bool(enabled))
+
+ def set_accessible_value(self, value):
+ self.slider.setAccessibilityValueDescription_(value)
+
+
class ControlWindow(AppKit.NSObject):
def initWithController_settingsStore_logger_(self, controller, settings_store, logger):
self = objc.super(ControlWindow, self).init()
@@ -1095,6 +1188,7 @@ class ControlWindow(AppKit.NSObject):
self.controller = controller
self.settings_store = settings_store
self.logger = logger
+ self.activation_policy_handler = None
# Before anything is built: every control takes its colours from the palette in use.
theme.set_dark(theme.wants_dark(controller.cfg.appearance, theme.system_dark()))
# Set by TrayApp once it exists: the listener for the PC's input, and
@@ -1102,6 +1196,7 @@ class ControlWindow(AppKit.NSObject):
self.windows_input = None
# Set by TrayApp: saves one machine's direction switch (token, send= or allow_drive=).
self.direction_handler = None
+ self.left_out_handler = None
self.last_capture_attempt = 0.0
# macOS passes keys only to a process started after Input Monitoring is granted, so a grant
# made during this run needs a relaunch before the keyboard crosses, however ready the tap looks.
@@ -1143,7 +1238,7 @@ class ControlWindow(AppKit.NSObject):
)
self.window.setTitle_("Beamer")
self.window.setReleasedWhenClosed_(False)
- self.window.setMinSize_((320, 300))
+ self.window.setMinSize_((640, 540))
self.window.keyboard_navigation = False
# The window always carries the palette's own appearance, never nil: the title bar's
# buttons and text then match the palette whatever the Mac is set to, and the transparent
@@ -1153,7 +1248,8 @@ class ControlWindow(AppKit.NSObject):
self.window.setTitlebarAppearsTransparent_(True)
screen = self.window.screen() or AppKit.NSScreen.mainScreen()
x, y, width, height = settings_normal_frame(
- self.settings_store.current().get("settings_window_frame"), screen.visibleFrame())
+ self.settings_store.current().get("settings_window_frame"),
+ screen.visibleFrame() if screen else AppKit.NSMakeRect(0, 0, 1728, 1084))
self.window.setFrame_display_(((x, y), (width, height)), False)
self._normal_frame = [x, y, width, height]
self._frame_transition = False
@@ -1237,7 +1333,7 @@ class ControlWindow(AppKit.NSObject):
"permissions": self._permissions_page,
}
for key, name, _symbol, purpose in pages.PAGES:
- scroll, body = self._page(name, purpose, pages.SCOPE.get(key), key)
+ scroll, body = self._page(name, purpose, pages.SCOPE.get(key) if key != "crossing" else None, key)
host.addArrangedSubview_(scroll)
scroll.setHidden_(True)
self.pages[key] = scroll
@@ -1262,6 +1358,11 @@ class ControlWindow(AppKit.NSObject):
page_width = width - sidebar - 1 - 16
self._apply_width(page_width)
body_width = page_column_width(page_width)
+ if self.page == "crossing":
+ for constraint in self.atlas_canvas.constraints():
+ if (constraint.firstItem() == self.atlas_canvas and constraint.secondItem() is None
+ and constraint.firstAttribute() == AppKit.NSLayoutAttributeHeight):
+ constraint.setConstant_(220 if width <= 640 else 260)
if self.page == "design":
inner_width = body_width - 32
for choices in (self.glow_style_select, self.switch_style_select, self.glow_colour_select):
@@ -1310,6 +1411,7 @@ class ControlWindow(AppKit.NSObject):
def windowDidBecomeKey_(self, _notification):
self.sidebar.refresh_focus()
+ self._show_login_state()
def windowWillUseStandardFrame_defaultFrame_(self, window, _default_frame):
return window_fill_frame(window)
@@ -1378,7 +1480,8 @@ class ControlWindow(AppKit.NSObject):
# another page.
if key != "crossing":
self.key_recorder.cancel()
- self.jump_recorder.cancel()
+ for row in self.crossing_ledger.rows.values():
+ row.jump.cancel()
if key != "keyboard":
self.ignored_recorder.cancel()
self._run_previews()
@@ -1395,6 +1498,7 @@ class ControlWindow(AppKit.NSObject):
return
if self.page == "design" and self.window.isVisible() and self.glow_box.value:
self.previews.start()
+ self.tile_hover.sync_clock()
else:
self.tile_hover.stop()
self.previews.stop()
@@ -1441,14 +1545,17 @@ class ControlWindow(AppKit.NSObject):
self.double_tap_ruler.value = raw["double_tap_ms"]
self.double_tap_numeral.set(str(raw["double_tap_ms"]))
crossing_raw = raw["crossing"]
+ self.shortcut_goes_to.value = crossing_raw.get("shortcut_goes_to", "last")
+ self._show_shortcut_destination_note()
self.method_boxes["shortcut"].value = "shortcut" in crossing_raw["methods"]
self.resistance_ruler.value = crossing_raw["resistance_px"]
self.landing_box.value = crossing_raw["shortcut_arrival"]
self.switch_style_select.value = crossing_raw["shortcut_arrival_style"]
self.dragging_box.value = crossing_raw["block_while_dragging"]
self.glow_style_select.value = crossing_raw["glow_style"]
- self.length_select.value = crossing_raw.get("effect_length", "normal")
- self.size_select.value = crossing_raw.get("effect_size", "medium")
+ self.length_select.set_numeric(crossing_raw.get("effect_pace", 1.0))
+ self.size_select.set_numeric(crossing_raw.get("effect_size_fraction", 0.045))
+ self._refresh_design_readouts()
self.glow_colour_select.value = crossing_raw["glow_colour"]
self._reflect()
@@ -1456,22 +1563,18 @@ class ControlWindow(AppKit.NSObject):
def _reflect(self, *_ignored):
"""Enables each control only when the setting it edits is in play, and keeps the figures
beside the rulers in step with them."""
- methods = [name for name, tile in self.method_boxes.items() if tile.value]
+ methods = self._methods()
rows = pages.crossing_rows(methods)
- for key, view in (("edge", self.edge_row), ("parts", self.parts_row), ("corner", self.corner_row),
- ("dragging", self.dragging_box.view), ("resistance", self.resistance_module.view),
+ for key, view in (("resistance", self.resistance_module.view),
("shortcut", self.shortcut_module.view)):
visible = rows[key] or key == "shortcut" and bool(getattr(self, "_trigger_conflict", ""))
motion.set_hidden(view, not visible)
+ self.dragging_box.set_enabled(bool(set(methods) & {"edge", "part", "corner", "notch"}))
if not rows["shortcut"]:
# Hidden, an armed recorder would still take the next key typed anywhere on the page.
self.key_recorder.cancel()
- for name, label in pages.part_names(self.edge_select.value).items():
- self.part_boxes[name].name.set(label)
- notch = self.method_boxes["notch"]
- notch.set_enabled(self.has_notch)
self._show_arrangement(methods)
- motion.set_hidden(self.edge_note.view, not pages.notch_or_corner_only(methods))
+ self._show_shortcut_destination_note()
haptics, glow = self.haptics_box.value, self.glow_box.value
for control in (self.tick_steps_select, self.try_button):
control.set_enabled(haptics)
@@ -1523,12 +1626,16 @@ class ControlWindow(AppKit.NSObject):
fx = effects.preview_effect(style) if self.effects_ready else effects.CLASSIC.get(style)
if fx is not None:
self.effect_name.set(f"{fx.name}, {pages.INTENSITIES.get(fx.intensity, fx.intensity).lower()}")
+ crossing_fx = effects.preview_effect(style) if self.effects_ready else effects.CLASSIC.get(style)
+ if crossing_fx is not None:
+ self.switch_style_select.set_detail("match", f"Plays {crossing_fx.name}")
motion.set_hidden(self.chosen_box, fx is None)
if fx is not None:
self.effect_blurb.set(fx.blurb)
# Drawing every still is tens of milliseconds, so only what they show redraws them: the
# colour, the place, the length, the size, the palette, and for Same as crossing the crossing style.
- stills = (colour, style, place, self.length_select.value, self.size_select.value, theme.is_dark())
+ stills = (colour, style, place, self.length_select.value, self.size_select.value,
+ self.notch_after_select.value, theme.is_dark())
if stills != self._stills:
self._stills = stills
for still in self.effect_stills:
@@ -1550,9 +1657,12 @@ class ControlWindow(AppKit.NSObject):
)
self._run_previews()
notch_range = self.controller.notch_range
- notch.set_detail(
- f"Top edge, {round(notch_range[1] - notch_range[0])} pt wide" if self.has_notch and notch_range else "This Mac has no notch"
- )
+ settings = self.settings_store.current()
+ layout = core_ways.derive_layout(settings, gap=0)
+ own = settings["machine_id"]
+ contact = (core_ways._rect_contact(layout[own], layout[self.chosen_peer])
+ if own in layout and self.chosen_peer in layout else None)
+ side = contact[0] if contact and contact[0] != "corner" else None
# Among the chosen machine's ways the shortcut is the one that is not that machine's: it is
# this Mac's, and goes where input last went.
several = len(self.settings_store.current()["peers"]) > 1
@@ -1569,8 +1679,8 @@ class ControlWindow(AppKit.NSObject):
)
resistance = self.resistance_ruler.value
self.resistance_numeral.set(str(resistance))
- self.push_strip.show(resistance / 500.0, self._chosen_label())
- side = self.edge_select.value
+ self.push_strip.set_other_name(self._chosen_label())
+ side = self._selected_ways()["side"]
self.resistance_hint.set(
"Switches the moment this Mac's pointer touches the edge. Each screen supplies its own zones."
if resistance == 0
@@ -1587,118 +1697,29 @@ class ControlWindow(AppKit.NSObject):
}.get(self.modifier_select.value, "Custom: the key map in settings.json is kept as it is."))
@objc.python_method
- def _load_ways(self, flat=None):
- """The chosen machine's ways into the page's controls, from the settings (core/ways.py);
- with nothing active, from `flat`, the crossing settings as 1.4.x kept them. A chosen machine
- no longer paired or in use gives way to the first active machine."""
- settings = self.settings_store.current()
- peers = peerlist.desktops(settings["peers"])
- available = [entry for entry in peers if entry.get("in_use", True) is True]
- if self.chosen_peer not in {entry["id"] for entry in available}:
- self.chosen_peer = available[0]["id"] if available else None
- if self.chosen_peer is None:
- flat = flat or self.controller.cfg.crossing
- held = {"side": flat["edge"], "methods": flat["methods"], "parts": flat["edge_parts"], "corner": flat["corner"]}
- else:
- held = core_ways.ways(settings, self.chosen_peer)
- self.edge_select.value = pages.shown_side(held["side"], len(peers))
- for name in core_ways.KIND_WORDS:
- self.method_boxes[name].value = name in held["methods"]
- for name, tile in self.part_boxes.items():
- tile.value = name in held["parts"]
- self.corner_select.value = held["corner"]
- self._show_machines()
+ def _selected_ways(self):
+ if self.chosen_peer is not None:
+ return core_ways.ways(self.settings_store.current(), self.chosen_peer)
+ flat = self.controller.cfg.crossing
+ return dict(side=flat["edge"], methods=flat["methods"], parts=flat["edge_parts"], corner=flat["corner"])
@objc.python_method
- def _show_machines(self):
- """The machine picker, shown with more than one machine paired and built again when the
- machines or their names change, and the words on the page that name the chosen one."""
- settings = self.settings_store.current()
- peers = peerlist.desktops(settings["peers"])
- available = [entry for entry in peers if entry.get("in_use", True) is True]
- if self.chosen_peer not in {entry["id"] for entry in available} and (available or self.chosen_peer is not None):
- self._load_ways()
- self._reflect()
- return
- labels = peerlist.labels(peers)
- choices = [(entry["id"], self._shown(labels[entry["token"]])) for entry in peers
- if entry.get("in_use", True) is True]
- several = len(choices) > 1
- if choices != self._picker_choices:
- self._picker_choices = choices
- for view in list(self.machine_row.arrangedSubviews()):
- self.machine_row.removeArrangedSubview_(view)
- view.removeFromSuperview()
- self.machine_select = None
- if several:
- self.machine_select = widgets.Segmented(choices, columns=min(len(choices), 4), on_change=self._machine_picked)
- widgets.add(self.machine_row, widgets.field_row("Machine", self.machine_select.view)[0])
- motion.set_hidden(self.machine_row, not several)
- if self.machine_select is not None and self.machine_select.value != self.chosen_peer:
- self.machine_select.value = self.chosen_peer
- label = self._chosen_label() if several else None
- self.ways_heading.setStringValue_(f"Ways from this screen to {self._chosen_label()}" if self.chosen_peer else "Ways from this screen")
- caption = pages.where_caption(label)
- if self.edge_caption.text != caption:
- self.edge_caption.set(caption)
- self.edge_select.view.setAccessibilityLabel_(caption)
- self.edge_note.set(pages.notch_or_corner_note(label))
- chosen = self.chosen_peer
- offer = core_ways.share_offer(settings, chosen, self._live) if chosen else None
- holders = [self._shown(peerlist.label_for(peers, peer_id=peer) or peerlist.UNNAMED)
- for peer in offer["holders"]] if offer else []
- identity = (offer["side"], tuple(offer["holders"]), tuple(offer["thirds"].items())) if offer else None
- if identity != getattr(self, "_share_identity", None):
- self._share_identity = identity
- self.share_thirds = dict(offer["thirds"]) if offer else {}
- motion.set_hidden(self.share_box, offer is None)
- if offer:
- side = offer["side"]
- self.share_title.set(f"Share the {side} edge")
- self.share_sentence.set(pages.share_sentence(holders, side, self._chosen_label()))
- self.share_button.set_title(f"Share the {side} edge")
- self.share_recipients = [chosen, *offer["holders"]]
- for part, tile in self.share_tiles.items():
- tile.name.set(pages.part_names(side)[part])
- owner = self.share_thirds[part]
- tile.set_detail(self._shown(peerlist.label_for(peers, peer_id=owner) or peerlist.UNNAMED))
- tile.value = owner == chosen
- self.share_button.set_enabled(chosen in self.share_thirds.values())
- for note, sentence in (
- (self.blocked_note, (core_ways.blocked_sentence(settings, chosen, "this Mac", self._live) if chosen and not offer else "")
- or (core_ways.gone_sentence(settings, chosen, "this Mac", self._gone) if chosen else "")),
- (self.missing_note, core_ways.missing_sentence(settings, chosen, "this Mac") if chosen else ""),
- (self.no_way_back_note, core_ways.no_way_back_sentence(settings, chosen) if chosen else "")):
- note.set(self._shown(sentence))
- motion.set_hidden(note.view, not sentence)
-
- self._show_jump_key()
-
- @objc.python_method
- def _share_third(self, part):
- """Move one offered third to the next machine without writing until Share is pressed."""
- recipients = self.share_recipients
- current = recipients.index(self.share_thirds[part])
- self.share_thirds[part] = recipients[(current + 1) % len(recipients)]
- self._show_machines()
+ def _methods(self):
+ methods = [way for way in self._selected_ways()["methods"] if way != "shortcut"]
+ if self.method_boxes["shortcut"].value:
+ methods.append("shortcut")
+ return methods
@objc.python_method
- def _share_side(self):
- """Apply the proposed split, rebuild the live zones and tell every affected machine."""
- side, thirds = self._share_identity[0], dict(self.share_thirds)
- try:
- changed = self.settings_store.share_side(side, thirds)
- cfg = self.settings_store.load()
- except (SettingsError, ValueError):
- self.logger.exception("The shared side could not be saved")
- return
- self.controller.cfg = cfg
- self.controller.zones_changed()
- for peer in changed:
- self._tell(peer)
- self._load_ways()
- self._reflect()
-
+ def _load_ways(self, flat=None):
+ peers = peerlist.desktops(self.settings_store.current()["peers"])
+ if self.chosen_peer not in {entry["id"] for entry in peers}:
+ self.chosen_peer = peers[0]["id"] if peers else None
+ self._show_machines()
+ @objc.python_method
+ def _show_machines(self):
+ if hasattr(self, "crossing_ledger"):
+ self.crossing_ledger.refresh(self.settings_store.current(), self.chosen_peer)
@objc.python_method
def _machine_picked(self, peer):
# A change still waiting out the pause belongs to the machine being left.
@@ -1723,40 +1744,176 @@ class ControlWindow(AppKit.NSObject):
return self._shown(found) if found else link_state.peer_name(self.controller.cfg)
@objc.python_method
- def _diagram_machines(self, methods):
- """Every machine as the drawing shows it: the chosen one as the controls have it, which may
- be a moment ahead of the settings, the rest as saved."""
+ def _show_arrangement(self, methods=None):
settings = self.settings_store.current()
- peers = peerlist.desktops(settings["peers"])
- live = {
- "side": self.edge_select.value or "",
- "methods": [name for name in methods if name != "shortcut"],
- "parts": [name for name, tile in self.part_boxes.items() if tile.value],
- "corner": self.corner_select.value or "top_right",
- }
- if not peers:
- return [{"key": "", "label": link_state.peer_name(self.controller.cfg), "chosen": True, **live}]
- labels = peerlist.labels(peers)
- machines = []
- for entry in peers:
- chosen = entry["id"] == self.chosen_peer
- held = live if chosen else core_ways.ways(settings, entry["id"])
- machines.append({"key": entry["id"], "label": self._shown(labels[entry["token"]]), "chosen": chosen,
- "side": held["side"], "methods": list(held["methods"]), "parts": list(held["parts"]),
- "corner": held["corner"]})
- return machines
-
- @objc.python_method
- def _show_arrangement(self, methods):
- held = self.style_select.value == "hold"
- sentence = self._ways_in_sentence()
- self.ways_note.set(sentence + "." if sentence else "No way in is switched on. Choose one below.")
- machines = self._diagram_machines(methods)
- self.arrangement_diagram.show(
- machines, widgets.key_cap(self.key_recorder.value), self.has_notch,
- pages.arrangement_description(machines, sentence), key_how="hold" if held else "double-tap",
- shortcut="shortcut" in methods,
- )
+ own = settings.get("machine_id", "")
+ entries = {entry["id"]: entry for entry in peerlist.desktops(settings["peers"])}
+ stored = self._atlas_layout_for(settings)
+ excluded = {peer for peer, entry in entries.items() if entry.get("left_out")
+ or entry.get("dormant") or entry.get("in_use", True) is False}
+ tiles = {key: dict(tile) for key, tile in stored.items() if key not in excluded}
+ caps = self._design_peer_caps()
+ capable = self._crossing_args()["capable"]
+ result = core_ways.compile_layout(settings, tiles, capable=capable)
+ states = result.get("tiles", {})
+ names = {peer: self._shown(peerlist.label_for(settings["peers"], peer_id=peer) or peerlist.UNNAMED)
+ for peer in entries}
+ names[own] = "This Mac"
+ older = {peer for peer, values in caps.items() if "layout" not in values}
+ for peer, entry in entries.items():
+ held = core_ways.ways(settings, peer)
+ picked = core_ways.picked_thirds(held["methods"], held["parts"])
+ state = dict(states.get(peer, {"state": "gap", "thirds": []}))
+ state.update(in_use=entry.get("in_use", True) is True, linked=self._live(peer),
+ platform={"macos": "macOS"}.get(entry.get("platform", ""), machines.platform_name(entry.get("platform", ""))),
+ version=entry.get("app", ""), crosses=core_ways.crosses_on_map(settings, peer),
+ picked_thirds=picked,
+ lit_thirds=[part for part in picked if part in state.get("thirds", picked)]
+ if "part" in held["methods"] else [],
+ edge_off=not bool(picked))
+ if peer not in excluded and "corner" in held["methods"]:
+ state["corner_way"] = held["corner"]
+ state["notch_way"] = bool(peer not in excluded and self.has_notch and "notch" in held["methods"])
+ states[peer] = state
+ try:
+ notch = diagram.notch_span(self.controller.notch_range, self.controller.crossing_display_map())
+ except Exception:
+ notch = None
+ self.atlas_canvas.show_layout(
+ tiles, {own: {"state": "this", "platform": "macOS", "notch_span": notch,
+ "machine_name": settings.get("name", "") or socket.gethostname().split(".")[0]}, **states},
+ names, own, self.chosen_peer or own,
+ cycle={peer: entry.get("shortcut_cycle") is not False for peer, entry in entries.items()},
+ cycle_enabled=(self.shortcut_goes_to.value or "last") == "ticked", older=older,
+ animate=motion.live(self.atlas_canvas))
+ self._show_machines()
+ @objc.python_method
+ def _atlas_default_layout(self, settings):
+ return core_ways.derive_layout(settings, gap=0)
+
+ @objc.python_method
+ def _atlas_layout_for(self, settings):
+ return self._atlas_default_layout(settings)
+
+ @objc.python_method
+ def _atlas_selected(self, peer):
+ if peer == self.own_id():
+ self.atlas_canvas.selected = self.chosen_peer or self.own_id()
+ self.atlas_canvas._draw(False)
+ return
+ self._machine_picked(peer)
+
+ @objc.python_method
+ def _open_pairing(self):
+ self._select_page("overview")
+ self.window.makeFirstResponder_(self.panel.sheet.show_button.view)
+
+ @objc.python_method
+ def _re_pair_peer(self, peer):
+ entry = next((item for item in self.settings_store.current()["peers"] if item.get("id") == peer), None)
+ if entry is not None:
+ self._select_page("overview")
+ self.panel.re_pair(entry["token"])
+
+ @objc.python_method
+ def _open_forget(self, peer):
+ entry = next((item for item in self.settings_store.current()["peers"] if item.get("id") == peer), None)
+ if entry is None:
+ return
+ self._select_page("overview")
+ self.panel._ask_to_remove(entry.get("token"))
+
+ @objc.python_method
+ def _atlas_layout_changed(self, tiles, moved, snap=True):
+ self._flush()
+ held = self.settings_store.current()
+ previous = self._atlas_layout_for(held)
+ radius = 0
+ if snap:
+ _frames, scale = self.atlas_canvas._map()
+ radius = self.atlas_canvas.snap_radius_for_scale(scale)
+ try:
+ outcome = self.controller.crossing_event(crossing_state.drop, tiles, moved,
+ snap_radius=radius, **self._crossing_args())
+ except (SettingsError, OSError, TypeError, ValueError):
+ self.logger.exception("could not save the desk layout")
+ self.atlas_canvas.show_layout(previous, {}, {}, held.get("machine_id", ""), self.chosen_peer, animate=False)
+ return
+ if not outcome["accepted"]:
+ labels = {entry.get("id"): peerlist.label_for(held["peers"], peer_id=entry.get("id")) or "Machine"
+ for entry in peerlist.desktops(held["peers"])}
+ self.atlas_canvas.show_layout(previous, {}, labels,
+ held.get("machine_id", ""), self.chosen_peer, animate=True)
+ self._say("Refused: that position is already occupied.", "fault")
+ return
+ self._load_ways()
+ self._reflect()
+ if moved in outcome["settings"]["layout"]:
+ tile_state = dict(outcome["tiles"].get(moved, {}))
+ tile_state["crosses"] = core_ways.crosses_on_map(self.settings_store.current(), moved)
+ self.atlas_canvas.announce_move(moved, outcome["settings"]["layout"][moved], tile_state)
+
+ @objc.python_method
+ def _begin_atlas_rename(self, peer):
+ if peer in self.crossing_ledger.rows:
+ self.crossing_ledger.rows[peer].begin_rename()
+ def control_textView_doCommandBySelector_(self, control, _text_view, selector):
+ for row in self.crossing_ledger.rows.values():
+ if control is row.name_field:
+ if selector == "insertNewline:":
+ row.finish_rename(True)
+ return True
+ if selector == "cancelOperation:":
+ row.finish_rename(False)
+ return True
+ return False
+ @objc.python_method
+ def _save_atlas_rename(self):
+ for row in self.crossing_ledger.rows.values():
+ if row.renaming:
+ row.finish_rename(True)
+ @objc.python_method
+ def _cancel_atlas_rename(self):
+ for row in self.crossing_ledger.rows.values():
+ if row.renaming:
+ row.finish_rename(False)
+ @objc.python_method
+ def _set_atlas_left_out(self, peer, enabled):
+ self._flush()
+ settings = self.settings_store.current()
+ entry = next((item for item in settings["peers"] if item.get("id") == peer), None)
+ if entry is None:
+ return
+ if not enabled and entry.get("in_use", True) is False:
+ self.direction_handler(entry.get("token"), in_use=True)
+ settings = self.settings_store.current()
+ try:
+ self.controller.crossing_event(
+ crossing_state.leave_out if enabled else crossing_state.put_back, peer, **self._crossing_args())
+ except (SettingsError, OSError, TypeError, ValueError):
+ self.logger.exception("could not save whether the machine is left out")
+ return
+ if enabled and self.chosen_peer == peer:
+ self.chosen_peer = None
+ self._load_ways()
+ self._reflect()
+
+ @objc.python_method
+ def _set_shortcut_cycle(self, peer, enabled):
+ self._flush()
+ try:
+ with self.settings_store.lock:
+ settings = copy.deepcopy(self.settings_store.current())
+ entry = next((item for item in settings["peers"] if item.get("id") == peer), None)
+ if entry is None:
+ return
+ entry["shortcut_cycle"] = bool(enabled)
+ self.settings_store.save_settings(settings)
+ self.controller.cfg = self.settings_store.load()
+ except (SettingsError, OSError, TypeError, ValueError):
+ self.logger.exception("could not save a shortcut cycle choice")
+ return
+ self._show_arrangement()
@objc.python_method
def _preview_resistance(self, value):
@@ -1766,8 +1923,8 @@ class ControlWindow(AppKit.NSObject):
self._changed()
# A machine not placed yet has no edge to light, and the glow turns itself off for the run
# on one it cannot draw.
- if self.preview is not None and self.glow_box.value and self.edge_select.value:
- self.preview(self.edge_select.value, min(1.0, value / 500.0))
+ if self.preview is not None and self.glow_box.value and self._selected_ways()["side"]:
+ self.preview(self._selected_ways()["side"], min(1.0, value / 500.0))
@objc.python_method
def _show_peer(self):
@@ -1802,6 +1959,41 @@ class ControlWindow(AppKit.NSObject):
controller = self.controller
return controller.on_label or controller.peer_label or link_state.peer_name(controller.cfg)
+ @objc.python_method
+ def _header_response_time(self):
+ controller = self.controller
+ server = self.windows_input.server if self.windows_input is not None else None
+ incoming_by_text = {}
+ if server is not None:
+ for remote_id in server.links():
+ text_id = remote_id if isinstance(remote_id, str) else protocol.id_text(remote_id)
+ incoming_by_text[text_id] = remote_id
+ incoming = set(incoming_by_text)
+ with controller._owner_lock:
+ outgoing_links = list(controller._peers_up.items())
+ outgoing = {peer for peer, link in outgoing_links if link.live()}
+ driver = server.owner if server is not None else None
+ if driver is not None and not isinstance(driver, str):
+ driver = protocol.id_text(driver)
+ active = (controller.owner.on, driver)
+ peer = next((candidate for candidate in active if candidate in outgoing or candidate in incoming), None)
+ if peer is None:
+ current = controller._status_link()
+ if current is not None and current.live():
+ peer = current.peer_id
+ if peer is None:
+ candidates = outgoing | incoming
+ peer = min(candidates) if candidates else None
+ if peer is None:
+ return "—", None, False
+ link = controller._link_of(peer)
+ response = getattr(link, "response_time_ms", None) if link is not None and link.live() else None
+ if response is None and server is not None and peer in incoming:
+ lookup = getattr(server, "response_time_ms", None)
+ response = lookup(incoming_by_text[peer]) if lookup is not None else None
+ label = controller._label(lambda entry: entry.get("id") == peer) or "another machine"
+ return label, response, True
+
@objc.python_method
def _live(self, peer):
"""Whether `peer` has a link up now, either way. One that has none gives way on the Crossing
@@ -1819,30 +2011,8 @@ class ControlWindow(AppKit.NSObject):
@objc.python_method
def settle_presence(self):
- """Puts back the zones set aside for a machine that has connected since, and keeps off for good,
- and says so, those of one that has removed this pairing (core/ways.py settle_presence). Run on
- every status tick, whether or not the window is shown."""
- if not core_ways.presence_due(self.settings_store.current(), self._live, self._gone):
- return
- self._flush()
- before = core_ways.way_back_state(self.settings_store.current())
- try:
- changed, notices = self.settings_store.settle_presence(self._live, self._gone)
- cfg = self.settings_store.load() if changed else None
- except SettingsError:
- self.logger.exception("could not settle the zones set aside")
- return
- if not changed:
- return
- self.controller.cfg = cfg
- self.controller.zones_changed()
- for notice in notices:
- self.controller._alert("Beamer", notice)
- self._load(config_to_raw(cfg))
- self.refresh()
- for target, state in core_ways.way_back_state(self.settings_store.current()).items():
- if before.get(target) != state:
- self._tell(target)
+ """Picture peers retain intent independently of presence."""
+ return
@objc.python_method
def inbound_ids(self):
@@ -1917,7 +2087,7 @@ class ControlWindow(AppKit.NSObject):
"top": (((0, height - 7), (width, 7)), (0.5, 0), (0.5, 1)),
"bottom": (((0, 0), (width, 7)), (0.5, 1), (0.5, 0)),
}
- frame, start, end = frames.get(self.edge_select.value, frames["right"])
+ frame, start, end = frames.get(self._selected_ways()["side"], frames["right"])
Quartz.CATransaction.begin()
Quartz.CATransaction.setDisableActions_(True)
self.preview_glow.setFrame_(frame)
@@ -1935,7 +2105,8 @@ class ControlWindow(AppKit.NSObject):
def _hold_changed(self, value):
# The controller reads this at every crossing, so it must not wait out the debounce; the
# controller's config is the one the pending save builds on.
- self.controller.cfg.crossing["hold_full_screen"] = value
+ with self.controller._cfg_lock:
+ self.controller.cfg.crossing["hold_full_screen"] = value
self._changed()
@objc.python_method
@@ -1944,13 +2115,46 @@ class ControlWindow(AppKit.NSObject):
applied once the control has been still for a moment, so a ruler being dragged writes once
at the end rather than on every step."""
self._reflect()
+ if hasattr(self, "length_select"):
+ self._refresh_design_readouts()
self._save_pending = True
self._apply_serial += 1
serial = self._apply_serial
AppHelper.callLater(0.3, lambda: serial == self._apply_serial and self._apply_settings())
+ @objc.python_method
+ def _design_slider_changed(self, control, sender):
+ event = AppKit.NSApp.currentEvent()
+ if event is not None and event.type() == AppKit.NSEventTypeLeftMouseDragged:
+ stops = tuple(stop * control.scale for stop in control.stops)
+ value = effects.snap_detent(sender.doubleValue(), sender.minValue(), sender.maxValue(), stops)
+ sender.setDoubleValue_(value)
+ self._refresh_design_readouts()
+ # A still is the same frame of its effect at every Length, so only Size redraws the tiles.
+ if control is not self.length_select:
+ for preview in self.effect_stills:
+ preview.setNeedsDisplay_(True)
+ self._changed()
+
+ @objc.python_method
+ def _refresh_design_readouts(self):
+ pace = self.length_select.numeric_value()
+ fraction = self.size_select.numeric_value()
+ style = self.glow_style_select.value or "glow"
+ if self.style_for_select.value == "switch" and self.landing_box.value:
+ style = effects.switch_effect(self.switch_style_select.value or "match", style).id
+ main_screen = AppKit.NSScreen.mainScreen()
+ screen = main_screen.frame().size if main_screen else AppKit.NSMakeSize(1728, 1084)
+ length_text, size_text = effects.design_slider_readouts(style, pace, fraction, screen.width, screen.height)
+ self.length_readout.set(length_text)
+ self.size_readout.set(size_text)
+ self.length_select.set_accessible_value(length_text)
+ self.size_select.set_accessible_value(size_text)
+
def windowWillClose_(self, _notification):
self._remember_normal_frame()
+ if self.activation_policy_handler is not None:
+ self.activation_policy_handler(window_open=False)
try:
with self.settings_store.lock:
settings = dict(self.settings_store.current())
@@ -1959,7 +2163,8 @@ class ControlWindow(AppKit.NSObject):
except SettingsError as exc:
self.logger.warning("Could not save settings window frame: %s", exc)
self.key_recorder.cancel()
- self.jump_recorder.cancel()
+ for row in self.crossing_ledger.rows.values():
+ row.jump.cancel()
self.ignored_recorder.cancel()
# A code that stays up with nobody watching would still accept a pairing.
self.panel.stop_showing()
@@ -2064,13 +2269,52 @@ class ControlWindow(AppKit.NSObject):
# Pairing stays at the top even when machines are already paired.
self.overview_body = body
widgets.add(body, self.panel.machines_module.view)
+ widgets.add(body, self.panel.own_name_module().view)
widgets.add(body, self.panel.sheet.view)
widgets.add(body, self._status_module().view)
widgets.add(body, self._keyboard_module().view)
widgets.add(body, self._same_module().view)
widgets.add(body, self._login_module().view)
+ widgets.add(body, self._dock_module().view)
widgets.add(body, self._updates_module().view)
+ @objc.python_method
+ def _rename_own(self, text):
+ raw = copy.deepcopy(self.settings_store.current())
+ raw["name"] = text.strip()[:protocol.MAX_NAME_CHARS]
+ raw["name_set_at"] = settings_sync.next_stamp(raw.get("name_set_at", 0), time.time())
+ raw["name_by"] = self.own_id()
+ try:
+ saved = self.settings_store.save_settings(raw)
+ except (SettingsError, TypeError, ValueError) as exc:
+ self.logger.exception("This Mac's name could not be saved")
+ self._say(f"Could not save this Mac's name: {exc}", "fault")
+ return
+ cfg = self.settings_store._config(saved)
+ self.controller.apply_settings(cfg)
+ display = saved.get("name", "") or socket.gethostname().split(".")[0] or "Mac"
+ self.panel._own_rename_views[0].setStringValue_(display)
+ if settings_sync.group_on(cfg, "names"):
+ self._send_same()
+
+ @objc.python_method
+ def _rename_peer(self, token, text):
+ raw = copy.deepcopy(self.settings_store.current())
+ entry = next((item for item in raw["peers"] if item.get("token") == token), None)
+ if entry is None:
+ return
+ entry.update(settings_sync.rename_peer(entry, text, self.own_id(), time.time()))
+ try:
+ saved = self.settings_store.save_settings(raw)
+ except (SettingsError, TypeError, ValueError) as exc:
+ self.logger.exception("A machine's name could not be saved")
+ self._say(f"Could not save the machine's name: {exc}", "fault")
+ return
+ self.controller.apply_settings(self.settings_store._config(saved))
+ self.panel.refresh()
+ if settings_sync.group_on(self.controller.cfg, "names"):
+ self._send_same()
+
@objc.python_method
def _place_machines(self, first):
"""Keep the primary pairing action immediately below the Overview title."""
@@ -2089,12 +2333,51 @@ class ControlWindow(AppKit.NSObject):
def _same_module(self):
module = widgets.Module()
module.add(widgets.eyebrow("Settings"))
- self.same_switch = widgets.Switch("Same on all machines", on_change=self._set_same)
- module.add(self.same_switch.view)
+ module.add(widgets.label("Same on all machines", theme.TYPE["body"]))
+ self.same_checks = {}
+ for key, title in (("crossing", "Crossing"), ("design", "Design"), ("shortcut", "Shortcut"), ("names", "Names")):
+ button = AppKit.NSButton.alloc().initWithFrame_(((0, 0), (0, 0)))
+ button.setTranslatesAutoresizingMaskIntoConstraints_(False)
+ button.setFont_(theme.font(theme.TYPE["body"]))
+ button.setButtonType_(AppKit.NSButtonTypeSwitch)
+ button.setTitle_(title)
+ button.setTarget_(self)
+ button.setAction_("sameGroupsChanged:")
+ button.setTag_(("crossing", "design", "shortcut", "names", "everything").index(key))
+ module.add(button, full_width=False)
+ self.same_checks[key] = button
+ module.add(widgets.note(
+ "Crossing shares resistance and drag protection. Design shares effects, colour, length, size and arrival animation. "
+ "Shortcut shares shortcut on/off, trigger key and style, and destination. Names shares this machine's name and paired-machine labels."
+ ).view)
+ button = AppKit.NSButton.alloc().initWithFrame_(((0, 0), (0, 0)))
+ button.setTranslatesAutoresizingMaskIntoConstraints_(False)
+ button.setFont_(theme.font(theme.TYPE["body"]))
+ button.setButtonType_(AppKit.NSButtonTypeSwitch)
+ button.setTitle_("Everything")
+ button.setTarget_(self)
+ button.setAction_("sameGroupsChanged:")
+ button.setTag_(4)
+ module.add(button, full_width=False)
+ self.same_checks["everything"] = button
+ self.same_everything_note = widgets.note("Shares every group and can replace local values on this machine.")
+ module.add(self.same_everything_note.view)
+ self.same_old_note = widgets.note("Older Beamer versions share known Crossing and Design settings without group choices.")
+ module.add(self.same_old_note.view)
+ self.same_revert = widgets.Button("Revert", self, "revertSame:", scale="small")
+ module.add(self.same_revert.view)
self.same_note = widgets.note()
module.add(self.same_note.view)
return module
+ def sameGroupsChanged_(self, sender):
+ keys = ("crossing", "design", "shortcut", "names", "everything")
+ selected = [key for key in keys[:4] if self.same_checks[key].state() == AppKit.NSControlStateValueOn]
+ if sender.tag() == 4:
+ selected = list(settings_sync.groups_for_choice(
+ ["everything"] if sender.state() == AppKit.NSControlStateValueOn else []))
+ self._set_same_groups(selected)
+
@objc.python_method
def _own_note(self, text=pages.OWN_ROW):
"""A note on a row this Mac keeps to itself, shown only while the pages are kept in step."""
@@ -2105,25 +2388,30 @@ class ControlWindow(AppKit.NSObject):
@objc.python_method
def _peer_too_old(self):
- """Whether a link is up to a PC whose Beamer does not keep settings in step."""
- links = [(True, getattr(self.controller, "peer_settings", None))]
- if self.windows_input is not None:
- links.append((self.windows_input.state == ServerState.CONNECTED, self.windows_input.peer_settings))
- return any(up and known is False for up, known in links)
+ """Whether a connected peer predates group-aware settings messages."""
+ return (getattr(self.controller, "peer_settings", None) is False
+ or self.windows_input is not None and self.windows_input.state == ServerState.CONNECTED
+ and self.windows_input.peer_settings is False
+ or any("layout" not in caps for caps in self._design_peer_caps().values()))
@objc.python_method
def _show_same(self):
cfg = self.controller.cfg
old = self._peer_too_old()
- on = cfg.same_on_both and not old
- if self.same_switch.value != on:
- self.same_switch.value = on
- self.same_switch.set_enabled(not old)
+ groups = settings_sync.normalise_groups(cfg.same_groups)
+ for key in settings_sync.ALL_GROUPS:
+ self.same_checks[key].setState_(AppKit.NSControlStateValueOn if key in groups else AppKit.NSControlStateValueOff)
+ self.same_checks["everything"].setState_(AppKit.NSControlStateValueOn if len(groups) == len(settings_sync.ALL_GROUPS) else AppKit.NSControlStateValueOff)
+ self.same_everything_note.view.setHidden_(len(groups) != len(settings_sync.ALL_GROUPS))
+ self.same_old_note.view.setHidden_(not old)
+ snapshot = self.settings_store.current().get("same_before_sync")
+ self.same_revert.view.setHidden_(not settings_sync.snapshot_available(snapshot))
who = settings_sync.who(list(peerlist.labels(peerlist.desktops(self.controller.book.peers())).values()))
- self.same_note.set(settings_sync.switch_note(who, cfg.same_on_both, old), ink="amber" if old else "ink_2")
+ on = cfg.same_on_both
+ self.same_note.set(settings_sync.group_note(groups, on), ink="ink_2")
self.same_note.view.setToolTip_(settings_sync.switch_detail("mac"))
for key, label in self.scope_labels.items():
- text = settings_sync.scope(key, who, on, pages.SCOPE.get(key), "mac")
+ text = settings_sync.scope(key, who, on, pages.SCOPE.get(key), "mac", groups=groups)
if label.text != text:
label.set(text)
for note in self.own_notes:
@@ -2133,12 +2421,18 @@ class ControlWindow(AppKit.NSObject):
@objc.python_method
def _set_same(self, on):
- """Turning it on carries this Mac's Crossing and Design across; off, each end keeps what it
- has. Either way the PC follows, now if a link is up, else when one next comes up."""
- raw = config_to_raw(self.controller.cfg)
- raw["same_on_both"] = bool(on)
+ """Turning it on carries across each of this Mac's Crossing and Design values that was chosen
+ more recently than the group's; off, each end keeps what it has. Either way the PC follows,
+ now if a link is up, else when one next comes up. A change of policy stamps no value."""
+ cfg = self.controller.cfg
+ raw = config_to_raw(cfg)
+ # Each value keeps the stamp it held before this change of policy, taken once and stored.
+ raw["same_stamps"] = settings_sync.stored_stamps(
+ settings_sync.held_stamps(cfg.same_stamps, cfg.same_set_at, cfg.same_by))
raw["same_set_at"] = settings_sync.next_stamp(raw["same_set_at"], time.time())
raw["same_by"] = self.own_id()
+ raw["same_groups"] = list(settings_sync.ALL_GROUPS) if on else []
+ raw["same_on_both"] = bool(on)
try:
cfg = self.settings_store.save(raw)
except SettingsError as exc:
@@ -2150,6 +2444,66 @@ class ControlWindow(AppKit.NSObject):
self._apply_followed_design(force=True)
self._show_same()
+ @objc.python_method
+ def _set_same_groups(self, groups):
+ cfg = self.controller.cfg
+ raw = config_to_raw(cfg)
+ # Each value keeps the stamp it held before this change of policy, taken once and stored.
+ raw["same_stamps"] = settings_sync.stored_stamps(
+ settings_sync.held_stamps(cfg.same_stamps, cfg.same_set_at, cfg.same_by))
+ raw["same_set_at"] = settings_sync.next_stamp(raw["same_set_at"], time.time())
+ raw["same_by"] = self.own_id()
+ raw["same_groups"] = list(settings_sync.normalise_groups(groups))
+ raw["same_on_both"] = bool(raw["same_groups"])
+ try:
+ cfg = self.settings_store.save(raw)
+ except SettingsError as exc:
+ self.logger.warning("Same groups not saved: %s", exc)
+ return
+ self.controller.apply_settings(cfg)
+ self._send_same()
+ if not settings_sync.group_on(cfg, "design"):
+ self._apply_followed_design(force=True)
+ self._show_same()
+
+ def revertSame_(self, _sender):
+ stored = copy.deepcopy(self.settings_store.current())
+ restored = settings_sync.restore_snapshot(stored.get("same_before_sync"))
+ if restored is None:
+ return
+ values, conflict = core_ways.shared_trigger_values(stored, restored["values"])
+ if conflict:
+ self._show_trigger_conflict(conflict)
+ cfg = self.controller.cfg
+ raw = config_to_raw(cfg)
+ before = settings_sync.mac_values(raw)
+ design_stamp = settings_sync.design_change_stamp(before, values, cfg.design_set_at, None, self.own_id())
+ raw = settings_sync.apply_mac(raw, values)
+ if design_stamp is not None:
+ raw["design_set_at"], raw["design_by"] = design_stamp["set_at"], design_stamp["by"]
+ # The values put back are a choice made here now: each is stamped, the rest keep theirs.
+ held = settings_sync.held_stamps(cfg.same_stamps, cfg.same_set_at, cfg.same_by)
+ stamps, _stamp = settings_sync.stamp_changes(held, before, settings_sync.mac_values(raw), self.own_id(),
+ floor=max(cfg.same_set_at, cfg.design_set_at))
+ raw["same_stamps"] = settings_sync.stored_stamps(stamps)
+ names = settings_sync.restamp_names(stored, restored.get("names", {}), self.own_id())
+ settings_sync.apply_names(stored, names)
+ raw["same_groups"] = settings_sync.revert_groups(stored["same_before_sync"], cfg.same_groups)
+ raw["same_on_both"] = bool(raw["same_groups"])
+ raw["same_set_at"] = settings_sync.next_stamp(max(raw["same_set_at"], raw["design_set_at"]), time.time())
+ raw["same_by"] = self.own_id()
+ try:
+ cfg = self.settings_store.save(raw, settings_changes=stored,
+ remove_settings=("same_before_sync",))
+ except (SettingsError, TypeError, ValueError):
+ self.logger.exception("Same settings could not be reverted")
+ return
+ self.controller.apply_settings(cfg)
+ self._load_shared(config_to_raw(cfg))
+ self.panel.refresh()
+ self._send_same()
+ self._show_same()
+
@objc.python_method
def same_state(self):
"""This Mac's settings message, for a change here and for announcing on a new link. Called
@@ -2159,24 +2513,37 @@ class ControlWindow(AppKit.NSObject):
design_state = {
"set_at": cfg.design_set_at,
"by": cfg.design_by or self.own_id(),
- "values": {key: values[key] for key in settings_sync.DESIGN_KEYS},
+ "values": {key: values[key] for key in settings_sync.DESIGN_KEYS if key in values},
"path": (self._design_path or [self.own_id()])
- if cfg.design_follow_peer and not cfg.same_on_both else [self.own_id()],
+ if cfg.design_follow_peer and not settings_sync.group_on(cfg, "design") else [self.own_id()],
}
+ stored = self.settings_store.current()
+ layout_tiles = copy.deepcopy(stored.get("layout", {}))
+ for entry in peerlist.desktops(stored.get("peers", [])):
+ tile = layout_tiles.get(entry.get("id"))
+ name = entry.get("name", "")
+ if isinstance(tile, dict) and isinstance(name, str) and name.strip():
+ tile["name"] = name.strip()[:64]
+ layout_state = {"set_at": stored.get("layout_set_at", 0),
+ "by": stored.get("layout_by") or self.own_id(),
+ "tiles": layout_tiles}
return settings_sync.message_data(cfg.same_on_both, cfg.same_set_at,
- values, by=cfg.same_by or self.own_id(), design_state=design_state)
+ values, by=cfg.same_by or self.own_id(), design_state=design_state,
+ names=settings_sync.names_from_settings(self.settings_store.current()),
+ layout_state=layout_state, groups=cfg.same_groups,
+ stamps=settings_sync.held_stamps(cfg.same_stamps, cfg.same_set_at, cfg.same_by))
@objc.python_method
def _apply_followed_design(self, force=False):
cfg = self.controller.cfg
peer = cfg.design_follow_peer
state = self._design_states.get(peer)
- if not peer or state is None or cfg.same_on_both:
+ if not peer or state is None or settings_sync.group_on(cfg, "design"):
return
current = settings_sync.mac_values(config_to_raw(cfg))
cursor = self._followed_version
stamp, author = cursor[1:] if cursor and cursor[0] == peer else (-1, "")
- taken = settings_sync.followed_design(current, state, peer, peer, cfg.same_on_both,
+ taken = settings_sync.followed_design(current, state, peer, peer, settings_sync.group_on(cfg, "design"),
stamp, author, own_id=self.own_id(), force=force)
if taken is None:
return
@@ -2241,31 +2608,92 @@ class ControlWindow(AppKit.NSObject):
peer_id = protocol.id_text(peer) if isinstance(peer, bytes) else peer
if peer_id is not None and peer_id not in {entry.get("id") for entry in peerlist.desktops(self.controller.book.peers())}:
return
+ settings = copy.deepcopy(self.settings_store.current())
+ cfg = self.controller.cfg
+ taken = settings_sync.arrived(data, cfg.same_set_at, KEY_NAME_TO_CODE, by_here=cfg.same_by,
+ current_groups=cfg.same_groups)
+ policy_groups = settings_sync.arrival_groups(data, cfg.same_groups) if taken is not None else cfg.same_groups
+ policy_on = taken[0] if taken is not None else cfg.same_on_both
+ current_names = settings_sync.names_from_settings(settings)
+ updates, own_name = settings_sync.names_arrived(
+ data, current_names, self.own_id(),
+ current_groups=cfg.same_groups, policy_groups=policy_groups if policy_on else (),
+ )
+ names_changed = settings_sync.apply_names(settings, updates)
+ name_snapshot = None
+ if names_changed:
+ labels_changed = any(current_names.get(ident, {}).get("label", "") != entry["label"]
+ for ident, entry in updates.items())
+ name_snapshot = settings_sync.same_snapshot(
+ self.controller.cfg.same_groups, settings_sync.mac_values(config_to_raw(self.controller.cfg)),
+ value_groups=(), names=current_names,
+ ) if labels_changed else None
+ if name_snapshot is not None:
+ settings["same_before_sync"] = name_snapshot
+ try:
+ saved = self.settings_store.save_settings(settings)
+ except (SettingsError, TypeError, ValueError):
+ self.logger.exception("could not save machine names sent by %s", peer)
+ return
+ self.controller.apply_settings(self.settings_store._config(saved))
+ self.panel.refresh()
+ if own_name is not None and hasattr(self.panel, "_own_rename_views"):
+ display = own_name or socket.gethostname().split(".")[0] or "Mac"
+ self.panel._own_rename_views[0].setStringValue_(display)
cfg = self.controller.cfg
- was_on = cfg.same_on_both
- taken = settings_sync.arrived(data, cfg.same_set_at, KEY_NAME_TO_CODE, by_here=cfg.same_by)
- if taken is not None:
- on, set_at, values = taken
+ layout_applied = self._receive_layout(data, peer_id)
+ was_design_on = settings_sync.group_on(cfg, "design")
+ # Value by value: each shared value is taken when its own stamp is newer than the one held
+ # here, whether or not the whole state is; the whole state decides only on, off and groups.
+ merged = settings_sync.merge(data, cfg.same_stamps, cfg.same_set_at, KEY_NAME_TO_CODE, by_here=cfg.same_by,
+ on_here=cfg.same_on_both, current_groups=cfg.same_groups)
+ policy = merged["policy"] if merged is not None else None
+ values, taken = {}, False
+ if merged is not None and merged["values"]:
+ values, conflict = core_ways.shared_trigger_values(self.settings_store.current(), merged["values"])
+ if conflict is not None:
+ self._show_trigger_conflict(conflict)
+ # A value kept here over a clash is not taken: counted, every copy of the message would be
+ # taken again and sent on, round three machines for ever.
+ taken = any(values.get(key) == value for key, value in merged["values"].items())
+ if merged is not None and (policy is not None or taken):
+ on = merged["on"]
raw = config_to_raw(cfg)
+ old_groups = settings_sync.normalise_groups(cfg.same_groups)
+ before_values = settings_sync.mac_values(raw)
+ snapshot = settings_sync.snapshot_for_arrival(
+ data, cfg.same_set_at, KEY_NAME_TO_CODE, cfg.same_by, old_groups, before_values,
+ applied_values=values, merged=merged,
+ )
+ if snapshot is not None:
+ if name_snapshot is not None:
+ snapshot["names"] = name_snapshot["names"]
+ snapshot.pop("selection_only", None)
+ raw["same_before_sync"] = snapshot
+ # A value kept here on a clash keeps its own stamp, so it is not taken as the sender's.
+ held = settings_sync.held_stamps(cfg.same_stamps, cfg.same_set_at, cfg.same_by)
+ held.update({key: stamp for key, stamp in merged["stamps"].items()
+ if key in values and values[key] == merged["values"][key]})
+ raw["same_stamps"] = settings_sync.stored_stamps(held)
+ if policy is not None:
+ raw["same_groups"] = list(merged["groups"])
+ raw["same_on_both"] = on
+ raw["same_set_at"] = policy[1]
+ raw["same_by"] = data.get("by", "")
design_stamp = None
- if on:
- values, conflict = core_ways.shared_trigger_values(self.settings_store.current(), values)
- if conflict is not None:
- self._show_trigger_conflict(conflict)
+ if values:
design_stamp = settings_sync.design_change_stamp(
settings_sync.mac_values(raw), values, cfg.design_set_at,
settings_sync.read_design_state(data, KEY_NAME_TO_CODE), self.own_id(),
)
- raw["same_on_both"] = on
- raw["same_set_at"] = set_at
- raw["same_by"] = data.get("by", "")
- if on:
raw = settings_sync.apply_mac(raw, values)
if design_stamp is not None:
raw["design_set_at"] = design_stamp["set_at"]
raw["design_by"] = design_stamp["by"]
try:
- cfg = self.settings_store.save(raw)
+ cfg = self.settings_store.save(
+ raw, settings_changes={"same_before_sync": snapshot} if snapshot is not None else None,
+ )
except (SettingsError, TypeError, ValueError):
self.logger.exception("could not save the settings %s sent", peer)
return
@@ -2280,11 +2708,31 @@ class ControlWindow(AppKit.NSObject):
self.logger.info("settings from %s applied (same on all machines %s)", peer, "on" if on else "off")
self._load_shared(config_to_raw(cfg))
self.refresh()
- resuming = taken is not None and was_on and not on
+ elif names_changed:
+ self._send_same(data, source=peer)
+ if merged is not None and merged["answer"]:
+ # This Mac holds a value newer than the sender's: its own state, so the sender learns it.
+ self._send_same()
+ resuming = policy is not None and was_design_on and not settings_sync.group_on(cfg, "design")
self._receive_design(data, peer, apply=not resuming)
if resuming:
self._apply_followed_design(force=True)
+ @objc.python_method
+ def _receive_layout(self, data, peer):
+ if peer is None or "layout" not in self._design_peer_caps().get(peer, ()):
+ return False
+ state = settings_sync.read_layout_state(data)
+ if state is None:
+ return False
+ outcome = self.controller.crossing_event(crossing_state.receive_picture, state, source=peer,
+ arrived=data, own_displays=self.controller.crossing_display_map(), **self._crossing_args())
+ if not outcome["changed"]:
+ return False
+ self._load_ways()
+ self.refresh()
+ return True
+
@objc.python_method
def _login_module(self):
module = widgets.Module()
@@ -2293,9 +2741,41 @@ class ControlWindow(AppKit.NSObject):
module.add(self.login_switch.view)
self.login_note = widgets.note()
module.add(self.login_note.view)
+ self.login_approval_button = widgets.Button(
+ "Open Login Items settings", self, "openLoginItemsSettings:", full_width=True
+ )
+ self.login_approval_button.view.setHidden_(True)
+ module.add(self.login_approval_button.view)
+ self.login_bundle_path = AppKit.NSBundle.mainBundle().bundlePath()
self._show_login_state()
return module
+ @objc.python_method
+ def _dock_module(self):
+ module = widgets.Module()
+ module.add(widgets.eyebrow("Window"))
+ self.dock_switch = widgets.Switch("Show in Dock", on_change=self._set_show_in_dock)
+ self.dock_switch.value = self.settings_store.current().get("show_in_dock", True)
+ module.add(self.dock_switch.view)
+ module.add(widgets.note(
+ "When off, Beamer stays in the menu bar and appears in the Dock while its window is open."
+ ).view)
+ return module
+
+ @objc.python_method
+ def _set_show_in_dock(self, on):
+ try:
+ with self.settings_store.lock:
+ settings = copy.deepcopy(self.settings_store.current())
+ settings["show_in_dock"] = bool(on)
+ self.settings_store.save_settings(settings)
+ except (SettingsError, TypeError, ValueError) as exc:
+ self.logger.warning("Show in Dock not saved: %s", exc)
+ self.dock_switch.value = self.settings_store.current().get("show_in_dock", True)
+ return
+ if self.activation_policy_handler is not None:
+ self.activation_policy_handler()
+
@objc.python_method
def _updates_module(self):
module = widgets.Module()
@@ -2346,15 +2826,49 @@ class ControlWindow(AppKit.NSObject):
self.logger.exception("could not read the login item")
state = login_item.NOT_FOUND
self.login_switch.value = state in (login_item.ENABLED, login_item.REQUIRES_APPROVAL)
+ in_applications = login_item.installed_in_applications(self.login_bundle_path)
+ self.login_switch.set_enabled(login_item.can_toggle(state, self.login_bundle_path))
if refused:
self.login_note.set(f"macOS refused: {refused}")
elif state == login_item.REQUIRES_APPROVAL:
- self.login_note.set("Waiting for you to allow it in System Settings, General, Login Items.")
+ if in_applications:
+ self.login_note.set(
+ "Login item status: Requires approval. Allow Beamer in System Settings, General, Login Items."
+ )
+ else:
+ self.login_note.set(
+ "Login item status: Requires approval. Move Beamer to Applications and reopen it before allowing it in Login Items."
+ )
+ elif not in_applications:
+ self.login_note.set(
+ f"Login item status: {login_item.status_text(state)}. Move Beamer to Applications and open it there to start at login."
+ )
+ elif state == login_item.NOT_FOUND:
+ self.login_note.set(
+ "Login item status: Not found. Check Beamer is installed in Applications, then turn it on again."
+ )
+ elif state == login_item.ENABLED:
+ self.login_note.set("Login item status: Enabled. Beamer will start when you log in.")
+ elif state == login_item.NOT_REGISTERED:
+ self.login_note.set(
+ "Login item status: Not registered. Turn on Start Beamer when you log in."
+ )
else:
- self.login_note.set("In the menu bar, with no window.")
+ self.login_note.set(f"Login item status: {login_item.status_text(state)}.")
+ self.login_approval_button.view.setHidden_(state != login_item.REQUIRES_APPROVAL)
+
+ def openLoginItemsSettings_(self, _sender):
+ try:
+ login_item.open_system_settings()
+ except Exception as exc:
+ self.logger.warning("could not open Login Items settings: %s", exc)
+ self.login_note.set(f"Could not open Login Items settings: {exc}")
@objc.python_method
def _set_login(self, enabled):
+ if enabled and not login_item.installed_in_applications(self.login_bundle_path):
+ self._show_login_state()
+ return
try:
login_item.set_enabled(enabled)
except OSError as exc:
@@ -2365,11 +2879,16 @@ class ControlWindow(AppKit.NSObject):
@objc.python_method
def _crossing_page(self, body):
- # The shortcut's module is built first: the ways' tiles name its key.
+ # The ledger's Keys cells use the global shortcut's recorder.
self.shortcut_module = self._shortcut_module()
self.resistance_module = self._resistance_module()
- for module in (self._ways_module(), self.resistance_module, self.shortcut_module):
+ machines = self._ways_module()
+ for module in (machines, self._pointer_module(), self.resistance_module, self.shortcut_module):
widgets.add(body, module.view)
+ # The table must fill the page before its notes' preferred reading width is solved.
+ for constraint in body.constraints():
+ if constraint.firstItem() == machines.view and constraint.firstAttribute() == AppKit.NSLayoutAttributeWidth:
+ constraint.setPriority_(499)
@objc.python_method
def _design_page(self, body):
@@ -2415,9 +2934,6 @@ class ControlWindow(AppKit.NSObject):
def _refresh_design_follow(self):
if not hasattr(self, "follow_host"):
return
- for view in self.follow_host.arrangedSubviews():
- self.follow_host.removeArrangedSubview_(view)
- view.removeFromSuperview()
peers = peerlist.desktops(self.settings_store.current()["peers"])
labels = peerlist.labels(peers)
choices = [("", "None")]
@@ -2425,22 +2941,24 @@ class ControlWindow(AppKit.NSObject):
rows = settings_sync.follow_rows(peers, caps, self._design_states, self.controller.cfg.design_follow_peer)
unsupported = {entry["id"]: why_not for entry, why_not in rows if why_not is not None}
for entry, why_not in rows:
- title = labels.get(entry.get("token", ""), entry.get("name") or "Machine")
+ title = labels.get(entry.get("token", "")) or "Machine"
if why_not == settings_sync.NEEDS_DESIGN_SYNC:
title += f" — {why_not}"
choices.append((entry["id"], title))
- self.follow_select = widgets.MenuChoice(choices, on_change=self._set_design_follow)
+ if not hasattr(self, "follow_select"):
+ self.follow_select = widgets.MenuChoice(choices, on_change=self._set_design_follow)
+ widgets.add(self.follow_host, self.follow_select.view, full_width=False)
+ else:
+ self.follow_select.set_choices(choices)
self.follow_select.value = self.controller.cfg.design_follow_peer
for value, cell in self.follow_select.items:
- if value in unsupported:
- cell.setEnabled_(False)
- cell.setToolTip_(unsupported[value])
- widgets.add(self.follow_host, self.follow_select.view, full_width=False)
+ cell.setEnabled_(value not in unsupported)
+ cell.setToolTip_(unsupported[value] if value in unsupported else cell.title())
peer = self.controller.cfg.design_follow_peer
entry = next((item for item in peers if item.get("id") == peer), {}) if peer else {}
- name = labels.get(entry.get("token", ""), entry.get("name") or "that machine")
+ name = labels.get(entry.get("token", "")) or "that machine"
if peer:
- if self.controller.cfg.same_on_both:
+ if settings_sync.group_on(self.controller.cfg, "design"):
note = f"Following {name}, paused while Same on all machines is on."
elif peer not in caps:
note = f"Keeping the last design received from {name} until it reconnects."
@@ -2450,7 +2968,7 @@ class ControlWindow(AppKit.NSObject):
note = settings_sync.follow_note(rows) or "None: this machine keeps its own Design."
self.follow_note.set(note)
self.follow_note.view.setHidden_(not note)
- self._lock_followed_design(settings_sync.follow_lock(peer, self.controller.cfg.same_on_both, peers), name)
+ self._lock_followed_design(settings_sync.follow_lock(peer, settings_sync.group_on(self.controller.cfg, "design"), peers), name)
@objc.python_method
def _set_design_follow(self, peer):
@@ -2622,12 +3140,9 @@ class ControlWindow(AppKit.NSObject):
figure, self.resistance_numeral = self._numeral("px")
module.add(self._head("Resistance", figure))
self.push_strip = diagram.PushStrip.alloc().init().setup()
+ self.push_strip.on_change = self._preview_resistance
+ self.resistance_ruler = self.push_strip
module.add(self.push_strip)
- self.resistance_ruler = widgets.Ruler(
- 0, 500, (0, 100, 200, 300, 400, 500), step=1, minor=25, on_change=self._preview_resistance,
- title="Resistance", arrow_step=10,
- )
- module.add(self.resistance_ruler.view)
self.resistance_hint = widgets.note()
module.add(self.resistance_hint.view)
return module
@@ -2635,135 +3150,45 @@ class ControlWindow(AppKit.NSObject):
@objc.python_method
def _ways_module(self):
module = widgets.Module()
- self.ways_heading = widgets.eyebrow("Ways from this screen")
- # With several machines paired, which one everything per machine below shows and writes.
- module.add(self.ways_heading)
- self.machine_row = widgets.stack(spacing=0)
- self.machine_row.setHidden_(True)
- module.add(self.machine_row)
- # The picker scopes everything under it, so it stands a step apart from what it scopes.
- module.body.setCustomSpacing_afterView_(18, self.machine_row)
- self.ways_note = widgets.note()
- module.add(self.ways_note.view)
- self.arrangement_diagram = diagram.ArrangementDiagram.alloc().init().setup()
- # The pointer's ways first, the shortcut on its own row above its settings.
- ways = (
- ("edge", "Edge", "One whole side"),
- ("part", "Part of the edge", "Only the thirds you pick"),
- ("corner", "Corner", "Push diagonally into a corner"),
- ("notch", "Notch", ""),
- ("shortcut", "Shortcut", ""),
- )
- self.method_boxes = {
- way: widgets.WayTile(title, detail, on_change=lambda on, way=way: self._way_toggled(way, on))
- for way, title, detail in ways
- }
- ways_list = widgets.stack(spacing=0)
- widgets.add(ways_list, widgets.grid([tile.view for tile in self.method_boxes.values()], 2))
- self.ways_pair = widgets.SideBySide(
- self.arrangement_diagram,
- ways_list,
- theme.tokens.CROSSING_ARRANGEMENT_MIN_WIDTH,
- theme.tokens.CROSSING_WAYS_MIN_WIDTH,
- )
- self.side_by_side.append(self.ways_pair)
- module.add(self.ways_pair.view)
- module.body.setCustomSpacing_afterView_(16, self.ways_pair.view)
- module.add(self._own_note(pages.OWN_NOTCH))
- # The values are the side of this Mac the chosen machine is on, which is also the edge that crosses.
- self.edge_select = widgets.Segmented(
- [("left", "Left"), ("right", "Right"), ("top", "Above"), ("bottom", "Below")], on_change=self._changed
- )
- self.edge_select.view.setToolTip_("Changing a side updates the other end's side; it can turn overlapping ways off, with a notice.")
- self.edge_row, self.edge_caption = widgets.field_row(pages.where_caption(None), self.edge_select.view)
- module.add(self.edge_row)
- # A group within Ways, never a panel of its own: a panel inside a panel also forced the
- # window's layout and squeezed the pairing sheet's code boxes to 28 pt.
- self.share_box = widgets.stack(spacing=8)
- self.share_title = widgets.Label("Share the edge", theme.TYPE["eyebrow"], 700, "ink_3",
- tracking=theme.TRACKING["eyebrow"], upper=True)
- widgets.add(self.share_box, self.share_title.view)
- self.share_sentence = widgets.note()
- widgets.add(self.share_box, self.share_sentence.view)
- self.share_thirds = {}
- self.share_tiles = {
- part: widgets.WayTile(pages.part_names("right")[part], on_change=lambda _on, part=part:
- self._share_third(part)) for part in return_edge.PARTS
- }
- widgets.add(self.share_box, widgets.grid([tile.view for tile in self.share_tiles.values()], 3))
- self.share_button = widgets.action_button("Share the right edge", self._share_side, style="primary")
- self.share_box.addArrangedSubview_(self.share_button.view)
- self.share_box.setHidden_(True)
- module.add(self.share_box)
- self.edge_note = widgets.note(pages.notch_or_corner_note(None))
- self.edge_note.view.setHidden_(True)
- module.add(self.edge_note.view)
- self.part_boxes = {
- part: widgets.WayTile(part.capitalize(), on_change=lambda on, part=part: self._part_toggled(part, on))
- for part in return_edge.PARTS
- }
- self.parts_row = widgets.field_row("Parts", widgets.grid([tile.view for tile in self.part_boxes.values()], 3))[0]
- module.add(self.parts_row)
- self.corner_select = widgets.Segmented(
- [
- ("top_left", "Top left"),
- ("top_right", "Top right"),
- ("bottom_left", "Bottom left"),
- ("bottom_right", "Bottom right"),
- ],
- columns=2,
- on_change=self._changed,
- )
- self.corner_select.view.setToolTip_(pages.corner_note())
- self.corner_row = widgets.field_row("Corner", self.corner_select.view)[0]
- module.add(self.corner_row)
- # What stops a way working, under the ways it is about: a side another machine's edge holds,
- # a machine that may drive this Mac and is not paired with the chosen one, and the chosen one
- # saying none of its own ways leads back here.
- self.blocked_note = widgets.note(ink="amber")
- self.missing_note = widgets.note(ink="amber")
- self.no_way_back_note = widgets.note()
- for note in (self.blocked_note, self.missing_note, self.no_way_back_note):
- note.view.setHidden_(True)
- module.add(note.view)
+ module.add(widgets.Label("Machines", theme.TYPE["body"], 600).view)
+ self.atlas_canvas = diagram.AtlasCanvas.alloc().init().setup()
+ self.arrangement_diagram = self.atlas_canvas
+ self.atlas_canvas.on_layout_change = self._atlas_layout_changed
+ self.atlas_canvas.on_select = self._atlas_selected
+ self.atlas_canvas.on_third = self._atlas_third
+ self.atlas_canvas.on_rename = self._begin_atlas_rename
+ self.atlas_canvas.on_cycle_change = self._set_shortcut_cycle
+ self.atlas_canvas.on_leave_out = lambda peer: self._set_atlas_left_out(peer, True)
+ module.add(self.atlas_canvas)
+ self.atlas_canvas_hint = widgets.note("Option-click a display to split or group · drag to move · click a third of a lit edge to leave it out")
+ module.add(self.atlas_canvas_hint.view)
+ module.body.setCustomSpacing_afterView_(8, self.atlas_canvas)
+ crosses = widgets.Label("● Crosses", theme.TYPE["note"], 500, "signal").view
+ offline = widgets.Label("● Offline, ways kept", theme.TYPE["note"], 500, "ink_3").view
+ self.atlas_legend_pair = widgets.SideBySide(crosses, offline, 80, 125, gap=18)
+ for view, width in ((crosses, 80), (offline, 125)):
+ preferred = view.widthAnchor().constraintEqualToConstant_(width)
+ preferred.setPriority_(490)
+ preferred.setActive_(True)
+ self.side_by_side.append(self.atlas_legend_pair)
+ self.atlas_legend = self.atlas_legend_pair.view
+ module.add(self.atlas_legend)
+ self.crossing_ledger = ledger.Ledger.alloc().init().setup(self)
+ module.add(self.crossing_ledger)
+ module.add(widgets.note("Three lit segments are the whole edge; click one to leave it out. A corner is a diagonal push, shown as a square on the map. The notch is this Mac only.").view)
+ return module
+
+ @objc.python_method
+ def _pointer_module(self):
+ module = widgets.Module()
+ module.add(widgets.Label("This machine's pointer", theme.TYPE["body"], 600).view)
self.dragging_box = widgets.Switch("Don't cross while dragging with this Mac's pointer", on_change=self._changed)
- self.dragging_box.view.setToolTip_("Applies when this physical pointer pushes through this screen's ways; visiting pointers are not protected by this switch.")
module.add(self.dragging_box.view)
- self.jump_box = widgets.stack(spacing=8)
- self.jump_heading = widgets.eyebrow("Jump to this machine")
- widgets.add(self.jump_box, self.jump_heading)
- self.jump_recorder = widgets.JumpKeyRecorder(on_change=self._record_jump_key, on_arm=self._jump_arming)
- jump_controls = widgets.stack(vertical=False, spacing=8)
- jump_controls.addArrangedSubview_(self.jump_recorder.view)
- self.jump_clear = widgets.Button("Clear", self, "clearJumpKey:", scale="small")
- jump_controls.addArrangedSubview_(self.jump_clear.view)
- widgets.add(self.jump_box, jump_controls)
- self.jump_note = widgets.note()
- widgets.add(self.jump_box, self.jump_note.view)
- module.add(self.jump_box)
- module.body.setCustomSpacing_afterView_(18, self.dragging_box.view)
+ module.add(widgets.note("Applies when this physical pointer pushes through this screen's ways; visiting pointers are not protected by this switch.").view)
return module
-
@objc.python_method
def _show_jump_key(self):
- peers = self.settings_store.current()["peers"]
- entry = next((peer for peer in peers if peer.get("id") == self.chosen_peer), None)
- self.jump_box.setHidden_(entry is None)
- if entry is None:
- self.jump_recorder.cancel()
- return
- self.jump_recorder.set_value(entry.get("jump_key", ""))
- name = self._shown(peerlist.label_for(peers, peer_id=self.chosen_peer) or "this machine")
- self.jump_heading.setStringValue_(f"Jump to {name}")
- self.jump_recorder.view.setAccessibilityLabel_(f"Jump to {name} key, {self.jump_recorder._title()}")
- chord = self.jump_recorder._title()
- if entry.get("jump_key"):
- self.jump_note.set(f"Press {chord} to send input to {name}; press again to bring it home.")
- else:
- self.jump_note.set(f"Choose a key combination to jump to {name} and back.")
- self.jump_note.view.setToolTip_(f"Works while edges are held. Needs In use, This Mac drives it and permission from {name} to drive it.")
- self.jump_clear.view.setAccessibilityLabel_(f"Clear jump key for {name}")
-
+ self._show_machines()
@objc.python_method
def _jump_arming(self, armed):
self.controller.jump_recording = armed
@@ -2773,44 +3198,90 @@ class ControlWindow(AppKit.NSObject):
self._save_jump_key(value)
@objc.python_method
- def _save_jump_key(self, value):
+ def _save_jump_key(self, value, peer=None):
+ peer = peer or self.chosen_peer
try:
- self.settings_store.set_jump_key(self.chosen_peer, value, self.controller.cfg.trigger_key)
+ self.settings_store.set_jump_key(peer, value, self.controller.cfg.trigger_key)
+ self.controller.cfg = self.settings_store.load()
except SettingsError as exc:
- peer = next((peer for peer in self.settings_store.current()["peers"] if peer.get("id") == self.chosen_peer), None)
- if peer is not None:
- self.jump_recorder.set_value(peer.get("jump_key", ""))
- self.jump_note.set(str(exc), ink="amber")
- return
- self._show_jump_key()
-
+ self._say(str(exc), "amber")
+ self._show_machines()
def clearJumpKey_(self, _sender):
self._save_jump_key("")
@objc.python_method
def _way_toggled(self, way, on):
- methods = pages.toggle_way([name for name, tile in self.method_boxes.items() if tile.value], way, on)
- for name, tile in self.method_boxes.items():
- tile.value = name in methods
- self._changed()
+ if way == "shortcut":
+ self.method_boxes["shortcut"].value = on
+ self._changed()
@objc.python_method
- def _part_toggled(self, part, on):
- # The tile has already flipped itself; the last-third rule needs the thirds from before.
- before = [name for name, tile in self.part_boxes.items() if (not on if name == part else tile.value)]
- parts = pages.toggle_part(before, part, on)
- for name, tile in self.part_boxes.items():
- tile.value = name in parts
- self._changed()
+ def _ledger_edge(self, peer, part=None):
+ settings = self.settings_store.current()
+ entry = next((item for item in settings["peers"] if item["id"] == peer), None)
+ held = core_ways.ways(settings, peer)
+ own = settings.get("machine_id")
+ tiles = core_ways.derive_layout(settings, gap=0)
+ contact = core_ways._rect_contact(tiles[own], tiles[peer]) if own in tiles and peer in tiles else None
+ if (entry is None or entry.get("left_out") or entry.get("in_use", True) is False
+ or not contact or contact[0] == "corner"):
+ return
+ methods, parts = (core_ways.toggle_third(held["methods"], held["parts"], part) if part
+ else core_ways.toggle_edge(held["methods"], held["parts"]))
+ self._write_ways(peer, edge=bool(set(methods) & {"edge", "part"}), thirds=parts)
+ self._load_ways()
+ self._reflect()
@objc.python_method
+ def _ledger_corner(self, peer, corner):
+ settings = self.settings_store.current()
+ entry = next((item for item in settings["peers"] if item["id"] == peer), None)
+ if (entry is None or entry.get("left_out") or entry.get("in_use", True) is False
+ or core_ways.corner_holder(settings, corner, exclude=peer)):
+ return
+ held = core_ways.ways(settings, peer)
+ enabled = not ("corner" in held["methods"] and held["corner"] == corner)
+ self._write_ways(peer, corner=enabled, corner_at=corner)
+ self._load_ways()
+ self._reflect()
+
+ @objc.python_method
+ def _ledger_notch(self, peer, enabled):
+ entry = next((item for item in self.settings_store.current()["peers"] if item["id"] == peer), None)
+ if (self.has_notch and entry and not entry.get("left_out")
+ and entry.get("in_use", True) is not False):
+ self._write_ways(peer, notch=enabled)
+ self._reflect()
+ @objc.python_method
+ def _atlas_third(self, peer, part):
+ self._ledger_edge(peer, part)
+ @objc.python_method
+ def _third_toggled(self, part):
+ if self.chosen_peer:
+ self._ledger_edge(self.chosen_peer, part)
+ @objc.python_method
def _shortcut_module(self):
module = widgets.Module()
module.add(widgets.eyebrow("Shortcut"))
+ self.method_boxes = {"shortcut": widgets.WayTile("Shortcut", on_change=lambda on: self._way_toggled("shortcut", on))}
+ module.add(self.method_boxes["shortcut"].view)
self.key_recorder = widgets.KeyRecorder("alt_r", on_change=self._trigger_chosen)
module.add(self.key_recorder.view)
self.style_select = widgets.Segmented([("double_tap", "Double-tap"), ("hold", "Hold")], on_change=self._changed)
module.add(widgets.field_row("How you press it", self.style_select.view)[0])
+ self.shortcut_goes_to = widgets.Segmented(
+ [("last", "Last machine"), ("next", "Next in order"), ("ticked", "Next among ticked")],
+ columns=3, on_change=self._shortcut_destination_changed,
+ )
+ self.shortcut_goes_to.cap = max(widgets.attributed(title, theme.TYPE["small"]).size().width + 24
+ for _value, title in self.shortcut_goes_to.choices) * 3
+ self.shortcut_goes_to.cap_constraint.setConstant_(self.shortcut_goes_to.cap)
+ self.shortcut_goes_to.preference.setConstant_(self.shortcut_goes_to.cap)
+ for _value, _cell, words in self.shortcut_goes_to.cells:
+ words.view.setUsesSingleLineMode_(True)
+ module.add(widgets.field_row("Shortcut goes to", self.shortcut_goes_to.view)[0])
+ self.shortcut_cycle_note = widgets.note()
+ module.add(self.shortcut_cycle_note.view)
# The figure sits on the ruler's own line, so it reads as the ruler's value rather than as
# a heading for the whole module, and the two hide together under Hold.
self.double_tap_head = widgets.stack(spacing=6)
@@ -2829,6 +3300,26 @@ class ControlWindow(AppKit.NSObject):
module.add(self.style_hint.view)
return module
+ @objc.python_method
+ def _shortcut_destination_changed(self, *_ignored):
+ self._show_shortcut_destination_note()
+ self._changed()
+
+ @objc.python_method
+ def _show_shortcut_destination_note(self):
+ if not hasattr(self, "shortcut_cycle_note"):
+ return
+ mode = self.shortcut_goes_to.value or "last"
+ if mode == "last":
+ note = "With Hold, input goes to the last machine."
+ elif self.style_select.value == "hold":
+ note = "With Hold, input goes to the first ready machine in order."
+ else:
+ note = "The order follows the tiles from top to bottom, then left to right. This Mac is always in the cycle."
+ if mode == "ticked":
+ note += " Choose which machines join the cycle with the tick boxes on their tiles."
+ self.shortcut_cycle_note.set(note)
+
@objc.python_method
def _show_trigger_conflict(self, note):
self._trigger_conflict = note
@@ -2941,6 +3432,11 @@ class ControlWindow(AppKit.NSObject):
def _preview_tile(self, base, value, title, detail, notch, flexible=False, **overrides):
"""One tile's preview: its own screen, a feed pinned to the style the tile shows, and the
real renderer hosted on it, registered with the page's loop."""
+ if notch is not None:
+ colour = lambda: (self.glow_colour_select.value if hasattr(self, "glow_colour_select") else None) or "signal"
+ view = previews.notch_crossing_still(base, colour, self.logger, self.controller, notch)
+ self.effect_stills.append(view)
+ return value, title, detail, view
screen = previews.PreviewScreen.alloc().init().setup(notch)
if flexible:
screen.widthAnchor().constraintEqualToAnchor_multiplier_(screen.heightAnchor(), 2.0).setActive_(True)
@@ -3041,8 +3537,9 @@ class ControlWindow(AppKit.NSObject):
self.notch_row = self._notch_row()
colour = lambda: self.glow_colour_select.value or "signal"
place = lambda: self.place
- pace = lambda: effects.pace(self.length_select.value)
+ pace = lambda: self.length_select.numeric_value()
effect_size = lambda: self.size_select.value or "medium"
+ size_fraction = lambda: self.size_select.numeric_value()
# The two sets of tiles, one per mode; only the chosen mode's shows.
self.crossing_styles_box = widgets.stack(spacing=0)
tile_sets = widgets.stack(spacing=6)
@@ -3051,7 +3548,8 @@ class ControlWindow(AppKit.NSObject):
for group, choices in pages.style_groups(self.effects_ready):
# Glow and Beam as stills of the same scene as the effects, so every tile reads alike.
tiles = [(value, title, detail, previews.effect_still(value, colour, self.logger, place=place,
- pace=pace, effect_size=effect_size))
+ pace=pace, effect_size=effect_size,
+ effect_size_fraction=size_fraction))
for value, title, detail in choices]
self.effect_stills.extend(tile[3] for tile in tiles)
if group == pages.TODAY:
@@ -3077,7 +3575,8 @@ class ControlWindow(AppKit.NSObject):
for value, title, detail in choices:
fx = lambda value=value: effects.switch_effect(value, self.glow_style_select.value or "glow")
tiles.append((value, title, detail, previews.switch_still(
- fx, colour, self.logger, pace=pace, effect_size=effect_size)))
+ fx, colour, self.logger, pace=pace, effect_size=effect_size,
+ effect_size_fraction=size_fraction)))
self.effect_stills.extend(tile[3] for tile in tiles)
rows.append(self._style_group(self.switch_styles_box, group, tiles))
self._style_grid(self.switch_styles_box)
@@ -3095,15 +3594,26 @@ class ControlWindow(AppKit.NSObject):
module.add(self.chosen_box)
module.body.setCustomSpacing_afterView_(12, self.chosen_box)
# Every style and every switch plays at this length, so it follows the tiles either way.
- self.length_select = widgets.Segmented(effects.LENGTHS, on_change=self._changed)
- self.size_select = widgets.Segmented(effects.SIZES, on_change=self._changed)
- self.length_row = widgets.field_row("Length", self.length_select.view)[0]
- self.size_row = widgets.field_row("Size", self.size_select.view)[0]
+ self.length_select = _DesignSliderChoice("Length", 25, 250, 5, 100, (0.5, 1.0, 2.0),
+ effects.LENGTHS, self._design_slider_changed,
+ "Sets the effect's playback time.")
+ self.size_select = _DesignSliderChoice("Size", 20, 80, 1, 1000, (0.03, 0.045, 0.06),
+ effects.SIZES, self._design_slider_changed,
+ "Sets effect depth relative to the shorter screen edge.")
+ self.length_readout = design_readout()
+ self.size_readout = design_readout()
+ length_control = widgets.stack(False, spacing=10)
+ widgets.add(length_control, self.length_select.view)
+ widgets.add(length_control, self.length_readout.view, full_width=False)
+ size_control = widgets.stack(False, spacing=10)
+ widgets.add(size_control, self.size_select.view)
+ widgets.add(size_control, self.size_readout.view, full_width=False)
+ self.length_row = widgets.field_row("Length", length_control)[0]
+ self.size_row = widgets.field_row("Size", size_control)[0]
module.add(self.length_row)
+ module.add(widgets.note("Sets the effect's playback time.", ink="ink_2").view)
module.add(self.size_row)
- module.add(widgets.note(
- "Length changes effect playback time, not crossing resistance or key timing. Size changes depth for styles that support it; it does not change resistance."
- ).view)
+ module.add(widgets.note("Sets effect depth relative to the shorter screen edge.", ink="ink_2").view)
module.add(self.place_note.view)
module.add(self.notch_row)
return module
@@ -3131,7 +3641,7 @@ class ControlWindow(AppKit.NSObject):
group_box.setAlignment_(AppKit.NSLayoutAttributeWidth)
heading = widgets.label(group, theme.TYPE["note"], 600, ink="ink_2")
widgets.add(group_box, heading)
- row = widgets.ChoiceTiles(tiles, vertical=True, responsive=True)
+ row = widgets.ChoiceTiles(tiles, vertical=True, responsive=True, keep_columns=True)
widgets.add(group_box, row.view)
self._hover(row)
widgets.add(box, group_box)
@@ -3255,6 +3765,11 @@ class ControlWindow(AppKit.NSObject):
module, "Input Monitoring", "Lets Beamer read this keyboard and trackpad, to send them to another machine.",
"requestInputMonitoring:",
)
+ module.add(widgets.hairline())
+ module.add(widgets.eyebrow("At login"))
+ module.add(widgets.note(
+ "On Overview, turn on Start Beamer when you log in. If macOS needs approval, that page shows the status and opens Login Items settings."
+ ).view)
self.capture_status = widgets.note()
module.add(self.capture_status.view)
self.relaunch_button = widgets.Button("Relaunch Beamer", self, "relaunch:", style="primary", full_width=True)
@@ -3279,37 +3794,25 @@ class ControlWindow(AppKit.NSObject):
@objc.python_method
def _ways_in_sentence(self):
- # Read from the controls, not the saved config, which lands a moment after a change: the
- # sentence and the drawing's description would otherwise be one change behind.
- key = widgets.key_title(self.key_recorder.value)
- methods = {name for name, tile in self.method_boxes.items() if tile.value}
- edge = self.edge_select.value
- if not edge:
- # A machine not placed yet: its edge and thirds lead nowhere until a side is chosen.
- methods -= {"edge", "part"}
- parts = []
+ held = self._selected_ways()
+ methods = set(self._methods())
+ edge = held["side"]
+ words = []
if "shortcut" in methods:
- parts.append(f"{'Hold' if self.style_select.value == 'hold' else 'Double-tap'} {key}")
- ways = []
- if "edge" in methods:
- ways.append(f"the {edge} edge")
- elif "part" in methods:
- ways.append(pages.parts_phrase(edge, [name for name, tile in self.part_boxes.items() if tile.value]))
+ words.append(f"{'Hold' if self.style_select.value == 'hold' else 'Double-tap'} {widgets.key_title(self.key_recorder.value)}")
+ pushes = []
+ if edge and "edge" in methods:
+ pushes.append(f"the {edge} edge")
+ elif edge and "part" in methods:
+ pushes.append(pages.parts_phrase(edge, held["parts"]))
if "corner" in methods:
- ways.append(f"the {(self.corner_select.value or 'top_right').replace('_', ' ')} corner")
+ pushes.append(f"the {held['corner'].replace('_', ' ')} corner")
if "notch" in methods:
- ways.append("the notch")
- if ways:
- joined = ways[0] if len(ways) == 1 else ", ".join(ways[:-1]) + " or " + ways[-1]
- # With several machines the pointer's ways lead to the chosen one; the shortcut goes
- # wherever input last was, so it is not said to.
- several = len(self.settings_store.current()["peers"]) > 1
- parts.append(f"push through {joined}" + (f" to reach {self._chosen_label()}" if several else ""))
- if not parts:
- return ""
- sentence = ", or ".join(parts)
- return sentence[0].upper() + sentence[1:]
-
+ pushes.append("the notch")
+ if pushes:
+ words.append("push through " + " or ".join(pushes))
+ sentence = ", or ".join(words)
+ return sentence[:1].upper() + sentence[1:]
@objc.python_method
def _commit(self):
bar = widgets.box("ground")
@@ -3329,6 +3832,8 @@ class ControlWindow(AppKit.NSObject):
@objc.python_method
def show(self):
+ if self.activation_policy_handler is not None:
+ self.activation_policy_handler(window_open=True)
self._select_page(pages.opening_page(
self.page if self.opened else None, accessibility_granted(), input_monitoring_granted()
))
@@ -3407,12 +3912,14 @@ class ControlWindow(AppKit.NSObject):
raw["appearance"] = self.appearance_select.value or "system"
if self.modifier_select.value in config_module.KEY_MAP_STYLES:
raw["key_map"] = self.modifier_select.value
+ methods = [name for name in raw["crossing"]["methods"] if name != "shortcut"]
+ if self.method_boxes["shortcut"].value:
+ methods.append("shortcut")
raw["crossing"] = {
- "methods": [name for name, tile in self.method_boxes.items() if tile.value],
- "edge_parts": [name for name, tile in self.part_boxes.items() if tile.value] or ["middle"],
- # Read only while nothing is paired; a machine's side and zones go through set_ways.
- "edge": self.edge_select.value or self.controller.cfg.crossing["edge"],
- "corner": self.corner_select.value,
+ "methods": methods,
+ "edge_parts": raw["crossing"]["edge_parts"],
+ "edge": raw["crossing"]["edge"],
+ "corner": raw["crossing"]["corner"],
"resistance_px": self.resistance_ruler.value,
"haptics": self.haptics_box.value,
"glow": self.glow_box.value,
@@ -3427,21 +3934,32 @@ class ControlWindow(AppKit.NSObject):
"glow_colour": self.glow_colour_select.value,
"effect_length": self.length_select.value or "normal",
"effect_size": self.size_select.value or "medium",
+ "effect_pace": self.length_select.numeric_value(),
+ "effect_size_fraction": self.size_select.numeric_value(),
"block_while_dragging": self.dragging_box.value,
+ "shortcut_goes_to": self.shortcut_goes_to.value or "last",
"hold_full_screen": self.hold_box.value,
"arrangement_set_at": self.controller.cfg.crossing.get("arrangement_set_at", 0),
}
- before = settings_sync.mac_values(config_to_raw(self.controller.cfg))
+ cfg = self.controller.cfg
+ before = settings_sync.mac_values(config_to_raw(cfg))
after = settings_sync.mac_values(raw)
- shared = self.controller.cfg.same_on_both and settings_sync.changed(before, after)
+ # Each shared value a person changed here gets its own stamp, Same on or off, so the
+ # latest real choice is the one that wins when it is on.
+ held = settings_sync.held_stamps(cfg.same_stamps, cfg.same_set_at, cfg.same_by)
+ stamps, stamp = settings_sync.stamp_changes(held, before, after, self.own_id(),
+ floor=max(cfg.same_set_at, cfg.design_set_at))
+ shared = cfg.same_on_both and settings_sync.changed(before, after, cfg.same_groups)
+ # Stored before the outer stamp can move, so no unstamped value takes the new one.
+ if stamp is not None or shared:
+ raw["same_stamps"] = settings_sync.stored_stamps(stamps)
design_changed = any(before.get(key) != after.get(key) for key in settings_sync.DESIGN_KEYS)
if design_changed:
- raw["design_set_at"] = settings_sync.next_stamp(
- max(self.controller.cfg.design_set_at, self.controller.cfg.same_set_at), time.time())
+ raw["design_set_at"] = settings_sync.next_stamp(max(cfg.design_set_at, cfg.same_set_at), time.time())
raw["design_by"] = self.own_id()
if shared:
- raw["same_set_at"] = settings_sync.next_stamp(
- max(self.controller.cfg.same_set_at, raw.get("design_set_at", 0)), time.time())
+ raw["same_set_at"] = max(settings_sync.next_stamp(
+ max(cfg.same_set_at, raw.get("design_set_at", 0)), time.time()), stamp or 0)
raw["same_by"] = self.own_id()
cfg = self.settings_store.save(raw)
except (SettingsError, TypeError, ValueError) as exc:
@@ -3460,54 +3978,28 @@ class ControlWindow(AppKit.NSObject):
self._say("Saved. Changes apply as you make them.", "ink_2")
@objc.python_method
- def _write_ways(self):
- """The chosen machine's side and zones from the page's controls (core/ways.py), the engine
- built again from them, and every machine whose way back changed told, along with the chosen
- machine when its side or way changed. False, with the store's sentence said and the controls
- back at what is saved, when the store refuses them."""
- peer = self.chosen_peer
+ def _crossing_args(self):
+ return dict(platform="mac", capable=self.controller.crossing_capable(),
+ live=self._live, gone=self._gone, now=time.time())
+
+ @objc.python_method
+ def _write_ways(self, peer=None, **changes):
+ """Write an explicit ledger or map choice and apply its shared crossing outcome."""
+ if not changes:
+ return True
+ peer = peer or self.chosen_peer
current = self.settings_store.current()
if peer not in {entry["id"] for entry in current["peers"]}:
- # None chosen, or one removed while its change waited: nothing of its to write.
return True
- side = self.edge_select.value or ""
- methods = [name for name in core_ways.KIND_WORDS if self.method_boxes[name].value]
- parts = [name for name, tile in self.part_boxes.items() if tile.value] or ["middle"]
- offer = core_ways.share_offer(current, peer, self._live)
- occupied = {part for part, owner in offer["thirds"].items() if owner in offer["holders"]} if offer else set()
- if offer and side == offer["side"] and (
- "edge" in methods or "part" in methods and occupied.intersection(parts)):
- self._load_ways()
- self._reflect()
- self.window.makeFirstResponder_(self.share_button.view)
- return False
- before = core_ways.way_back_state(current)
- had_way = core_ways.has_way(current, peer)
try:
- moved = self.settings_store.set_ways(
- peer, side=side, corner=self.corner_select.value,
- methods=methods, parts=parts, live=self._live)
- cfg = self.settings_store.load()
- except SettingsError as exc:
+ self.controller.crossing_event(crossing_state.edit_ways, peer, **changes, **self._crossing_args())
+ except (SettingsError, OSError, KeyError, TypeError, ValueError) as exc:
self._say(str(exc), "fault")
self._load_ways()
self._reflect()
return False
- # Straight onto the controller rather than through apply_settings, which would send the
- # first machine's side a second time when that is the machine chosen.
- self.controller.cfg = cfg
- self.controller.zones_changed()
- if moved:
- # A side moved onto another machine's turns this machine's ways there off: show what was kept.
- self._load_ways()
- self._reflect()
- updated = self.settings_store.current()
- changed_peers = [target for target, state in core_ways.way_back_state(updated).items()
- if before.get(target) != state]
- if moved or core_ways.has_way(updated, peer) != had_way:
- changed_peers.append(peer)
- for target in dict.fromkeys(changed_peers):
- self._tell(target)
+ self._load_ways()
+ self._reflect()
return True
@objc.python_method
@@ -3523,37 +4015,19 @@ class ControlWindow(AppKit.NSObject):
@objc.python_method
def apply_arrangement(self, peer, edge, set_at, by, way_back=None, way_back_by=None):
- """A machine changed which of its edges faces this Mac (`edge` is its own). Applied here
- rather than at either link, because this is the side that owns the settings file; kept only
- when newer than the side held for that machine, a tie going to the larger `by` (WIRE.md
- section 8). A side that would put two machines' zones over one stretch turns that machine's
- clashing zones off, and says so. `way_back` is kept whatever the side; a message that changed
- anything here is answered with this Mac's own, so that machine learns at once whether a way
- leads back to it, and one that changed nothing is not, so two machines never answer in turn."""
- # A change still waiting out the pause is written first: the page reloads from the
- # settings below, which would otherwise drop it.
+ """Picture peers supply return status; old peers still settle a side by stamp."""
self._flush()
- before = core_ways.way_back_state(self.settings_store.current())
try:
- changed, notices = self.settings_store.arrangement(peer, edge, set_at, by, way_back, way_back_by,
- live=self._live)
- cfg = self.settings_store.load() if changed else None
+ outcome = self.controller.crossing_event(crossing_state.receive_arrangement, peer,
+ dict(edge=edge, set_at=set_at, by=protocol.read_id(by), way_back=way_back,
+ way_back_by=protocol.read_id(way_back_by)), **self._crossing_args())
except (SettingsError, TypeError, ValueError):
self.logger.exception("could not save the arrangement %s sent", peer)
return
- if not changed:
+ if not outcome["changed"]:
return
- self.controller.cfg = cfg
- self.controller.zones_changed()
- for notice in notices:
- self.controller._alert("Beamer", notice)
- self.logger.info("%s's arrangement: this Mac's %s edge", peer, crossing.OPPOSITE[edge])
- self._load(config_to_raw(cfg))
+ self._load(config_to_raw(self.controller.cfg))
self.refresh()
- changed_peers = [target for target, state in core_ways.way_back_state(self.settings_store.current()).items()
- if before.get(target) != state]
- for target in dict.fromkeys([*changed_peers, peer]):
- self._tell(target)
def quitApp_(self, _sender):
self.quit_handler()
@@ -3591,7 +4065,7 @@ class ControlWindow(AppKit.NSObject):
if not self.controller.redirecting and self.controller.can_wake:
self.controller.wake()
self._say(f"Waking {self._first_label()}. It connects on its own once it is up.", "ink_2")
- elif not self.controller.set_redirecting(not self.controller.redirecting):
+ elif not self.controller.set_redirecting(not self.controller.redirecting, reason="menu"):
self._say(self.controller.connection_status, "fault")
self.refresh()
@@ -3628,6 +4102,26 @@ class ControlWindow(AppKit.NSObject):
def _crossing_state_sentence(self):
return pages.crossing_state_sentence(*self._crossing_state_args())
+ @objc.python_method
+ def _current_chain_sentence(self):
+ controller = self.controller
+ identity = controller.identity()
+ own_id = protocol.id_text(identity["id"])
+ with controller._owner_lock:
+ route = controller.owner.chain
+ if len(route) <= 1:
+ driver = self.windows_input.server.owner if self.windows_input is not None else None
+ route = (protocol.id_text(driver), own_id) if driver is not None else ()
+ if not route:
+ return "Current chain: Idle"
+ entries = controller.book.peers()
+ labels = peerlist.labels(entries)
+ names_by_id = {entry.get("id"): labels.get(entry.get("token", ""), "another machine")
+ for entry in entries if entry.get("id")}
+ names = [identity["name"] if ident == own_id else names_by_id.get(ident, "another machine")
+ for ident in route]
+ return "Current chain: " + " → ".join(names)
+
@objc.python_method
def _permission(self, status, button, granted):
status.set("Granted" if granted else "Required", ink="signal" if granted else "amber")
@@ -3654,12 +4148,30 @@ class ControlWindow(AppKit.NSObject):
def refresh(self):
controller = self.controller
self._follow_first_peer()
- self._show_same()
access = accessibility_granted()
listening = input_monitoring_granted()
+ self.retry_capture(access, listening)
+ self._run_previews()
+ # Pairing has its own inputs and countdown; it must keep polling even while the
+ # rest of the window is unchanged. Copies detect link-thread and in-place edits.
+ self.panel.refresh()
+ state = link_state.describe(controller)
+ rows = self.panel.rows()
+ response = self._header_response_time()
+ key = (controller.cfg, self.settings_store.current(), state, rows, response,
+ access, listening, controller.input_ready, controller.input_error,
+ self.granted_at_launch, controller.redirecting, controller.waking,
+ controller.can_wake, controller.windows_locked, controller.round_trip_ms,
+ controller.notch_range, self._crossing_state_args(), self.chosen_peer,
+ self.wide, self._design_peer_caps(), self._design_states,
+ self._peer_too_old(), self.shortcut_goes_to.value,
+ frozenset(controller.crossing_capable()), controller.crossing_display_map())
+ if key == getattr(self, "_refresh_key", None) and not controller.redirecting:
+ return
+ self._refresh_key = copy.deepcopy(key)
+ self._show_same()
self._permission(self.access_status, self.access_button, access)
self._permission(self.input_status, self.input_button, listening)
- self.retry_capture(access, listening)
needs_relaunch = access and listening and not self.granted_at_launch
self.relaunch_button.view.setHidden_(not needs_relaunch)
if needs_relaunch:
@@ -3678,13 +4190,16 @@ class ControlWindow(AppKit.NSObject):
# Names arrive with each link's hello, and the pairings a zone needs with its `paired`.
self._show_machines()
- self._show_arrangement([name for name, tile in self.method_boxes.items() if tile.value])
- state = link_state.describe(controller)
- rows = self.panel.rows()
+ self._show_arrangement()
self._place_machines(not rows)
refused = any(row.state.key == "token" for row in rows)
- self.sidebar.set_link(replace(state, word=self._shown(state.word)), self._shown(self._machine_label()) if rows else "—")
- self.sidebar.set_dots(pages.dots(access, listening, "token" if refused else state.key))
+ response_peer, response_time, response_connected = response
+ self.sidebar.set_link(replace(state, word=self._shown(state.word)),
+ self._shown(response_peer if response_connected else self._machine_label()) if rows else "—",
+ response_time_ms=response_time, connected=response_connected)
+ dormant = any(peerlist.dormant_reason(entry) for entry in controller.book.peers())
+ dots = pages.dots(access, listening, "token" if refused else state.key, dormant)
+ self.sidebar.set_dots(dots)
self.link_led.set(state.led, state.blink)
self.link_tag.set(state.tag)
if (self._shown(state.word), state.tone) != (self.state_word.text, self.state_word.ink):
@@ -3750,7 +4265,6 @@ class ControlWindow(AppKit.NSObject):
if mac
else "Read from the network the first time this Mac connects; nothing to type."
)
- self.panel.refresh()
class StatusItemClick(AppKit.NSObject):
@@ -3782,8 +4296,7 @@ class StatusItemClick(AppKit.NSObject):
class _LaunchWatch(AppKit.NSObject):
- """A login item takes no arguments, so a login launch is recognised instead: macOS marks it
- as not the default launch, and that is the cue to stay in the menu bar."""
+ """Keeps non-default launches in the menu bar without opening a window."""
def initWithTray_(self, tray):
self = objc.super(_LaunchWatch, self).init()
@@ -3796,9 +4309,10 @@ class _LaunchWatch(AppKit.NSObject):
def launched_(self, note):
self.tray.notices.ask()
info = note.userInfo() or {}
- default = info.get("NSApplicationLaunchIsDefaultLaunchKey")
- if default is not None and not bool(default):
+ default_launch = info.get("NSApplicationLaunchIsDefaultLaunchKey")
+ if login_item.is_background_launch(default_launch):
self.tray.hidden = True
+ self.tray.apply_activation_policy(window_open=False)
def _tray_item(title, **kwargs):
@@ -3813,17 +4327,22 @@ class TrayApp(rumps.App):
def __init__(self, controller, settings_store, logger, hidden=False):
self.hidden = hidden
self.notices = notices.Notices(logger)
+ self._last_refusal = ""
+ self._refusal_notices = peerlist.RefusalThrottle()
self.launch_watch = _LaunchWatch.alloc().initWithTray_(self)
self.controller = controller
self.settings_store = settings_store
self.logger = logger
+ self.apply_activation_policy(window_open=False)
# Before anything reads or posts a key: the table follows this Mac's layout from here on.
self.layout_observer = keyboard_layout.watch()
self.control_window = ControlWindow.alloc().initWithController_settingsStore_logger_(
controller, settings_store, logger
)
+ self.control_window.activation_policy_handler = self.apply_activation_policy
self.control_window.quit_handler = self.quit_app
self.control_window.direction_handler = self._set_direction
+ self.control_window.left_out_handler = self._set_left_out
install_main_menu(self.control_window)
self.gesture_overlay = GestureOverlay(controller, logger)
self.edge_glow = EdgeGlow(controller, logger)
@@ -3831,6 +4350,7 @@ class TrayApp(rumps.App):
self.notch_beam = NotchBeam(controller, logger)
self.effects_overlay = effects_overlay.EffectsOverlay(controller, logger)
self.haptics = Haptics(logger)
+ self._resistance_pressure_timer = None
self.control_window.preview = self.edge_glow.preview
self.control_window.haptics = self.haptics
self.controller.on_user_alert = self.notify_user
@@ -3875,7 +4395,7 @@ class TrayApp(rumps.App):
self._notch_failed = False
self.header_item = header = _tray_item(f"Beamer {VERSION}", callback=None)
self.update_url = None
- self.status_item = _tray_item("Starting", callback=None)
+ self.status_item = _tray_item(self._drive_status(), callback=None)
self.toggle_item = _tray_item(TOGGLE_ITEM, callback=self.toggle_redirect)
# With several machines to send to, one item each after the one above, keyed by machine id.
self._send_keys = []
@@ -3888,9 +4408,10 @@ class TrayApp(rumps.App):
"Beamer",
title="Beamer • Local",
menu=[
+ self.status_item,
+ rumps.separator,
header,
rumps.separator,
- self.status_item,
self.toggle_item,
self.pause_item,
rumps.separator,
@@ -3953,6 +4474,8 @@ class TrayApp(rumps.App):
self.split_clicks()
if not self.hidden:
self.control_window.show()
+ else:
+ self.apply_activation_policy(window_open=False)
def split_clicks(self):
"""Runs once the status item exists, which is after rumps has started the app."""
@@ -3988,7 +4511,7 @@ class TrayApp(rumps.App):
_set_tray_title(self.pause_item, "Resume crossing" if controller.crossing_paused else "Pause crossing")
self._machine_items()
self._direction_items()
- _set_tray_title(self.status_item, pages.redact(link_state.describe(controller).word, hide))
+ self._refresh_tray_state()
def _machine_items(self):
"""With more than one machine to send to, Send input to each of them in place of the one
@@ -4020,7 +4543,7 @@ class TrayApp(rumps.App):
if controller.redirecting and controller.owner.on == peer:
controller.set_redirecting(False)
else:
- controller.set_redirecting(True, peer=peer)
+ controller.set_redirecting(True, peer=peer, reason="menu")
self.refresh_status(None)
def _direction_items(self):
@@ -4072,6 +4595,16 @@ class TrayApp(rumps.App):
def open_window(self, _sender):
self.control_window.show()
+ def apply_activation_policy(self, window_open=None):
+ if window_open is None:
+ window_open = self.control_window.window.isVisible()
+ show_in_dock = self.settings_store.current().get("show_in_dock", True)
+ policy = dock_visibility.activation_policy(show_in_dock, window_open)
+ AppKit.NSApp.setActivationPolicy_(
+ AppKit.NSApplicationActivationPolicyRegular
+ if policy == "regular" else AppKit.NSApplicationActivationPolicyAccessory
+ )
+
def toggle_send_to_windows(self, _sender):
"""The menu's tick covers every machine: all on turns them all off, anything else all on."""
peers = peerlist.desktops(self.controller.book.peers())
@@ -4085,6 +4618,26 @@ class TrayApp(rumps.App):
"""One machine's switch from its row on Overview."""
self._switch([token], **change)
+ def _set_left_out(self, token, enabled):
+ """Changes one desktop peer's local layout state and tells peers whose way back changed."""
+ store = self.settings_store
+ try:
+ with store.lock:
+ settings = copy.deepcopy(store.current())
+ entry = next((item for item in settings["peers"] if item.get("token") == token), None)
+ if entry is None or entry.get("port") == 0:
+ return
+ self.controller.crossing_event(
+ crossing_state.leave_out if enabled else crossing_state.put_back,
+ entry["id"], **self.control_window._crossing_args())
+ except (SettingsError, OSError, KeyError) as exc:
+ self.logger.warning("layout state not saved: %s", exc)
+ self.notify_user("Beamer", f"Could not save the change: {exc}")
+ self.control_window.panel.invalidate()
+ self.control_window.peers_changed()
+ return
+ self.control_window.peers_changed()
+
def _switch(self, tokens, **change):
controller = self.controller
entries = []
@@ -4107,7 +4660,8 @@ class TrayApp(rumps.App):
controller.set_redirecting(False)
self.control_window.peers_changed()
self.logger.info("directions: %s", ", ".join(
- f"{entry.get('name')} send {'on' if entry['send'] else 'off'} drive {'on' if entry['allow_drive'] else 'off'}"
+ f"{peerlist.label_for(self.controller.book.peers(), token=entry.get('token')) or 'Machine'} "
+ f"send {'on' if entry['send'] else 'off'} drive {'on' if entry['allow_drive'] else 'off'}"
for entry in entries))
self.refresh_status(None)
@@ -4166,6 +4720,13 @@ class TrayApp(rumps.App):
def _crossing_feedback_main(self, kind, step):
try:
+ if kind in ("pressure", "tick", "cross"):
+ update_strip = getattr(self, "_update_resistance_strip", None)
+ if update_strip is not None:
+ try:
+ update_strip(kind, step)
+ except Exception:
+ self.logger.exception("Resistance strip feedback failed")
if kind in ("home", "arrive"):
# Input is home: the gesture panel goes now, not on the next status tick up to 0.4 s
# later, when it would still sit over the landing animation and take the first click.
@@ -4202,6 +4763,39 @@ class TrayApp(rumps.App):
except Exception:
self.logger.exception("crossing feedback failed")
+ def _update_resistance_strip(self, kind, step):
+ control = getattr(self, "control_window", None)
+ strip = getattr(control, "push_strip", None)
+ if strip is None:
+ return
+ resistance = strip.value
+ edge = step.mac_edge or self.controller.cfg.crossing["edge"] or "right"
+ if kind == "cross":
+ if self._resistance_pressure_timer is not None:
+ self._resistance_pressure_timer.invalidate()
+ self._resistance_pressure_timer = None
+ strip.set_pressure(resistance, edge, crossed=True)
+ return
+ pressure = step.pressure * resistance
+ strip.set_pressure(pressure, edge)
+ if pressure > 0 and self._resistance_pressure_timer is None:
+ timer = AppKit.NSTimer.timerWithTimeInterval_target_selector_userInfo_repeats_(
+ 1 / 30, self, "refreshResistancePressure:", None, True
+ )
+ AppKit.NSRunLoop.mainRunLoop().addTimer_forMode_(timer, AppKit.NSRunLoopCommonModes)
+ self._resistance_pressure_timer = timer
+ elif pressure <= 0 and self._resistance_pressure_timer is not None:
+ self._resistance_pressure_timer.invalidate()
+ self._resistance_pressure_timer = None
+
+ def refreshResistancePressure_(self, _timer):
+ strip = self.control_window.push_strip
+ pressure = self.controller.crossing.pressure_at(time.monotonic()) * strip.value
+ strip.set_pressure(pressure)
+ if pressure <= 0 and self._resistance_pressure_timer is not None:
+ self._resistance_pressure_timer.invalidate()
+ self._resistance_pressure_timer = None
+
def _driven_pressure(self, edge, pressure, crossed, part=None):
"""The receiver's return edge while the PC drives this Mac, off its session thread: the push
home plays the departure effect. Today's glow never drew this direction."""
@@ -4258,6 +4852,14 @@ class TrayApp(rumps.App):
AppHelper.callAfter(self._notify_user_main, title, message)
def _notify_user_main(self, title, message):
+ if message.startswith("Can't cross to"):
+ self._last_refusal = message
+ refresh = getattr(self, "_refresh_tray_state", None)
+ if refresh is not None:
+ refresh()
+ throttle = getattr(self, "_refusal_notices", None)
+ if throttle is not None and not throttle.allow(message):
+ return
try:
AppKit.NSBeep()
except Exception:
@@ -4267,6 +4869,27 @@ class TrayApp(rumps.App):
except Exception:
self.logger.exception("failed to show a user notification")
+ def _drive_status(self):
+ if self.controller.redirecting:
+ return f"Driving {self.controller.on_label or 'another machine'}"
+ if self.controller.driver is not None:
+ return f"Driven by {self.controller.driver_label or 'another machine'}"
+ return "Idle"
+
+ def _refresh_tray_state(self):
+ state = self._drive_status()
+ previous = getattr(self, "_last_drive_status", None)
+ if previous is not None and previous != state:
+ self._last_refusal = ""
+ self._refusal_notices.reset()
+ self._last_drive_status = state
+ tooltip = f"{state}\n{self._last_refusal}" if self._last_refusal else state
+ if hasattr(self, "status_item"):
+ _set_tray_title(self.status_item, state)
+ item = getattr(self, "status_item_view", None)
+ if item is not None:
+ item.button().setToolTip_(pages.redact(tooltip, self.controller.cfg.hide_addresses))
+
def toggle_redirect(self, _sender):
self.control_window.toggleRedirect_(None)
@@ -4307,6 +4930,7 @@ def main(argv=None):
raise SystemExit("Beamer must run on macOS")
instance_lock = acquire_instance_lock()
if instance_lock is None:
+ request_running_instance(instance_socket_path())
return
AppKit.NSApplication.sharedApplication()
theme.init_fonts()
@@ -4327,11 +4951,18 @@ def main(argv=None):
book, identity = bridge.links_from_store(settings_store, VERSION)
controller = WakingController(cfg, logger=logger, book=book, identity=identity, hardware=hardware_mac.hardware_address_towards)
app = TrayApp(controller, settings_store, logger, hidden=args.hidden)
+ instance_server = InstanceSignalServer(
+ instance_socket_path(), lambda: AppHelper.callAfter(app.open_window, None)
+ )
+ instance_thread = threading.Thread(target=instance_server.serve_forever, daemon=True)
+ instance_thread.start()
awake = stay_awake() # noqa: F841 (held until Beamer quits)
controller.start()
try:
app.run()
finally:
+ instance_server.close()
+ instance_thread.join(timeout=1)
controller.stop()
instance_lock.close()
diff --git a/mac_app/ledger.py b/mac_app/ledger.py
new file mode 100644
index 0000000..95ac2f9
--- /dev/null
+++ b/mac_app/ledger.py
@@ -0,0 +1,504 @@
+"""The Crossing ledger: saved intent, with stable native controls for each paired desktop."""
+
+import AppKit
+import objc
+
+import theme
+import widgets
+from core import peerlist, ways
+
+
+class _ActionButton(AppKit.NSButton):
+ def acceptsFirstResponder(self):
+ return self.isEnabled()
+
+ def resetCursorRects(self):
+ self.addCursorRect_cursor_(self.bounds(), AppKit.NSCursor.pointingHandCursor()
+ if self.isEnabled() else AppKit.NSCursor.arrowCursor())
+
+
+class _CellView(AppKit.NSView):
+ def isFlipped(self):
+ return True
+
+ def hitTest_(self, point):
+ hit = objc.super(_CellView, self).hitTest_(point)
+ if hit is None:
+ # Glyph hit bands extend beyond the cell while their visible outline stays inside.
+ local = self.convertPoint_fromView_(point, self.superview())
+ for child in self.subviews():
+ if isinstance(child, Glyph):
+ hit = child.hitTest_(local)
+ if hit is not None:
+ return hit
+ return hit
+
+
+def quiet_button(title, callback):
+ target = widgets.callback_target(callback)
+ view = _ActionButton.alloc().initWithFrame_(((0, 0), (40, 24)))
+ view.setTitle_(title)
+ view.setTarget_(target)
+ view.setAction_("fire:")
+ view.setAccessibilityElement_(True)
+ view.setAccessibilityRole_(AppKit.NSAccessibilityButtonRole)
+ view.setBordered_(False)
+ view.cell().setLineBreakMode_(AppKit.NSLineBreakByTruncatingTail)
+ view.cell().setUsesSingleLineMode_(True)
+ view.cell().setWraps_(False)
+ view.setAttributedTitle_(widgets.attributed(title, 12.5, 500, "ink_2"))
+ view.setAccessibilityLabel_(title)
+ view._ledger_target = target
+ return view
+
+
+class Glyph(AppKit.NSView):
+ def isFlipped(self):
+ return True
+
+ @objc.python_method
+ def setup(self, row, kind):
+ self.row, self.kind = row, kind
+ self.hits = {}
+ self.setAccessibilityElement_(False)
+ keys = ways.PARTS if kind == "edge" else ways.CORNERS
+ for key in keys:
+ callback = (lambda key=key: row.control._ledger_edge(row.peer, key)) if kind == "edge" else (
+ lambda key=key: row.control._ledger_corner(row.peer, key))
+ button = quiet_button("", callback)
+ button.setTransparent_(True)
+ self.addSubview_(button)
+ self.hits[key] = button
+ return self
+
+ @objc.python_method
+ def refresh(self):
+ held, entry = self.row.held, self.row.entry
+ out = entry.get("left_out") is True or entry.get("in_use", True) is False
+ side = self.row.side or held["side"] or "top"
+ picked = ways.picked_thirds(held["methods"], held["parts"])
+ for index, (key, button) in enumerate(self.hits.items()):
+ if self.kind == "edge":
+ vertical = side in ("left", "right")
+ rect = ((-6 if side == "left" else 32, index * 26 / 3), (12, 26 / 3)) if vertical else (
+ (index * 38 / 3, -6 if side == "top" else 20), (38 / 3, 12))
+ name = ways.part_names(side)[key]
+ on = key in picked
+ label = f"{side.capitalize()} edge, {name.lower()} third, {'on' if on else 'off'}"
+ tooltip = f"{name} third: click to {'leave it out' if on else 'turn it on'}"
+ enabled = bool(self.row.side) and not out
+ else:
+ x = 4.5 if key.endswith("left") else 33.5
+ y = 4.5 if key.startswith("top") else 21.5
+ rect = ((x - 7, y - 7), (14, 14))
+ holder = ways.corner_holder(self.row.settings, key, exclude=self.row.peer)
+ on = "corner" in held["methods"] and held["corner"] == key
+ label = f"{key.replace('_', ' ').capitalize()} corner, {'on' if on else 'off'}"
+ tooltip = (peerlist.label_for(self.row.settings["peers"], peer_id=holder) + "'s corner") if holder else (
+ f"{key.replace('_', ' ').capitalize()} corner: click to " +
+ ("turn it off" if on else "move the corner here" if "corner" in held["methods"] else "turn it on"))
+ enabled = not holder and not out
+ (x, y), size = rect
+ button.setFrame_(((x+6, y+6), size))
+ button.setEnabled_(enabled)
+ button.setAccessibilityLabel_(label)
+ button.setAccessibilityValue_("on" if on else "off")
+ button.setToolTip_("Left out: Put back to change its ways" if out else tooltip)
+ self.setNeedsDisplay_(True)
+
+ def drawRect_(self, rect):
+ AppKit.NSGraphicsContext.saveGraphicsState()
+ transform = AppKit.NSAffineTransform.transform()
+ transform.translateXBy_yBy_(6, 6)
+ transform.concat()
+ outline = AppKit.NSBezierPath.bezierPathWithRoundedRect_xRadius_yRadius_(((0, 0), (38, 26)), 2.5, 2.5)
+ theme.colour("well").setFill()
+ outline.fill()
+ theme.colour("edge").setStroke()
+ outline.setLineWidth_(1)
+ outline.stroke()
+ held = self.row.held
+ if self.kind == "corner":
+ for corner in ways.CORNERS:
+ on = "corner" in held["methods"] and corner == held["corner"]
+ holder = ways.corner_holder(self.row.settings, corner, exclude=self.row.peer)
+ radius = 3.2 if on else 2
+ x = 4.5 if corner.endswith("left") else 33.5
+ y = 4.5 if corner.startswith("top") else 21.5
+ dot = AppKit.NSBezierPath.bezierPathWithOvalInRect_(((x-radius, y-radius), (radius*2, radius*2)))
+ colour = theme.colour("signal" if on or holder else "edge")
+ if holder:
+ colour = colour.colorWithAlphaComponent_(.45)
+ colour.setFill()
+ colour.setStroke()
+ dot.fill() if on else dot.stroke()
+ else:
+ side = self.row.side or held["side"] or "top"
+ picked = ways.picked_thirds(held["methods"], held["parts"]) if self.row.side else []
+ vertical = side in ("left", "right")
+ length = 26 if vertical else 38
+ for index, part in enumerate(ways.PARTS):
+ start, end = index*length/3+1, (index+1)*length/3-1
+ fixed = 0 if side in ("top", "left") else length
+ if vertical:
+ fixed = 0 if side == "left" else 38
+ else:
+ fixed = 0 if side == "top" else 26
+ path = AppKit.NSBezierPath.bezierPath()
+ path.moveToPoint_((fixed, start) if vertical else (start, fixed))
+ path.lineToPoint_((fixed, end) if vertical else (end, fixed))
+ on = part in picked
+ theme.colour("signal" if on else "edge").colorWithAlphaComponent_(1 if on else .7).setStroke()
+ path.setLineWidth_(3 if on else 1.5)
+ path.setLineCapStyle_(AppKit.NSRoundLineCapStyle)
+ path.stroke()
+ AppKit.NSGraphicsContext.restoreGraphicsState()
+
+
+class Row(AppKit.NSView):
+ def isFlipped(self):
+ return True
+
+ @objc.python_method
+ def setup(self, ledger, peer):
+ self.ledger, self.control, self.peer = ledger, ledger.control, peer
+ self.renaming = False
+ self.setAccessibilityElement_(True)
+ self.setAccessibilityRole_(AppKit.NSAccessibilityRowRole)
+ self.cells = {}
+ for key in ("machine", "edge", "corner", "notch", "keys"):
+ cell = _CellView.alloc().init()
+ self.addSubview_(cell)
+ self.cells[key] = cell
+ self.name = widgets.Label("", theme.TYPE["body"], 600)
+ self.status = widgets.Label("", theme.TYPE["small"], ink="ink_3")
+ self.rename = quiet_button("Rename", self.begin_rename)
+ self.leave = quiet_button("Leave out", lambda: self.control._set_atlas_left_out(
+ self.peer, not (self.entry.get("left_out") is True or self.entry.get("in_use", True) is False)))
+ self.name_field = AppKit.NSTextField.alloc().init()
+ self.name_field.setDelegate_(self.control)
+ self.name_field.setFont_(theme.font(theme.TYPE["body"]))
+ self.name_field.setHidden_(True)
+ self.rename_hint = widgets.Label("Return saves, Escape cancels", theme.TYPE["small"], ink="ink_3", wrap=True)
+ self.scope = widgets.Label("Only on this Mac", theme.TYPE["small"], ink="ink_3")
+ for item in (self.name.view, self.status.view, self.rename, self.leave, self.name_field,
+ self.rename_hint.view, self.scope.view):
+ self._add("machine", item)
+ self.edge_glyph = Glyph.alloc().init().setup(self, "edge")
+ self.corner_glyph = Glyph.alloc().init().setup(self, "corner")
+ self.edge_title = quiet_button("Off", lambda: self.control._ledger_edge(self.peer))
+ self.edge_detail = quiet_button("", lambda: self.control._ledger_edge(self.peer))
+ self.corner_title = widgets.Label("", 12.5)
+ self.corner_detail = widgets.Label("", 11, ink="ink_3")
+ for label in (self.corner_title, self.corner_detail):
+ label.view.cell().setLineBreakMode_(AppKit.NSLineBreakByTruncatingTail)
+ label.view.cell().setUsesSingleLineMode_(True)
+ label.view.cell().setWraps_(False)
+ for item in (self.edge_glyph, self.edge_title, self.edge_detail):
+ self._add("edge", item)
+ for item in (self.corner_glyph, self.corner_title.view, self.corner_detail.view):
+ self._add("corner", item)
+ self.notch = self._check(lambda on: self.control._ledger_notch(self.peer, on))
+ self.no_notch = widgets.Label("No notch", theme.TYPE["body"], ink="ink_3")
+ self.cycle = self._check(lambda on: self.control._set_shortcut_cycle(self.peer, on))
+ self._add("notch", self.notch)
+ self._add("notch", self.no_notch.view)
+ self._add("keys", self.cycle)
+ self.jump_caption = widgets.Label("Jump", theme.TYPE["small"], ink="ink_3")
+ self.jump = widgets.JumpKeyRecorder(on_change=lambda value: self.control._save_jump_key(value, self.peer),
+ on_arm=self._arm_jump, compact=True)
+ self.clear = quiet_button("Clear", lambda: self.control._save_jump_key("", self.peer))
+ for item in (self.jump_caption.view, self.jump.view, self.clear):
+ self._add("keys", item)
+ return self
+
+ @objc.python_method
+ def _add(self, cell, view):
+ view.setTranslatesAutoresizingMaskIntoConstraints_(True)
+ self.cells[cell].addSubview_(view)
+
+ @objc.python_method
+ def _check(self, callback):
+ target = widgets._Target.alloc().initWithCallback_(lambda sender: callback(sender.state() == AppKit.NSControlStateValueOn))
+ view = _ActionButton.alloc().initWithFrame_(((0, 0), (100, 28)))
+ view.setButtonType_(AppKit.NSSwitchButton)
+ view.setTarget_(target)
+ view.setAction_("fire:")
+ view.setTitle_("")
+ view.setFont_(theme.font(theme.TYPE["body"]))
+ view.setAccessibilityElement_(True)
+ view.setAccessibilityRole_(AppKit.NSAccessibilityCheckBoxRole)
+ view._ledger_target = target
+ return view
+
+ @objc.python_method
+ def _arm_jump(self, armed):
+ if armed:
+ for row in self.ledger.rows.values():
+ if row is not self:
+ row.jump.cancel()
+ self.control._jump_arming(any(row.jump.monitor is not None for row in self.ledger.rows.values()))
+ self.jump.hint.view.setHidden_(not armed)
+ self.ledger.reflow()
+
+ @objc.python_method
+ def begin_rename(self):
+ if self.control.page != "crossing":
+ self.control._select_page("crossing")
+ self.renaming = True
+ self.name_field.setStringValue_(self.entry.get("label") or self.entry.get("name") or "")
+ self.ledger.reflow()
+ self.control.window.makeFirstResponder_(self.name_field)
+ self.name_field.selectText_(None)
+
+ @objc.python_method
+ def finish_rename(self, save):
+ self.renaming = False
+ if save:
+ self.control._rename_peer(self.entry["token"], self.name_field.stringValue())
+ self.ledger.refresh(self.control.settings_store.current(), self.control.chosen_peer)
+ self.control.window.makeFirstResponder_(self.control.atlas_canvas)
+
+ @objc.python_method
+ def refresh(self, settings, entry, selected):
+ self.settings, self.entry, self.selected = settings, entry, selected
+ self.held = ways.ways(settings, self.peer)
+ tiles, own = ways.derive_layout(settings, gap=0), settings.get("machine_id")
+ contact = ways._rect_contact(tiles[own], tiles[self.peer]) if own in tiles and self.peer in tiles else None
+ self.side = contact[0] if contact and contact[0] != "corner" else ""
+ name = self.control._shown(peerlist.label_for(settings["peers"], peer_id=self.peer) or peerlist.UNNAMED)
+ linked = self.control._live(self.peer)
+ out = entry.get("left_out") is True or entry.get("in_use", True) is False
+ self.dimmed = out or not linked
+ platform = {"macos": "macOS", "windows": "Windows", "linux": "Linux"}.get(entry.get("platform"), "Machine")
+ caps = self.control._design_peer_caps()
+ status = "Left out" if out else "Linked" if linked else "Offline, ways kept"
+ self.status_text = f"{platform} · {status}"
+ self.old_peer = self.peer in caps and "layout" not in caps[self.peer]
+ if self.old_peer:
+ self.status_text = f"Beamer {entry.get('app') or '1.5.2'} · only sees which side"
+ self.name.set(name, ink="ink_2" if self.dimmed else "ink")
+ self.name.view.setToolTip_(name)
+ self.name.view.setLineBreakMode_(AppKit.NSLineBreakByTruncatingTail)
+ self.status.set(self.status_text)
+ self.leave.setAttributedTitle_(widgets.attributed("Put back" if out else "Leave out", 12.5, 500, "ink_2"))
+ self.leave.setAccessibilityLabel_("Put back" if out else "Leave out")
+ self.leave.setToolTip_("Left out machines stay paired and linked. The shortcut, menu and clipboard still reach them." if out else "Leave this machine out of pointer crossings")
+ picked = ways.picked_thirds(self.held["methods"], self.held["parts"]) if self.side else []
+ title = ways.edge_form_detail(self.side, self.held["methods"], self.held["parts"]) if picked else "Off"
+ detail = f"{self.side} edge" + (" off" if not picked else "") if self.side else "place it on the map"
+ self.edge_text = title
+ for button, text, size, ink in ((self.edge_title, title, 12.5, "ink" if picked else "ink_3"),
+ (self.edge_detail, detail, 11, "ink_3")):
+ button.setAttributedTitle_(widgets.attributed(text, size, ink=ink))
+ button.setAlignment_(AppKit.NSTextAlignmentLeft)
+ button.setAccessibilityLabel_("Edge, off" if not picked else
+ f"Edge, whole {self.side} edge" if len(picked) == 3 else
+ f"Edge, {title.lower()}, {self.side} edge")
+ button.setEnabled_(bool(self.side) and not out)
+ button.setToolTip_(text + ": " + ("Left out: Put back to change its ways" if out else
+ "Edge: click to turn it off" if picked else f"Edge: click for the whole {self.side} edge"))
+ corner_on = "corner" in self.held["methods"]
+ self.corner_title.set(self.held["corner"].replace("_", " ").capitalize() if corner_on else "None",
+ ink="ink" if corner_on else "ink_3")
+ self.corner_detail.set("diagonal push" if corner_on else "click a dot")
+ self.edge_glyph.refresh()
+ self.corner_glyph.refresh()
+ self.notch.setTitle_("" if not self.control.has_notch else
+ "On" if "notch" in self.held["methods"] else "Off")
+ self.no_notch.view.setHidden_(self.control.has_notch)
+ self.notch.setAccessibilityLabel_("Notch, no notch" if not self.control.has_notch else
+ "Notch, on" if "notch" in self.held["methods"] else "Notch, off")
+ self.notch.setState_(int("notch" in self.held["methods"]))
+ self.notch.setEnabled_(self.control.has_notch and not out)
+ self.notch.setToolTip_(f"Push into the notch to reach {name}")
+ self.cycle.setTitle_(widgets.key_title(self.control.key_recorder.value))
+ self.cycle.setState_(int(entry.get("shortcut_cycle") is not False))
+ self.cycle.setToolTip_("In the shortcut's cycle")
+ if self.jump.monitor is None:
+ self.jump.set_value(entry.get("jump_key", ""))
+ self.jump.hint.view.setHidden_(self.jump.monitor is None)
+ self.jump.view.setToolTip_(f"Press {self.jump._title()} to send input to {name}; press again to bring it home.")
+ self.clear.setHidden_(not bool(self.jump.value))
+ self.rename.setAccessibilityLabel_(f"Rename {name}")
+ self.leave.setAccessibilityLabel_(f"{'Put back' if out else 'Leave out'} {name}")
+ self.setAccessibilityLabel_(name)
+ self.setNeedsDisplay_(True)
+
+ def mouseDown_(self, event):
+ self.control._atlas_selected(self.peer)
+
+ def accessibilityRowHeaderUIElements(self):
+ return [self.name.view]
+
+ @objc.python_method
+ def arrange(self, width, narrow):
+ rename_space = 74 if self.renaming else 0
+ positions = self.ledger.columns(width)
+ if narrow:
+ half = (width-40)/2
+ positions = [(0, width), (12, half), (half+28, half), (12, half), (half+28, half)]
+ positions[0] = (12, positions[0][1] - 12)
+ for key, (x, w) in zip(self.cells, positions):
+ self.cells[key].setFrame_(((x, 12), (w, 72)))
+ self.cells[key].setAlphaValue_(.5 if self.dimmed else 1)
+ cell_heights = {"machine": 72 + rename_space, "notch": 28}
+ for kind, glyph, title, detail in (("edge", self.edge_glyph, self.edge_title, self.edge_detail),
+ ("corner", self.corner_glyph, self.corner_title.view, self.corner_detail.view)):
+ w = max(1, self.cells[kind].bounds().size.width - 48)
+ title_h, detail_h = 22, 20
+ # The glyph's six-point hit halo is outside its 38 × 26 visible outline.
+ glyph.setFrame_(((-6, -6), (50, 38)))
+ title.setFrame_(((48, 0), (w, title_h)))
+ detail.setFrame_(((48, title_h), (w, detail_h)))
+ cell_heights[kind] = max(38, title_h + detail_h)
+ w = self.cells["keys"].bounds().size.width
+ self.cycle.setFrame_(((0, 0), (w, 28)))
+ self.jump_caption.view.setFrame_(((0, 34), (35, 24)))
+ jump_w, jump_h = self.jump.arrange_compact(max(1, w-36))
+ self.jump.view.setFrame_(((36, 32), (jump_w, jump_h)))
+ clear_x, clear_y = 36 + jump_w + 4, 32
+ clear_w = 38
+ if clear_x + clear_w > w:
+ clear_x, clear_y = 36, 32 + jump_h + 2
+ self.clear.setFrame_(((clear_x, clear_y), (clear_w, 24)))
+ self.clear.setHidden_(not self.jump.value or self.jump.monitor is not None)
+ cell_heights["keys"] = max(60, 32 + jump_h,
+ clear_y + 24 if not self.clear.isHidden() else 0)
+ if narrow:
+ edge_y = 12 + cell_heights["machine"] + 12
+ edge_h = max(cell_heights["edge"], cell_heights["corner"])
+ keys_y = edge_y + edge_h + 12
+ bottom_h = max(cell_heights["notch"], cell_heights["keys"])
+ places = [(12, cell_heights["machine"]), (edge_y, edge_h), (edge_y, edge_h),
+ (keys_y, bottom_h), (keys_y, bottom_h)]
+ height = keys_y + bottom_h + 12
+ else:
+ height = max(76, max(cell_heights.values()) + 24)
+ places = [(12, height-24)] * 5
+ for key, (y, h) in zip(self.cells, places):
+ cell = self.cells[key]
+ cell.setFrame_(((cell.frame().origin.x, y), (cell.bounds().size.width, h)))
+ machine = self.cells["machine"].bounds().size.width
+ self.name.view.setFrame_(((0, 0), (machine, 22)))
+ self.status.view.setFrame_(((12, 25), (machine-12, 19)))
+ self.rename.setFrame_(((0, 48), (54, 24)))
+ self.leave.setFrame_(((56, 48), (min(74, machine-56), 24)))
+ self.name_field.setFrame_(((0, 0), (machine, 24)))
+ self.name_field.setHidden_(not self.renaming)
+ self.name.view.setHidden_(self.renaming)
+ for label, y in ((self.rename_hint, 74), (self.scope, 110)):
+ label.view.setFrame_(((0, y), (machine, 32)))
+ label.view.setHidden_(not self.renaming or label is self.scope and self.control.controller.cfg.same_on_both)
+ w = self.cells["notch"].bounds().size.width
+ self.notch.setFrame_(((0, 0), (w if self.control.has_notch else 22, 28)))
+ self.no_notch.view.setFrame_(((0, 32), (w, 22)))
+ return height
+
+ def drawRect_(self, rect):
+ width = self.bounds().size.width
+ theme.colour("rule").setFill()
+ AppKit.NSRectFill(((0, 0), (width, 1)))
+ if self.selected:
+ theme.colour("signal").setFill()
+ AppKit.NSRectFill(((0, 12), (3, self.bounds().size.height-24)))
+ cell = self.cells["machine"].frame()
+ theme.colour("amber" if self.old_peer else "signal" if self.control._live(self.peer) else "ink_3").setFill()
+ AppKit.NSBezierPath.bezierPathWithOvalInRect_(((cell.origin.x+1, cell.origin.y+32), (6, 6))).fill()
+
+
+class Ledger(AppKit.NSView):
+ def isFlipped(self):
+ return True
+
+ @objc.python_method
+ def setup(self, control):
+ self.control, self.rows = control, {}
+ self.order = []
+ self.setTranslatesAutoresizingMaskIntoConstraints_(False)
+ self.height = self.heightAnchor().constraintEqualToConstant_(0)
+ self.height.setActive_(True)
+ self.setAccessibilityElement_(True)
+ self.setAccessibilityRole_(AppKit.NSAccessibilityTableRole)
+ self.setAccessibilityLabel_("Machines and crossing ways")
+ self.headers = []
+ for title in ("Machine", "Edge", "Corner", "Notch", "Keys"):
+ label = widgets.Label(title, theme.TYPE["eyebrow"], 700, "ink_3",
+ tracking=theme.TRACKING["eyebrow"], upper=True)
+ label.view.setTranslatesAutoresizingMaskIntoConstraints_(True)
+ label.view.setAccessibilityRole_(AppKit.NSAccessibilityColumnRole)
+ self.addSubview_(label.view)
+ self.headers.append(label)
+ return self
+
+ @objc.python_method
+ def columns(self, width):
+ weights = (1.3, 1, .9, 0, 1)
+ widths = [132, 124, 104, 56, 128]
+ remaining = max(488, width - 64 - 56)
+ flexible = {0, 1, 2, 4}
+ while flexible:
+ unit = remaining / sum(weights[index] for index in flexible)
+ fixed = {index for index in flexible if widths[index] > unit * weights[index]}
+ if not fixed:
+ for index in flexible:
+ widths[index] = unit * weights[index]
+ break
+ remaining -= sum(widths[index] for index in fixed)
+ flexible -= fixed
+ result, x = [], 0
+ for w in widths:
+ result.append((x, w))
+ x += w+16
+ return result
+
+ @objc.python_method
+ def refresh(self, settings, selected):
+ entries = peerlist.desktops(settings["peers"])
+ tiles = ways.derive_layout(settings, gap=0)
+ entries.sort(key=lambda entry: (entry["id"] not in tiles,
+ tiles.get(entry["id"], {}).get("x", 0), tiles.get(entry["id"], {}).get("y", 0)))
+ ids = [entry["id"] for entry in entries]
+ for peer in list(self.rows):
+ if peer not in ids:
+ self.rows[peer].jump.cancel()
+ self.rows.pop(peer).removeFromSuperview()
+ for entry in entries:
+ peer = entry["id"]
+ if peer not in self.rows:
+ row = Row.alloc().init().setup(self, peer)
+ self.rows[peer] = row
+ self.addSubview_(row)
+ self.rows[peer].refresh(settings, entry, peer == selected)
+ self.order = ids
+ self.reflow()
+
+ @objc.python_method
+ def reflow(self):
+ width = self.bounds().size.width
+ narrow = width < 620
+ y = 0 if narrow or not self.rows else 34
+ for label, (x, w) in zip(self.headers, self.columns(width)):
+ label.view.setHidden_(narrow or not self.rows)
+ label.view.setFrame_(((x, 0), (w, 24)))
+ for peer in self.order:
+ row = self.rows[peer]
+ h = row.arrange(width, narrow)
+ row.setFrame_(((0, y), (width, h)))
+ y += h
+ self.height.setConstant_(y)
+ self.setNeedsDisplay_(True)
+
+ def setFrameSize_(self, size):
+ objc.super(Ledger, self).setFrameSize_(size)
+ if hasattr(self, "rows"):
+ self.reflow()
+
+ def accessibilityRows(self):
+ return [self.rows[peer] for peer in self.order]
+
+ def accessibilityColumns(self):
+ return [header.view for header in self.headers]
+
+ def accessibilityColumnHeaderUIElements(self):
+ return [header.view for header in self.headers]
diff --git a/mac_app/login_item.py b/mac_app/login_item.py
index 6a402c3..0f1c204 100644
--- a/mac_app/login_item.py
+++ b/mac_app/login_item.py
@@ -5,6 +5,8 @@ ServiceManagement is loaded from the system framework rather than through
pyobjc-framework-ServiceManagement, which would be a new dependency for four calls.
"""
+from pathlib import Path
+
import objc
objc.loadBundle(
@@ -17,12 +19,38 @@ for _selector in (b"registerAndReturnError:", b"unregisterAndReturnError:"):
SMAppService = objc.lookUpClass("SMAppService")
NOT_REGISTERED, ENABLED, REQUIRES_APPROVAL, NOT_FOUND = 0, 1, 2, 3
+STATUS_TEXT = {
+ NOT_REGISTERED: "Not registered",
+ ENABLED: "Enabled",
+ REQUIRES_APPROVAL: "Requires approval",
+ NOT_FOUND: "Not found",
+}
def status():
return SMAppService.mainAppService().status()
+def status_text(value):
+ return STATUS_TEXT.get(value, "Unknown")
+
+
+def installed_in_applications(bundle_path):
+ path = Path(bundle_path).resolve()
+ if "/AppTranslocation/" in str(path):
+ return False
+ roots = (Path("/Applications"), Path.home() / "Applications")
+ return any(path == root or root in path.parents for root in roots)
+
+
+def can_toggle(status_value, bundle_path):
+ return installed_in_applications(bundle_path) or status_value in (ENABLED, REQUIRES_APPROVAL)
+
+
+def is_background_launch(is_default_launch):
+ return is_default_launch is not None and not bool(is_default_launch)
+
+
def is_enabled():
"""Waiting for approval in Login Items counts as on: the choice was made here."""
return status() in (ENABLED, REQUIRES_APPROVAL)
@@ -39,3 +67,7 @@ def set_enabled(enabled):
ok, error = service.unregisterAndReturnError_(None)
if not ok:
raise OSError(error.localizedDescription() if error is not None else "macOS refused")
+
+
+def open_system_settings():
+ SMAppService.openSystemSettingsLoginItems()
diff --git a/mac_app/machines.py b/mac_app/machines.py
index 3359b8e..33736c3 100644
--- a/mac_app/machines.py
+++ b/mac_app/machines.py
@@ -10,6 +10,7 @@ from __future__ import annotations
from dataclasses import dataclass
from core import protocol
+from core import peerlist
from link_state import AMBER, FAULT, INK, SIGNAL, LinkState
PLATFORMS = {"windows": "Windows", "macos": "Mac", "linux": "Linux", "ios": "iPhone", "android": "Android"}
@@ -25,6 +26,7 @@ class Row:
address: str
state: LinkState
in_use: bool
+ left_out: bool
drives: bool
driven: bool
phone: bool = False
@@ -44,11 +46,15 @@ def row(entry: dict, label: str, live: bool, kind: str, status: str, here: bool,
return Row(
entry["token"], label, platform_name(entry.get("platform", "")), address,
_state(entry, label, live, kind, status, here, driving, inbound, has_link), entry.get("in_use", True) is True,
+ entry.get("left_out") is True,
entry.get("send") is True, entry.get("allow_drive") is True, port == 0,
)
def _state(entry, label, live, kind, status, here, driving, inbound, has_link) -> LinkState:
+ reason = peerlist.dormant_reason(entry)
+ if reason:
+ return LinkState("dormant", AMBER, "Needs re-pair", "Needs re-pair", reason, AMBER)
if entry.get("in_use", True) is not True:
return LinkState("not_in_use", AMBER, "NOT IN USE", "NOT IN USE", f"{label} is not in use on this Mac.", AMBER)
if not protocol.linkable(entry):
diff --git a/mac_app/machines_panel.py b/mac_app/machines_panel.py
index 88e29f0..817c085 100644
--- a/mac_app/machines_panel.py
+++ b/mac_app/machines_panel.py
@@ -12,6 +12,7 @@ threads, so nothing here hops to the main thread from those.
"""
import re
+import socket
import threading
import AppKit
@@ -37,6 +38,17 @@ def seconds(count):
return f"Expires in {count} s"
+class _RenameDelegate(AppKit.NSObject):
+ def control_textView_doCommandBySelector_(self, control, _text_view, selector):
+ if selector == "insertNewline:":
+ self.panel._save_rename(self.token, control.stringValue())
+ return True
+ if selector == "cancelOperation:":
+ self.panel._cancel_rename(self.token)
+ return True
+ return False
+
+
class MachinesPanel:
def __init__(self, controller, settings_store, logger, owner):
self.controller = controller
@@ -53,6 +65,8 @@ class MachinesPanel:
self.wide = True
self._targets = []
self._rows_key = None
+ self._rename_views = {}
+ self._cycle_controls = {}
self.directions_open = set()
self._heard_key = None
self._heard = []
@@ -83,6 +97,32 @@ class MachinesPanel:
module.add(line)
return module
+ def own_name_module(self):
+ module = widgets.Module()
+ module.add(widgets.eyebrow("This Mac"))
+ line = widgets.stack(vertical=False, spacing=9)
+ own_name = self.settings_store.current().get("name", "")
+ name = widgets.Label(own_name or socket.gethostname().split(".")[0] or "Mac",
+ theme.TYPE["body"], 600)
+ widgets.squeeze(name.view)
+ line.addArrangedSubview_(name.view)
+ rename = self._chip("Rename", lambda: self._begin_rename(None), "Rename this Mac")
+ line.addArrangedSubview_(rename)
+ module.add(line)
+ box, edit = widgets.field(mono=False)
+ edit.setAccessibilityLabel_("Name for this Mac")
+ edit.setStringValue_(own_name)
+ box.setHidden_(True)
+ note = widgets.note("Only on this Mac", reading=False)
+ note.view.setHidden_(True)
+ delegate = _RenameDelegate.alloc().init()
+ delegate.panel, delegate.token = self, None
+ edit.setDelegate_(delegate)
+ module.add(box)
+ module.add(note.view)
+ self._own_rename_views = (name.view, rename, box, edit, note, delegate)
+ return module
+
def _sheet(self):
module = widgets.Module()
module.add(widgets.eyebrow("Pair a machine"))
@@ -213,9 +253,13 @@ class MachinesPanel:
# and a rebuild takes keyboard and VoiceOver focus off whatever it was on.
key = (hide, self.removing, self.wide, tuple(
(r.token, r.label, r.platform, r.address, r.state.key, r.state.word, r.state.tone, r.state.led,
- r.in_use, r.drives, r.driven)
+ r.state.detail if r.state.key == "dormant" else "",
+ r.in_use, r.left_out, r.drives, r.driven)
for r in rows))
key += (tuple(sorted(self.directions_open)),)
+ mode = getattr(getattr(self.owner, "shortcut_goes_to", None), "value", "last")
+ key += (mode, tuple((entry.get("token"), entry.get("shortcut_cycle") is not False)
+ for entry in self.controller.book.peers()))
if key != self._rows_key:
self._rows_key = key
self._build_rows(rows)
@@ -231,6 +275,7 @@ class MachinesPanel:
self._cancel_code()
def _build_rows(self, rows):
+ self._cycle_controls = {}
focus = self._focus_after or self._focused_control()
self._focus_after = None
for view in list(self.list.arrangedSubviews()):
@@ -272,22 +317,53 @@ class MachinesPanel:
head.addArrangedSubview_(led.view)
name = widgets.Label(label, theme.TYPE["body"], 600, wrap=True)
head.addArrangedSubview_(widgets.hug(widgets.squeeze(name.view), AppKit.NSLayoutPriorityDefaultLow))
- tag = widgets.Label(self._shown(state.word), theme.TYPE["eyebrow"], 700, state.tone, tracking=theme.TRACKING["eyebrow"], upper=True)
+ rename = self._chip("Rename", lambda t=row.token: self._begin_rename(t), f"Rename {label}")
+ head.addArrangedSubview_(rename)
+ tag = widgets.Label(self._shown(state.word), theme.TYPE["eyebrow"], 700, state.tone,
+ tracking=theme.TRACKING["eyebrow"], upper=state.key != "dormant")
if self.wide:
head.addArrangedSubview_(tag.view)
widgets.add(body, head)
if not self.wide:
widgets.add(body, tag.view)
remove = self._removal(row)
+ repair = (self._chip("Re-pair", lambda t=row.token: self.re_pair(t), f"Re-pair {label}")
+ if state.key == "dormant" else None)
where = row.platform if row.phone else " ".join((row.platform, self._shown(row.address)))
widgets.add(body, widgets.Label(where, theme.TYPE["small"], ink="ink_3", wrap=True).view)
+ if row.left_out:
+ widgets.add(body, widgets.note("Left out of the layout. The shortcut and the menu still reach it.").view)
widgets.add(body, widgets.note(self._shown(state.detail)).view)
+ entry = next((item for item in self.controller.book.peers() if item.get("token") == row.token), {})
+ if not row.phone and getattr(getattr(self.owner, "shortcut_goes_to", None), "value", "last") == "ticked":
+ cycle = widgets.Switch("In the shortcut's cycle",
+ on_change=lambda on, peer=entry.get("id"): self.owner._set_shortcut_cycle(peer, on))
+ cycle.value = entry.get("shortcut_cycle") is not False
+ cycle.set_enabled(row.in_use)
+ cycle.view.focus_id = (row.token, "shortcut_cycle")
+ self._cycle_controls[row.token] = cycle
+ widgets.add(body, cycle.view)
+ edit_box, edit = widgets.field(mono=False)
+ edit.setAccessibilityLabel_(f"Name for {label}")
+ edit.setStringValue_(entry.get("label", "") or entry.get("name", ""))
+ edit_box.setHidden_(True)
+ delegate = _RenameDelegate.alloc().init()
+ delegate.panel, delegate.token = self, row.token
+ edit.setDelegate_(delegate)
+ note = widgets.note("Only on this Mac", reading=False)
+ note.view.setHidden_(True)
+ self._rename_views[row.token] = (name.view, rename, edit_box, edit, note, delegate)
+ widgets.add(body, edit_box)
+ widgets.add(body, note.view)
in_use = widgets.Switch("In use", on_change=lambda on, t=row.token: self._direction(t, in_use=on))
in_use.value = row.in_use
in_use.view.setToolTip_(f"Off: no input or settings link to {label}. Pairing, directions, ways and jump key are kept. Turn it back on here to reconnect.")
if row.phone:
in_use.view.setToolTip_(f"Off: {label} cannot connect or drive this Mac. Turn it back on here to reconnect.")
in_use.view.focus_id = (row.token, "in_use")
+ left_out = self._chip("Put back" if row.left_out else "Leave out",
+ lambda out=not row.left_out, t=row.token: self._left_out(t, out),
+ f"{'Put back' if row.left_out else 'Leave out'} {label}", (row.token, "left_out"))
drives = widgets.Switch("This Mac drives it", on_change=lambda on, t=row.token: self._direction(t, send=on))
drives.value = row.drives
drives.view.setToolTip_(f"Input moves only when this Mac enables this switch and {label} enables It drives this Mac.")
@@ -300,11 +376,42 @@ class MachinesPanel:
disclosure = self._chip("Hide directions" if opened else "Directions", lambda t=row.token: self._toggle_directions(t),
f"{'Hide' if opened else 'Show'} directions for {label}",
(row.token, "directions"))
- widgets.add(body, self._controls(row, in_use, disclosure, drives, driven, remove))
+ widgets.add(body, self._controls(row, in_use, left_out, disclosure, drives, driven, remove, repair))
frame.addSubview_(body)
widgets.pin(body, frame, (10, 12, 10, 12))
return frame
+ def _begin_rename(self, token):
+ views = self._own_rename_views if token is None else self._rename_views.get(token)
+ if views is None:
+ return
+ name, button, box, edit, note, _delegate = views
+ if token is None:
+ edit.setStringValue_(self.settings_store.current().get("name", ""))
+ else:
+ entry = next((peer for peer in self.controller.book.peers() if peer.get("token") == token), {})
+ edit.setStringValue_(entry.get("label", "") or entry.get("name", ""))
+ name.setHidden_(True)
+ button.setHidden_(True)
+ box.setHidden_(False)
+ note.view.setHidden_(self.controller.cfg.same_on_both and "names" in self.controller.cfg.same_groups)
+ self.owner.window.makeFirstResponder_(edit)
+ edit.selectText_(None)
+
+ def _save_rename(self, token, text):
+ self.owner._rename_own(text) if token is None else self.owner._rename_peer(token, text)
+ self._cancel_rename(token)
+
+ def _cancel_rename(self, token):
+ views = self._own_rename_views if token is None else self._rename_views.get(token)
+ if views is None:
+ return
+ name, button, box, _edit, note, _delegate = views
+ name.setHidden_(False)
+ button.setHidden_(False)
+ box.setHidden_(True)
+ note.view.setHidden_(True)
+
def _chip(self, text, callback, label, focus_id=None):
chip = widgets.pressable(callback, "well", "edge", theme.RADIUS["field"])
chip.focus_id = focus_id
@@ -314,7 +421,7 @@ class MachinesPanel:
widgets.pin(word.view, chip, (6, 12, 6, 12))
return chip
- def _controls(self, row, in_use, disclosure, drives, driven, remove):
+ def _controls(self, row, in_use, left_out, disclosure, drives, driven, remove, repair=None):
"""The machine switch leads; its two direction switches stay under their disclosure."""
if self.removing == row.token:
column = widgets.stack(spacing=6)
@@ -326,7 +433,11 @@ class MachinesPanel:
line.setAlignment_(AppKit.NSLayoutAttributeTrailing)
if self.wide:
line.addArrangedSubview_(widgets.hug(widgets.box(), AppKit.NSLayoutPriorityDefaultLow))
+ if repair is not None:
+ line.addArrangedSubview_(repair)
widgets.add(line, in_use.view, full_width=not self.wide)
+ if not row.phone:
+ line.addArrangedSubview_(left_out)
if not row.phone:
line.addArrangedSubview_(disclosure)
line.addArrangedSubview_(remove)
@@ -379,7 +490,7 @@ class MachinesPanel:
self.refresh()
return
if removed is not None:
- self.logger.info("removed %s", removed.get("name") or "a machine")
+ self.logger.info("removed %s", peerlist.label_for([removed], token=token) or "a machine")
self.owner.peers_changed()
after = core_ways.way_back_state(self.settings_store.current())
changed_peers = [peer for peer, state in after.items() if before.get(peer) != state]
@@ -392,6 +503,12 @@ class MachinesPanel:
handler(token, **change)
self.refresh()
+ def _left_out(self, token, enabled):
+ handler = self.owner.left_out_handler
+ if handler is not None:
+ handler(token, enabled)
+ self.refresh()
+
# The sheet
def _toggle_sheet(self):
@@ -400,6 +517,21 @@ class MachinesPanel:
self._leave_sheet()
self.refresh()
+ def re_pair(self, token):
+ entry = next((item for item in self.controller.book.peers() if item.get("token") == token), None)
+ if entry is None:
+ return
+ self.open = True
+ self.chosen = None
+ for field in (self.find_field, self.find_secret):
+ field.setStringValue_("")
+ address = entry.get("host") or ""
+ field = self.find_secret if self.controller.cfg.hide_addresses else self.find_field
+ field.setStringValue_(address)
+ self._heard_key = None
+ self.refresh()
+ self.code_boxes.focus(self.owner.window)
+
def _leave_sheet(self):
self.code_boxes.clear()
self.chosen = None
@@ -662,7 +794,7 @@ class MachinesPanel:
self._say(self._shown(peerlist.pairing_error_text(result, name)), "fault")
return
# The name the exchange proved, not the one a beacon claimed.
- proved = result.get("name") or name
+ proved = peerlist.label_for(self.controller.book.peers(), token=result.get("token")) or name
self.code_boxes.clear()
for box_field in (self.find_field, self.find_secret):
box_field.setStringValue_("")
diff --git a/mac_app/media_keys.py b/mac_app/media_keys.py
index 8b5068b..9fd4af0 100644
--- a/mac_app/media_keys.py
+++ b/mac_app/media_keys.py
@@ -18,6 +18,8 @@ NX_SUBTYPE_AUX_CONTROL_BUTTONS = 8
NX_KEY_NAMES = {
0: "volume_up",
1: "volume_down",
+ 2: "brightness_up",
+ 3: "brightness_down",
7: "volume_mute",
16: "media_play_pause",
17: "media_next",
diff --git a/mac_app/notch_island.py b/mac_app/notch_island.py
index 21a54cc..bbc8dfd 100644
--- a/mac_app/notch_island.py
+++ b/mac_app/notch_island.py
@@ -22,8 +22,7 @@ import time
import AppKit
import Quartz
-import rumps
-
+from frame_clock import FrameClock
import tokens
NOTCH_FALLBACK_HEIGHT = 32.0
@@ -130,7 +129,7 @@ class NotchIsland:
self.kick = 0.0
self.held = 0.0
self.held_at = None
- self.timer = rumps.Timer(self._tick, 1 / 60)
+ self.timer = FrameClock(None, lambda: self._tick(None))
def _held(self, level, now):
"""Pressure as the animation shows it. Lifting a finger to reposition lets real pressure
diff --git a/mac_app/pages.py b/mac_app/pages.py
index e32d581..37d4414 100644
--- a/mac_app/pages.py
+++ b/mac_app/pages.py
@@ -10,7 +10,7 @@ import re
from core import effects
from core import peerlist
-from core.ways import part_names, parts_phrase, toggle_part
+from core.ways import DIAGRAM_GAP, DIAGRAM_THIS, diagram_layout, part_names, parts_phrase, toggle_part
# (key, name, SF Symbol, what the page is for), in sidebar order, which is the order a new Mac is
# set up in after the Overview; Cmd+1 is the first.
@@ -21,7 +21,7 @@ PAGES = (
("permissions", "Permissions", "lock.shield",
"macOS must allow Beamer to read this Mac's input and to move its pointer and type when another machine drives it."),
("crossing", "Crossing", "cursorarrow.motionlines",
- "Choose how the pointer or a key moves input to each machine, and how hard the edge pushes back first."),
+ "Drag a machine on the map to where it sits. The ledger says how each one is reached; click a row to pick it on the map."),
("keyboard", "Keyboard", "keyboard",
"How this Mac's modifier keys arrive on other machines, which keys and buttons stay on this Mac, "
"and how fast another machine's pointer moves here. The switch key is on the Crossing page."),
@@ -59,13 +59,15 @@ def opening_page(last, accessibility, input_monitoring):
return "overview" if accessibility and input_monitoring else "permissions"
-def dots(accessibility, input_monitoring, link_key):
- """Page key to the tone of its sidebar dot, for the pages that need one."""
+def dots(accessibility, input_monitoring, link_key, dormant=False):
+ """Page key to dot tone; a dormant peer marks Overview and Crossing amber."""
marks = {}
if not (accessibility and input_monitoring):
marks["permissions"] = "amber"
if link_key == "token":
marks["overview"] = "fault"
+ if dormant:
+ marks.update({"overview": "amber", "crossing": "amber"})
return marks
@@ -120,7 +122,7 @@ SIMPLE = "Simple"
def switch_style_groups(with_effects=True):
"""[(group, [(value, name, detail)])] for the style tiles in Switch mode: what a switch plays,
effects.SWITCH_STYLES, with the effects grouped as the crossing's are."""
- simple = [("match", "Same as crossing", "Plays the crossing style"), ("locator", "Ring", "Closes onto the pointer")]
+ simple = [("match", "Same as crossing", "Plays Glow"), ("locator", "Ring", "Closes onto the pointer")]
with_effects = with_effects and effects_load_error() is None
aperture = [(TODAY, [("aperture", effects.CLASSIC["aperture"].name,
effects.CLASSIC["aperture"].intensity.capitalize())])] if with_effects else []
@@ -161,16 +163,10 @@ def toggle_way(methods, way, on):
return [name for name in WAYS if name in chosen]
-# The Crossing page's diagram: this Mac's screen at 16:10 and the other machine's at 16:9, a gap between.
-DIAGRAM_THIS = (120.0, 75.0)
-DIAGRAM_OTHER = (112.0, 63.0)
-DIAGRAM_GAP = 10.0
MARK = 3.0
CORNER_MARK = 12.0
-DIAGRAM_SPLIT_GAP = 6.0
-DIAGRAM_MARGIN = 12.0
SIDES = ("left", "right", "top", "bottom")
PART_ORDER = ("start", "middle", "end")
@@ -181,51 +177,6 @@ def arrangement(width, height, side):
return this, other
-def diagram_layout(width, height, machines):
- """Where this Mac and each machine sit in a drawing `width` by `height`, top left at the origin.
- `machines` is (side, first third) per machine: side "" when it is not placed, first third the
- index of its first third when it crosses by Part of the edge, else None. Returns (this, frames),
- a frame (x, y, w, h) or None for each machine. Two or more on one side share it, each as much
- shorter as there are of them, in the order of their thirds when all have some, else of the
- list; the whole is centred, and shrinks to fit only when it must."""
- tw, th = DIAGRAM_THIS
- ow, oh = DIAGRAM_OTHER
- placed = [None] * len(machines)
- for side in SIDES:
- at = [index for index, (where, _third) in enumerate(machines) if where == side]
- if at and all(machines[index][1] is not None for index in at):
- at.sort(key=lambda index: machines[index][1])
- count = len(at)
- if not count:
- continue
- w, h = ow / count, oh / count
- upright = side in ("left", "right")
- step = (h if upright else w) + DIAGRAM_SPLIT_GAP
- start = ((th if upright else tw) - (step * count - DIAGRAM_SPLIT_GAP)) / 2
- for order, index in enumerate(at):
- along = start + order * step
- placed[index] = {
- "left": (-DIAGRAM_GAP - w, along), "right": (tw + DIAGRAM_GAP, along),
- "top": (along, -DIAGRAM_GAP - h), "bottom": (along, th + DIAGRAM_GAP),
- }[side] + (w, h)
- frames = [(0.0, 0.0, tw, th)] + [frame for frame in placed if frame is not None]
- left = min(x for x, _y, _w, _h in frames)
- top = min(y for _x, y, _w, _h in frames)
- span_w = max(x + w for x, _y, w, _h in frames) - left
- span_h = max(y + h for _x, y, _w, h in frames) - top
- scale = 1.0
- if span_w > width or span_h > height:
- scale = min((width - 2 * DIAGRAM_MARGIN) / span_w, (height - 2 * DIAGRAM_MARGIN) / span_h)
- dx = (width - span_w * scale) / 2 - left * scale
- dy = (height - span_h * scale) / 2 - top * scale
-
- def fit(frame):
- x, y, w, h = frame
- return (dx + x * scale, dy + y * scale, w * scale, h * scale)
-
- return fit(frames[0]), [None if frame is None else fit(frame) for frame in placed]
-
-
def placement(machine):
"""A machine as diagram_layout takes it: its side, and its first third when it crosses by Part
of the edge."""
@@ -420,17 +371,16 @@ def notch_or_corner_note(label):
def crossing_rows(methods):
- """Which of the Crossing page's rows and modules show for these ways. The rest are hidden, not
- dimmed, and reappear the moment a way that uses them is chosen."""
+ """Which Crossing modules show for these ways; Corner and the drag guard stay in place."""
chosen = set(methods)
pointer = bool(chosen & {"edge", "part", "corner", "notch"})
return {
# Where the other machine sits, which every way in uses: a crossing arrives by it, and with
# only the shortcut on it is still that machine's edge that leads back here.
"edge": True,
- "parts": "part" in chosen,
- "corner": "corner" in chosen,
- "dragging": pointer,
+ "parts": bool(chosen & {"edge", "part"}),
+ "corner": True,
+ "dragging": True,
"resistance": pointer,
"shortcut": "shortcut" in chosen,
}
diff --git a/mac_app/previews.py b/mac_app/previews.py
index 2df0f68..eae4309 100644
--- a/mac_app/previews.py
+++ b/mac_app/previews.py
@@ -14,6 +14,7 @@ Main thread only. A failing preview disables itself as the real renderer does; n
import time
import types
+import math
import AppKit
import Quartz
@@ -22,10 +23,12 @@ import objc
import crossing
from core import effects
import effects_overlay
+from frame_clock import PREVIEW_MAX_RATE, FrameClock
import motion
import notch_beam
import notch_island
import theme
+import tokens
PUSH_S = 1.8
REST_S = 1.0
@@ -135,6 +138,180 @@ def hosted_notch(base):
return HostedNotch
+class HostedNotchScene(effects_overlay.EffectsCanvas):
+ """A complete notch crossing with the real hosted NotchBeam or NotchIsland layer tree."""
+
+ @objc.python_method
+ def setup(self, base, controller, logger, style, colour, notch):
+ self.setTranslatesAutoresizingMaskIntoConstraints_(False)
+ self.widthAnchor().constraintEqualToAnchor_multiplier_(self.heightAnchor(), 2.0).setActive_(True)
+ self.setWantsLayer_(True)
+ self.layer().setCornerRadius_(theme.RADIUS["field"])
+ self.layer().setMasksToBounds_(True)
+ self.logger = logger
+ self.playing_since = None
+ self.style = style
+ self.colour = colour
+ self.notch = notch
+ self.controller = controller
+ self.still_at = 1.9
+ self.after = lambda: controller.cfg.crossing.get("notch_after_ms", 1200) / 1000.0
+ self.feed = PreviewFeed(controller, glow_colour=colour(), notch_style=style)
+ self.renderer = hosted_notch(base)(self.feed, logger, self._layer_host(notch))
+ self.renderer._show()
+ self.stage = self.renderer.screen.stage
+ self.stage.removeFromSuperlayer()
+ with notch_island._no_actions():
+ self.stage.setAnchorPoint_((0.0, 0.0))
+ self.stage.setPosition_((0.0, 0.0))
+ self.stage.setAffineTransform_(Quartz.CGAffineTransformIdentity)
+ self.painter = lambda ctx, width, height: self.paint_frame(ctx, width, height, self._time(),
+ self._live())
+ return self
+
+ @staticmethod
+ def _layer_host(notch):
+ host = PreviewScreen.alloc().initWithFrame_(AppKit.NSMakeRect(0, 0, 600, 540))
+ host.setup(notch)
+ host.setFrame_(AppKit.NSMakeRect(0, 0, 600, 540))
+ host.arrange()
+ return host
+
+ @objc.python_method
+ def _time(self):
+ since = self.playing_since
+ elapsed = None if since is None else time.monotonic() - since
+ return effects.preview_time(self.still_at, elapsed, effects_overlay.reduce_motion())
+
+ @objc.python_method
+ def _live(self):
+ return (self.playing_since is not None and time.monotonic() >= self.playing_since
+ and not effects_overlay.reduce_motion())
+
+ @objc.python_method
+ def paint_frame(self, ctx, width, height, at=None, live=False):
+ """Paint a deterministic frame; callers may supply `t` for offline judging renders."""
+ t = self._time() if at is None else at
+ t %= effects.PREVIEW_LOOP_S
+ current_colour = self.colour()
+ dark = theme.is_dark()
+ feel = self.controller.cfg.crossing
+ pace = feel.get("effect_pace", effects.pace(feel.get("effect_length")))
+ size = feel.get("effect_size", "medium")
+ size_fraction = feel.get("effect_size_fraction")
+ fx = effects.preview_effect("glow")
+ crop = effects.still_view(fx, "notch", size, pace, size_fraction)
+ scene = effects.preview_still_scene(fx, t, "notch", effects_overlay.palette(current_colour),
+ dark=dark, pace=pace, effect_size=size, live=live,
+ view_width=crop[2], effect_size_fraction=size_fraction,
+ notch_geometry=self.notch)
+ scene["pens"] = []
+ effects_overlay.draw_scene(Quartz, ctx, scene, width, height, "notch", dark, crop=crop, pointer=11.0)
+ self._set_renderer_frame(t, current_colour, dark)
+ x, y, w, h, _radius = scene["notch"]
+ stage_bounds = self.stage.bounds()
+ stage_width = stage_bounds.size.width
+ scene_w, scene_h = crop[2:]
+ scale = min(width / scene_w, height / scene_h)
+ Quartz.CGContextSaveGState(ctx)
+ try:
+ Quartz.CGContextTranslateCTM(ctx, (width - scene_w * scale) / 2.0,
+ (height - scene_h * scale) / 2.0)
+ Quartz.CGContextScaleCTM(ctx, scale, scale)
+ Quartz.CGContextTranslateCTM(ctx, -crop[0], -crop[1])
+ Quartz.CGContextClipToRect(ctx, ((crop[0], crop[1]), (scene_w, scene_h)))
+ Quartz.CGContextTranslateCTM(ctx, x + w / 2.0 - stage_width / 2.0, y)
+ self.stage.renderInContext_(ctx)
+ finally:
+ Quartz.CGContextRestoreGState(ctx)
+
+ @objc.python_method
+ def _set_renderer_frame(self, t, colour, dark):
+ """Set the existing renderer's layers directly from the shared crossing clock."""
+ renderer = self.renderer
+ push_start, cross_at = effects._P_PUSH, effects._P_CROSS
+ after = self.after()
+ pressure_end = cross_at
+ if t < push_start:
+ level, flash, elapsed = 0.0, 0.0, 0.0
+ elif t < pressure_end:
+ u = min(1.0, max(0.0, (t - push_start) / (pressure_end - push_start)))
+ level, flash, elapsed = (1.0 - math.cos(math.pi * u)) / 2.0, 0.0, 0.0
+ else:
+ elapsed = t - cross_at
+ phase = notch_island.breakthrough_phase(elapsed, after)
+ level, flash = (1.0, phase[1]) if phase is not None else (0.0, 0.0)
+ if isinstance(renderer, notch_beam.NotchBeam):
+ self._set_beam_frame(renderer, level, flash, elapsed, colour, dark, after, t)
+ else:
+ self._set_island_frame(renderer, level, flash, elapsed, after)
+
+ @staticmethod
+ def _set_beam_frame(renderer, level, flash, elapsed, colour, dark, after, t):
+ base = notch_beam.LAP * 0.3
+ if t < effects._P_CROSS:
+ position = (base + notch_beam.LAP * max(0.0, t - effects._P_PUSH)
+ / notch_beam.turn_seconds(level)) % notch_beam.LAP
+ else:
+ crossed = (base + notch_beam.LAP * (effects._P_CROSS - effects._P_PUSH)
+ / notch_beam.turn_seconds(1.0)) % notch_beam.LAP
+ travel = notch_beam.lap_finish(crossed, after)
+ position = (crossed + travel * notch_island.ease_out(elapsed / max(after, 0.001))) % notch_beam.LAP
+ spans = notch_beam.comet_segments(position)
+ with notch_island._no_actions():
+ for gradient in renderer.gradients:
+ gradient.setColors_(notch_beam.palette_colours(colour, closed=True, dark=dark))
+ for segments in renderer.comets:
+ for layer, (start, end) in zip(segments, spans):
+ layer.setHidden_(end - start < 0.002)
+ layer.setStrokeStart_(start)
+ layer.setStrokeEnd_(end)
+ renderer.island.setOpacity_(min(1.0, level * 20.0))
+ renderer.beam.setOpacity_(min(1.0, level + flash))
+ renderer.bloom.setOpacity_(min(1.0, level * 0.8 + flash * 0.6))
+ renderer.halo.setOpacity_(max(0.0, 1.0 - elapsed / notch_beam.HALO_S) * 0.9 if elapsed > 0 else 0.0)
+
+ @staticmethod
+ def _set_island_frame(renderer, level, flash, elapsed, after):
+ grow_w = level * tokens.ISLAND["grow_width"]
+ grow_d = level * tokens.ISLAND["grow_depth"]
+ with notch_island._no_actions():
+ renderer.island.removeAllAnimations()
+ renderer.rim.removeAllAnimations()
+ renderer.island.setPath_(renderer._island_path(grow_w, grow_d))
+ renderer.rim.setPath_(renderer._rim_path(grow_w, grow_d))
+ renderer.trace.setPath_(renderer._rim_path(grow_w, grow_d))
+ renderer.island.setOpacity_(1.0 if level > 0.0 else 0.0)
+ renderer.rim.setStrokeColor_(notch_island._colour(notch_island.FLASH_RIM) if flash else
+ notch_island._colour("signal"))
+ renderer.rim.setOpacity_(min(1.0, 0.25 + level * 0.9 + flash) if level or flash else 0.0)
+ renderer.rim.setShadowOpacity_(min(1.0, level * 0.75 + flash))
+ renderer.rim.setShadowRadius_(7.0 + flash * 7.0)
+ if elapsed > 0.0:
+ progress = min(1.0, elapsed / max(after, 0.001))
+ head = notch_island.trace_head(progress, after)
+ renderer.trace.setStrokeStart_(max(0.0, head - notch_island.TRACE_LENGTH))
+ renderer.trace.setStrokeEnd_(min(1.0, head))
+ renderer.trace.setOpacity_(1.0)
+ else:
+ renderer.trace.setOpacity_(0.0)
+ meter = max(0.0, min(1.0, (grow_d - tokens.ISLAND["meter_after_depth"]) / 8.0))
+ renderer._set_meter(level, meter)
+ renderer.meter.setOpacity_(meter)
+
+
+def notch_crossing_still(base, colour, logger, controller=None, notch=None):
+ """A notch style tile backed by its real renderer and the shared two-screen crossing scene."""
+ if controller is None:
+ cfg = types.SimpleNamespace(crossing={"notch_after_ms": 1200, "glow_colour": colour()})
+ controller = types.SimpleNamespace(cfg=cfg)
+ style = "beam" if issubclass(base, notch_beam.NotchBeam) else "island"
+ view = HostedNotchScene.alloc().initWithFrame_(AppKit.NSMakeRect(0, 0, 1, 1))
+ if notch is None:
+ notch = (effects.PREVIEW_NOTCH["w"], effects.PREVIEW_NOTCH["h"])
+ return view.setup(base, controller, logger, style, colour, notch)
+
+
def hosted_edge(base):
"""The app's EdgeGlow, drawing its band along the right side of a PreviewScreen."""
@@ -232,15 +409,9 @@ class PreviewScreen(AppKit.NSView):
Quartz.CATransaction.commit()
-FRAME_RATE = 60
HOVER_INTENT_S = 0.1
-class _Fire(AppKit.NSObject):
- def fire_(self, _sender):
- self.callback()
-
-
def on_screen(view):
"""Whether any of `view` can be seen: in a window on screen and not covered, not hidden, and not
scrolled out of its page."""
@@ -253,45 +424,6 @@ def on_screen(view):
return visible.size.width > 0 and visible.size.height > 0
-class FrameClock:
- """Calls `callback()` once a frame, timed to `view`'s display at up to FRAME_RATE where macOS
- offers a view's display link (14 and later), else by a timer. Either runs in the common run loop
- modes, as a default-mode timer, rumps.Timer's, stops dead while the page scrolls or a slider is
- dragged and then jumps."""
-
- def __init__(self, view, callback):
- self.view = view
- self.callback = callback
- self.source = None
-
- def start(self):
- if self.source is not None:
- return
- target = _Fire.alloc().init()
- target.callback = self.callback
- runloop = AppKit.NSRunLoop.mainRunLoop()
- if self.view.window() is not None and hasattr(self.view, "displayLinkWithTarget_selector_"):
- link = self.view.displayLinkWithTarget_selector_(target, "fire:")
- # 60 on a 120Hz panel lands every other refresh, evenly, where a timer beats against it.
- link.setPreferredFrameRateRange_(Quartz.CAFrameRateRangeMake(30, FRAME_RATE, FRAME_RATE))
- link.addToRunLoop_forMode_(runloop, AppKit.NSRunLoopCommonModes)
- self.source = link
- else:
- timer = AppKit.NSTimer.timerWithTimeInterval_target_selector_userInfo_repeats_(
- 1.0 / FRAME_RATE, target, "fire:", None, True
- )
- runloop.addTimer_forMode_(timer, AppKit.NSRunLoopCommonModes)
- self.source = timer
-
- def stop(self):
- source, self.source = self.source, None
- if source is not None:
- source.invalidate()
-
- def is_alive(self):
- return self.source is not None
-
-
class PreviewLoop:
"""Plays the page's hosted renderers from one clock: the tile the pointer is over, else the
tiles set `resting`. Every other tile holds a still, the push part way in, and a tile that starts
@@ -308,16 +440,16 @@ class PreviewLoop:
self.resting = ()
self.hovered = None
self.hovered_at = 0.0
- self.clock = None if host is None else FrameClock(host, self._tick)
+ self.clock = None if host is None else FrameClock(host, self._tick, PREVIEW_MAX_RATE)
def add(self, feed, renderer, update, screen):
"""`update(kind, pressure)` passes an event to `renderer` the way the app's crossing
feedback would. The renderer's own timer is swapped for a FrameClock on `screen`."""
- renderer.timer = FrameClock(screen, lambda: renderer._tick(None))
+ renderer.timer = FrameClock(screen, lambda: renderer._tick(None), PREVIEW_MAX_RATE)
self.players.append(types.SimpleNamespace(feed=feed, renderer=renderer, update=update, screen=screen,
started_at=None, phase=None, quarter=0))
if self.clock is None:
- self.clock = FrameClock(screen, self._tick)
+ self.clock = FrameClock(screen, self._tick, PREVIEW_MAX_RATE)
def owns(self, view):
return any(player.screen is view for player in self.players)
@@ -329,15 +461,35 @@ class PreviewLoop:
"""`view` is the preview of the tile under the pointer, one of this loop's or not, or None."""
self.hovered = view
self.hovered_at = time.monotonic()
+ # Under Reduce Motion nothing plays, so the clock has nothing to drive.
+ if self.running and self.owns(view) and self.clock is not None and not effects_overlay.reduce_motion():
+ self.clock.start()
def start(self):
if self.running:
+ self.sync_clock()
return
self.running = True
self.repaint()
- if self.clock is not None:
+ if self.owns(self.hovered) and self.clock is not None:
self.clock.start()
+ def sync_clock(self):
+ if self.clock is None:
+ return
+ wanted = (self.running and not effects_overlay.reduce_motion()
+ and any(on_screen(player.screen) and
+ (player.screen is self.hovered or player.screen in self.resting)
+ for player in self.players))
+ if wanted:
+ self.clock.start()
+ else:
+ for player in self.players:
+ if player.started_at is not None:
+ player.started_at = None
+ self._hold(player)
+ self.clock.stop()
+
def stop(self):
if not self.running:
return
@@ -421,6 +573,7 @@ class PreviewLoop:
player.update("cross", 1.0)
elif phase == "push" and level > 0.0:
player.update("tick" if ticked else "pressure", level)
+ self.sync_clock()
class TileStack(AppKit.NSView):
@@ -475,9 +628,8 @@ class _HoverOwner(AppKit.NSObject):
class TileHover:
- """The one tile under the pointer plays its animation and settles back to its still when the
- pointer leaves; under Reduce Motion it keeps its still. A crossing effect's still plays on from
- the frame it shows, so the tile starts without a jump."""
+ """The hovered tile plays after intent and restores its still on leaving. Crossings begin
+ with approach; shortcut arrivals resume their still. Reduce Motion keeps the still."""
def __init__(self, loop):
self.loop = loop
@@ -510,9 +662,22 @@ class TileHover:
return
# A pointer passing over on its way elsewhere leaves the tiles it crosses still.
target.playing_since = time.monotonic() + HOVER_INTENT_S
- self.clock = FrameClock(target, lambda: target.setNeedsDisplay_(True))
+ self.clock = FrameClock(target, self._tick, PREVIEW_MAX_RATE)
self.clock.start()
+ def sync_clock(self):
+ if self.clock is None:
+ return
+ if on_screen(self.target) and not effects_overlay.reduce_motion():
+ self.clock.start()
+ else:
+ self.clock.stop()
+
+ def _tick(self):
+ self.sync_clock()
+ if self.clock is not None and self.clock.is_alive():
+ self.target.setNeedsDisplay_(True)
+
def leave(self, preview):
if preview is self.current:
self.stop()
@@ -541,27 +706,24 @@ def notch_update(renderer):
# The crossing effects' previews: effects.preview_scene drawn by effects_overlay.draw_scene, the same
# replay the overlay uses on screen. Every tile shows one still frame at the place the page's Show at
-# chooses, and plays on from it while TileHover says the pointer is over it; nothing else animates.
-# The still is part way into the push, where every style shows.
-STILL_AT_S = 1.7
-# The part of the scene a tile shows at each place, centred on where the pointer pushes so the
-# departure fills the tile: the Mac's right-hand side, the gap and the PC's left edge; the Mac's
-# top right corner with room above it; the notch and the Mac's screen under it, where the forms play.
-STILL_CROPS = {"edge": (620.0, 142.0, 240.0, 120.0), "corner": (680.0, -50.0, 240.0, 120.0),
- "notch": (220.0, 470.0, 360.0, 180.0)}
+# chooses, and plays the full journey while TileHover says the pointer is over it.
STAGE_METHODS = (("edge", "Edge"), ("corner", "Corner"), ("notch", "Notch"))
-SWITCH_STILL_CROP = (248.0, 138.0, 240.0, 120.0)
-SWITCH_STILL_AT_S = 0.6
-def _played(view, still_at):
- """The time into its loop a tile draws: its still, or on from it while it plays."""
+def _played(view, still_at, switch=False):
+ """Crossings start at approach; shortcut arrivals resume their specimen frame."""
since = view.playing_since
- return still_at if since is None else still_at + max(0.0, time.monotonic() - since)
+ return effects.preview_time(still_at, None if since is None else time.monotonic() - since,
+ effects_overlay.reduce_motion(), switch=switch)
+
+
+def _live(view):
+ return (view.playing_since is not None and time.monotonic() >= view.playing_since
+ and not effects_overlay.reduce_motion())
def effect_still(effect_id, colour, logger, height=84, place=lambda: "edge", pace=lambda: 1.0,
- effect_size=lambda: "medium"):
+ effect_size=lambda: "medium", effect_size_fraction=lambda: None):
"""A tile's still frame of `effect_id`, in the selected colour, place, length and size."""
view = effects_overlay.EffectsCanvas.alloc().initWithFrame_(AppKit.NSMakeRect(0, 0, 1, 1))
view.setTranslatesAutoresizingMaskIntoConstraints_(False)
@@ -569,8 +731,7 @@ def effect_still(effect_id, colour, logger, height=84, place=lambda: "edge", pac
view.setWantsLayer_(True)
view.layer().setCornerRadius_(theme.RADIUS["field"])
view.layer().setMasksToBounds_(True)
- view.layer().setBorderWidth_(1)
- theme.tint(view.layer(), border="rule")
+ view.layer().setBorderWidth_(0)
view.logger = logger
view.playing_since = None
@@ -578,29 +739,37 @@ def effect_still(effect_id, colour, logger, height=84, place=lambda: "edge", pac
fx = effects.preview_effect(effect_id)
dark = theme.is_dark()
where = place()
- # Beam's comet crosses the cropped pointer at this time; the common still puts it off-tile.
- held_at = 1.45 if effect_id == "beam" and where == "edge" else STILL_AT_S
- scene = effects.preview_scene(fx, _played(view, held_at), where, effects_overlay.palette(colour()), dark=dark,
- pace=pace(), effect_size=effect_size())
- # A small pointer, so the effect rather than the arrow is what a tile shows.
- # A desktop-scale thin line would disappear below one pixel in the common crop.
- crop = (730.0, 172.5, 120.0, 60.0) if effect_id == "beam" and where == "edge" else STILL_CROPS[where]
+ current_pace, current_size, size_fraction = pace(), effect_size(), effect_size_fraction()
+ held_at = effects.still_time(fx, where, current_size, current_pace, size_fraction)
+ crop = effects.still_view(fx, where, current_size, current_pace, size_fraction)
+ scene = effects.preview_still_scene(
+ fx, _played(view, held_at), where, effects_overlay.palette(colour()), dark=dark,
+ pace=current_pace, effect_size=current_size, live=_live(view), view_width=crop[2],
+ effect_size_fraction=size_fraction)
effects_overlay.draw_scene(Quartz, ctx, scene, width, height, where, dark, crop=crop, pointer=11.0)
view.painter = paint
return view
-def switch_still(fx, colour, logger, height=84, pace=lambda: 1.0, effect_size=lambda: "medium"):
+def switch_still(fx, colour, logger, height=84, pace=lambda: 1.0, effect_size=lambda: "medium",
+ effect_size_fraction=lambda: None):
"""A tile's still frame of what a switch plays: `fx()` is the Effect, asked when it draws, since
Same as crossing follows the crossing style."""
view = effect_still(None, colour, logger, height)
def paint(ctx, width, height):
dark = theme.is_dark()
- scene = effects.preview_switch_scene(fx(), _played(view, SWITCH_STILL_AT_S), effects_overlay.palette(colour()),
- dark=dark, pace=pace(), effect_size=effect_size())
- effects_overlay.draw_scene(Quartz, ctx, scene, width, height, "switch", dark, crop=SWITCH_STILL_CROP, pointer=11.0)
+ effect = fx()
+ current_pace, current_size, size_fraction = pace(), effect_size(), effect_size_fraction()
+ t = _played(view, effects.still_time(effect, "switch", current_size, current_pace, size_fraction), switch=True)
+ crop = effects.still_view(effect, "switch", current_size, current_pace, size_fraction)
+ scene = effects.preview_still_scene(
+ effect, t, "switch", effects_overlay.palette(colour()), dark=dark, pace=current_pace,
+ effect_size=current_size, live=_live(view), view_width=crop[2],
+ effect_size_fraction=size_fraction)
+ effects_overlay.draw_scene(Quartz, ctx, scene, width, height, "switch", dark,
+ crop=crop, pointer=11.0)
view.painter = paint
return view
diff --git a/mac_app/settings_store.py b/mac_app/settings_store.py
index 8962798..f4ab8e6 100644
--- a/mac_app/settings_store.py
+++ b/mac_app/settings_store.py
@@ -21,6 +21,7 @@ from pathlib import Path
import config as config_module
from core import effects
+from core import crossing_state
from core import ignored
from core import peerlist
from core import protocol
@@ -29,6 +30,7 @@ from core import return_edge
from core import ways
from crossing import CORNERS, EDGES, GLOW_COLOURS, GLOW_STYLES, HAPTIC_FEELS, HAPTIC_STEPS, METHODS, NOTCH_STYLES
+import dock_visibility
from key_codes import KEY_NAME_TO_CODE
from wake import parse_mac
@@ -45,7 +47,8 @@ MAX_PEERS = 32
MOVED_CROSSING = ("methods", "edge", "edge_parts", "corner", "arrangement_set_at")
ZONE_KINDS = tuple(method for method in METHODS if method != "shortcut")
# Fields settings.json has that Config has no name for; everything else in it is Config's own.
-SETTINGS_ONLY = ("schema", "machine_id", "name", "port", "shortcut", "migrated_token_sha256", "peers", "zones", "crossing")
+SETTINGS_ONLY = ("schema", "machine_id", "name", "port", "shortcut", "migrated_token_sha256", "peers", "zones", "crossing",
+ "layout", "layout_set_at", "layout_by", "show_in_dock")
PEER_DEFAULTS = {
"id": "", "name": "", "platform": "", "token": "", "host": "", "port": 0, "hw": "", "send": True,
"allow_drive": True, "in_use": True, "side": "", "side_set_at": 0, "side_by": "", "paired_with": [], "paired_at": 0,
@@ -108,7 +111,9 @@ def editable_default_config():
hide_addresses=False,
same_on_both=False,
same_set_at=0,
+ same_groups=[],
same_by="",
+ same_stamps={},
design_set_at=0,
design_by="",
design_follow_peer="",
@@ -143,7 +148,9 @@ def config_to_raw(cfg):
"hide_addresses": cfg.hide_addresses,
"same_on_both": cfg.same_on_both,
"same_set_at": cfg.same_set_at,
+ "same_groups": list(cfg.same_groups),
"same_by": cfg.same_by,
+ "same_stamps": {key: list(pair) for key, pair in cfg.same_stamps.items()},
"design_set_at": cfg.design_set_at,
"design_by": cfg.design_by,
"design_follow_peer": cfg.design_follow_peer,
@@ -199,6 +206,12 @@ def _apply_zones(zones, peer_id, crossing):
def _crossing_from_zones(settings, peer):
"""The crossing choices the zones and `shortcut` stand for, read for one peer."""
+ if isinstance(peer.get("ways"), dict):
+ intent = ways.ways(settings, peer["id"])
+ return dict(methods=(["shortcut"] if settings["shortcut"] else []) + intent["methods"],
+ edge=peer["side"] or config_module.DEFAULT_CROSSING["edge"],
+ edge_parts=intent["parts"], corner=intent["corner"],
+ arrangement_set_at=peer["side_set_at"])
mine = {}
for zone in settings["zones"]:
if zone.get("peer") == peer["id"] and zone.get("kind") in ZONE_KINDS:
@@ -329,6 +342,7 @@ class SettingsStore:
of `replaced` when there is one. Raises SettingsError, writing nothing, if it cannot be saved."""
with self.lock:
settings = copy.deepcopy(self.current())
+ first_picture = set(settings.get("layout", {})) <= {settings["machine_id"]}
if replaced is not None:
held = next((peer for peer in settings["peers"] if peer["token"] == replaced.get("token")), None)
# The snapshot `replaced` came from was taken before this lock: it may have changed
@@ -336,7 +350,10 @@ class SettingsStore:
if held is None or held["id"] != replaced.get("id") or held["linked"] != replaced.get("linked"):
raise SettingsError("the machine being replaced changed while pairing")
peerlist.add_peer(settings, entry, replaced)
- self.save_settings(settings)
+ if first_picture:
+ settings["layout"] = {}
+ outcome = crossing_state.paired(settings, platform="mac", own_displays={}, now=time.time())
+ self.save_settings(outcome["settings"])
def set_peer(self, token, **switches):
"""Turns `send`, `allow_drive` and `in_use` on or off for the machine holding `token`; returns
@@ -374,26 +391,19 @@ class SettingsStore:
self.save_settings(settings)
return removed
- def set_ways(self, peer, *, side, methods, parts, corner, live=None):
- """Writes one machine's side and zones, as the Crossing page shows them for it (core/ways.py).
- A machine with no link now (`live(id)` false) gives way to them. Returns whether its side
- moved, which the caller sends it as `arrangement`; SettingsError, writing nothing, for a
- machine not in the list or zones that would clash with another's."""
+ def set_ways(self, peer, *, side=None, methods, parts, corner, live=None, gone=None, capable=()):
+ """Compatibility controls write local intent; the picture alone supplies the side."""
with self.lock:
- settings = copy.deepcopy(self.current())
try:
- moved = ways.edit(settings, peer, side=side, methods=methods, parts=parts, corner=corner,
- kinds=ZONE_KINDS, corner_edge=lambda corner, _side: _corner_edge(corner), now=time.time())
- except KeyError:
- raise SettingsError("that machine is no longer paired with this Mac") from None
- if moved:
- # Moved onto a side another machine's edge holds: the side stands and this machine's
- # way there goes off, as when the side arrives from it; the page says who holds it.
- ways.settle(settings, peer, "this Mac", live)
- for notice in ways.give_way(settings, peer, "this Mac", live):
- LOGGER.info("%s", notice)
- self.save_settings(settings)
- return moved
+ outcome = crossing_state.edit_ways(self.current(), peer, platform="mac",
+ edge=bool(set(methods) & {"edge", "part"}),
+ thirds=list(ways.PARTS) if "edge" in methods else parts,
+ corner="corner" in methods, corner_at=corner, notch="notch" in methods,
+ live=live, gone=gone, now=time.time(), capable=capable)
+ except (KeyError, ValueError) as exc:
+ raise SettingsError("that machine is no longer paired with this Mac") from exc
+ self.save_settings(outcome["settings"])
+ return False
def share_side(self, side, thirds):
"""Split one side's zones under the store lock, returning every machine whose zones changed."""
@@ -418,30 +428,22 @@ class SettingsStore:
return True
def settle_presence(self, live, gone):
- """What became of the zones set aside for a machine with no link (core/ways.py settle_presence).
- Returns (changed, notices): whether the file was written, and a sentence for each zone that
- stays off for good or could not be put back."""
- with self.lock:
- settings = copy.deepcopy(self.current())
- notices = ways.settle_presence(settings, "this Mac", live, gone)
- changed = settings != self.current()
- if changed:
- self.save_settings(settings)
- return changed, notices
+ """Presence has no saved history in the picture model."""
+ return False, []
- def arrangement(self, peer, edge, set_at, by, way_back=None, way_back_by=None, live=None):
- """A machine's `arrangement`, kept when it is newer than the side held for that machine, and
- its `way_back` whatever the side (core/ways.py). Returns (changed, notices), a sentence for each
- zone it turned off."""
+ def arrangement(self, peer, edge, set_at, by, way_back=None, way_back_by=None, live=None,
+ gone=None, capable=()):
+ """Retain return status, taking side stamps only from old peers."""
with self.lock:
- settings = copy.deepcopy(self.current())
- changed, notices = ways.arrangement(settings, peer, edge, set_at, by, "this Mac", way_back,
- way_back_by=way_back_by, live=live)
- if changed:
- self.save_settings(settings)
- return changed, notices
-
- def save(self, raw):
+ outcome = crossing_state.receive_arrangement(self.current(), peer,
+ dict(edge=edge, set_at=set_at, by=protocol.read_id(by), way_back=way_back,
+ way_back_by=protocol.read_id(way_back_by)), platform="mac", capable=capable,
+ live=live, gone=gone, now=time.time())
+ if outcome["changed"]:
+ self.save_settings(outcome["settings"])
+ return outcome["changed"], []
+
+ def save(self, raw, settings_changes=None, remove_settings=()):
try:
cfg = config_module.parse_config(raw)
except (config_module.ConfigError, TypeError, ValueError, OverflowError) as exc:
@@ -457,6 +459,10 @@ class SettingsStore:
except ValueError as exc:
raise SettingsError(str(exc)) from exc
cfg = self._without_stale_pairing(cfg, base, handed)
+ if settings_changes:
+ base.update(copy.deepcopy(settings_changes))
+ for key in remove_settings:
+ base.pop(key, None)
return self._config(self.save_settings(_merge_config(base, cfg)))
@staticmethod
@@ -479,13 +485,35 @@ class SettingsStore:
def load_settings(self):
"""The whole of settings.json, made from config.json on the first start and kept in step with it after."""
with self.lock:
+ files = self._file_state()
+ if self._cache is not None and files == getattr(self, "_loaded_files", None):
+ return copy.deepcopy(self._cache)
if not self.path.exists():
settings = self._migrate()
else:
settings = self._reimport(self._read())
+ before = copy.deepcopy(settings)
+ ways.prune_layout(settings)
+ self._ensure_zones(settings)
+ if settings != before or getattr(self, "_read_migrated", False):
+ settings = self._save_settings(settings)
self._cache = copy.deepcopy(settings)
+ # A writer replacing the file during the read must be noticed next time.
+ self._loaded_files = files
return settings
+ def _file_state(self):
+ result = []
+ for path in (self.path, self.legacy_path):
+ try:
+ stat = path.stat()
+ result.append((stat.st_dev, stat.st_ino, stat.st_size, stat.st_mtime_ns, stat.st_ctime_ns))
+ except FileNotFoundError:
+ result.append(None)
+ except OSError as exc:
+ raise SettingsError(str(exc)) from exc
+ return tuple(result)
+
def save_settings(self, settings):
"""Check and write `settings` atomically; returns what was written."""
with self.lock:
@@ -494,17 +522,24 @@ class SettingsStore:
return written
def _save_settings(self, settings):
- settings = self._complete(settings)
+ settings = copy.deepcopy(settings)
try:
before = self._read()
except SettingsError:
before = None
- if before:
+ if (before and isinstance(settings, dict) and isinstance(settings.get("peers"), list)
+ and isinstance(settings.get("zones"), list)
+ and all(isinstance(zone, dict) for zone in settings["zones"])):
unnamed = next((peer for peer in before["peers"] if peer["id"] == ""), None)
if unnamed:
- learnt = next((peer for peer in settings["peers"] if peer["token"] == unnamed["token"] and peer["id"]), None)
+ learnt = next((peer for peer in settings["peers"] if isinstance(peer, dict)
+ and peer.get("token") == unnamed["token"] and peer.get("id")), None)
if learnt:
settings["zones"] = _rename_zones(settings["zones"], "", learnt["id"])
+ elif any(peer.get("id") == "" and peer.get("token") == unnamed["token"]
+ for peer in settings["peers"]) and not any(zone.get("peer") == "" for zone in settings["zones"]):
+ settings["zones"].extend(copy.deepcopy(zone) for zone in before["zones"] if zone.get("peer") == "")
+ settings = self._complete(settings)
self._ensure_zones(settings)
self._check(settings)
self._write(settings)
@@ -530,6 +565,11 @@ class SettingsStore:
"peers": [],
"zones": [],
"crossing": {},
+ "layout": {},
+ "layout_set_at": 0,
+ "layout_by": "",
+ "same_groups": [],
+ "show_in_dock": True,
}
def _read(self):
@@ -539,16 +579,21 @@ class SettingsStore:
raise SettingsError(f"{self.path.name} could not be read: {exc}") from exc
if not isinstance(settings, dict) or settings.get("schema") != SCHEMA:
raise SettingsError(f"{self.path.name} is not a schema {SCHEMA} settings file")
+ original = copy.deepcopy(settings)
settings = self._complete(settings)
self._ensure_zones(settings)
self._check(settings)
+ self._read_migrated = settings != original
return settings
def _complete(self, settings):
"""A copy with every field the format has, so a hand-edited file missing one does not break a read."""
settings = copy.deepcopy(settings)
- for name in ("name", "port", "shortcut", "migrated_token_sha256", "crossing"):
+ for name in ("name", "port", "shortcut", "migrated_token_sha256", "crossing", "layout", "layout_set_at", "layout_by"):
settings.setdefault(name, self._fresh()[name])
+ dock_visibility.complete_settings(settings)
+ settings.setdefault("same_groups", ["crossing", "design", "shortcut", "names"]
+ if settings.get("same_on_both", False) else [])
for name in ("machine_id", "peers", "zones"):
if name not in settings:
raise SettingsError(f"{name} is missing; settings.json is not written over a file that lacks it")
@@ -558,21 +603,38 @@ class SettingsStore:
peerlist.normalise_phones(settings)
if not isinstance(settings["crossing"], dict):
raise SettingsError("crossing must be a JSON object")
+ if (not isinstance(settings["layout"], dict) or type(settings["layout_set_at"]) is not int
+ or not 0 <= settings["layout_set_at"] <= 2 ** 53 - 2
+ or not isinstance(settings["layout_by"], str)
+ or settings["layout_by"] and not is_machine_id(settings["layout_by"])):
+ raise SettingsError("layout and its stamp are invalid")
settings["crossing"] = {
**{name: value for name, value in config_module.DEFAULT_CROSSING.items() if name not in MOVED_CROSSING},
**settings["crossing"],
} if peerlist.first_desktop(settings["peers"]) is not None else {**config_module.DEFAULT_CROSSING, **settings["crossing"]}
+ self._check(settings)
+ self._ensure_zones(settings)
+ if not settings["layout"]:
+ settings["layout"] = ways.derive_layout(settings, gap=0)
+ if len(settings["layout"]) > MAX_PEERS + 1 or settings["machine_id"] not in settings["layout"] or any(
+ not is_machine_id(machine) or not isinstance(tile, dict)
+ or any(type(tile.get(key)) is not int for key in ("x", "y", "w", "h"))
+ or tile["w"] < 1 or tile["h"] < 1 or not ways._valid_tile_displays(tile)
+ for machine, tile in settings["layout"].items()):
+ raise SettingsError("layout must have a valid tile for each machine id")
return settings
- @staticmethod
- def _ensure_zones(settings):
- """Give old pairs their edge and the one unplaced desktop its shown side on every read and save.
- Run after a learnt id has renamed migrated zones, or that machine would get a second edge."""
+ def _ensure_zones(self, settings):
+ """Read legacy choices once and derive zones from the saved picture and intent."""
if (isinstance(settings["zones"], list)
and all(isinstance(item, dict) for item in settings["peers"] + settings["zones"])
and all(isinstance(item.get("id"), str) for item in settings["peers"])):
- ways.ensure_zones(settings)
- ways.default_side(settings)
+ legacy = [copy.deepcopy(zone) for zone in settings["zones"] if zone.get("peer") == ""
+ and any(peer.get("id") == "" for peer in settings["peers"])]
+ outcome = crossing_state.migrate(settings, "mac", capable=getattr(self, "_crossing_capable", ()))
+ settings.clear()
+ settings.update(outcome["settings"])
+ settings["zones"].extend(legacy)
def _check(self, settings):
if not is_machine_id(settings["machine_id"]):
@@ -580,6 +642,10 @@ class SettingsStore:
for name, kind in (("name", str), ("shortcut", bool), ("migrated_token_sha256", str), ("zones", list)):
if not isinstance(settings[name], kind):
raise SettingsError(f"{name} must be {kind.__name__}")
+ try:
+ dock_visibility.validate_settings(settings)
+ except ValueError as exc:
+ raise SettingsError(str(exc)) from exc
if isinstance(settings["port"], bool) or not isinstance(settings["port"], int) or not 1 <= settings["port"] <= 65535:
raise SettingsError("port must be between 1 and 65535")
if not all(isinstance(zone, dict) and isinstance(zone.get("peer"), str) and zone.get("kind") in ZONE_KINDS
@@ -621,14 +687,6 @@ class SettingsStore:
key_ids.add(protocol.key_id(peer["token"]))
if any(zone["peer"] not in ids for zone in settings["zones"]):
raise SettingsError("a zone names a peer that is not in the list")
- self._check_overlap(settings)
-
- def _check_overlap(self, settings):
- """Two zones in use never cover one stretch (WIRE.md section 8); a corner inside an edge is the
- exception, and the notch stands beside the top edge, as 1.4.x let it, but leads to one machine."""
- sentence = ways.clash(settings, "this Mac")
- if sentence is not None:
- raise SettingsError(sentence)
def _write(self, settings):
self.path.parent.mkdir(parents=True, exist_ok=True, mode=0o700)
@@ -767,6 +825,14 @@ class SettingsStore:
for name, allowed in choices:
if crossing[name] not in allowed:
raise SettingsError(f"crossing.{name} must be one of: {', '.join(allowed)}")
+ for name, low, high in (("effect_pace", effects.MIN_EFFECT_PACE, effects.MAX_EFFECT_PACE),
+ ("effect_size_fraction", effects.MIN_EFFECT_SIZE_FRACTION,
+ effects.MAX_EFFECT_SIZE_FRACTION)):
+ value = crossing[name]
+ valid = (effects.valid_effect_pace(value) if name == "effect_pace"
+ else effects.valid_effect_size_fraction(value))
+ if not valid:
+ raise SettingsError(f"crossing.{name} must be a number between {low} and {high}")
for name in ("haptics", "glow", "block_while_dragging", "shortcut_arrival", "hold_full_screen"):
if not isinstance(crossing[name], bool):
raise SettingsError(f"crossing.{name} must be true or false")
diff --git a/mac_app/setup.py b/mac_app/setup.py
index 7955b4f..696151f 100644
--- a/mac_app/setup.py
+++ b/mac_app/setup.py
@@ -25,6 +25,7 @@ setup(
"config",
"crossing",
"desktop_mac",
+ "dock_visibility",
"diagram",
"effects_overlay",
"gestures",
diff --git a/mac_app/tests/__init__.py b/mac_app/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/mac_app/tests/bridge_fakes.py b/mac_app/tests/bridge_fakes.py
index bf3d80c..69f58a3 100644
--- a/mac_app/tests/bridge_fakes.py
+++ b/mac_app/tests/bridge_fakes.py
@@ -27,6 +27,8 @@ class FakeQuartz:
kCGEventTapDisabledByTimeout = 0xFFFFFFFE
kCGEventTapDisabledByUserInput = 0xFFFFFFFF
kCGEventSourceUserData = 42
+ kCGEventSourceStateHIDSystemState = 1
+ kCGAnyInputEventType = 0
kCGKeyboardEventKeycode = 9
kCGKeyboardEventAutorepeat = 8
kCGMouseEventDeltaX = 4
@@ -98,6 +100,10 @@ class FakeQuartz:
def CGEventTapEnable(cls, tap, enabled):
cls.tap_enable_calls.append((tap, enabled))
+ @staticmethod
+ def CGEventSourceSecondsSinceLastEventType(source, event_type):
+ return 3600.0
+
class FakeGestureEvent:
"""Stands in for bridge.py's `_GestureEventView` (the object a converted
@@ -200,4 +206,3 @@ class FakeClipboard:
self.text, self.image = text, image
self.stamp += 1
return True
-
diff --git a/mac_app/tests/design_offscreen.py b/mac_app/tests/design_offscreen.py
index e2ddf39..1e22301 100644
--- a/mac_app/tests/design_offscreen.py
+++ b/mac_app/tests/design_offscreen.py
@@ -19,6 +19,22 @@ def settle(window):
assert not window.isVisible()
+def raster(view):
+ rep = view.bitmapImageRepForCachingDisplayInRect_(view.bounds())
+ view.cacheDisplayInRect_toBitmapImageRep_(view.bounds(), rep)
+ return rep
+
+
+def accent_pixels_near_top_edge(view):
+ rep = raster(view)
+ left, right = int(rep.pixelsWide() * .25), int(rep.pixelsWide() * .75)
+ return sum(
+ 1 for y in range(2, min(16, rep.pixelsHigh())) for x in range(left, right)
+ if (lambda colour: colour.blueComponent() > .55 and
+ colour.blueComponent() - colour.redComponent() > .18)(rep.colorAtX_y_(x, y))
+ )
+
+
def rect_list(rect):
return [rect.origin.x, rect.origin.y, rect.size.width, rect.size.height]
diff --git a/mac_app/tests/render_crossing_ledger.py b/mac_app/tests/render_crossing_ledger.py
new file mode 100644
index 0000000..b3e2117
--- /dev/null
+++ b/mac_app/tests/render_crossing_ledger.py
@@ -0,0 +1,74 @@
+"""Render one of the seven ledger states without ordering a window or capturing the screen."""
+import copy
+from pathlib import Path
+import sys
+from unittest import mock
+
+from mac_app.tests.test_crossing_page_machines import Page, BEE, SEA, OAK, token
+from mac_app.tests.design_offscreen import AppKit, settle
+from mac_app.tests.settings_layout_offscreen import render, measure
+import theme
+
+
+def built_state(number, destination):
+ fixture = Page()
+ fixture.setUp()
+ try:
+ side = "left" if number in (2, 3) else "top"
+ peers = [(BEE, token(100), "Gaming PC", {"side": side})]
+ if number == 6:
+ peers += [(SEA, token(150), "Fedora laptop", {"side": "left", "platform": "linux", "jump_key": "cmd+f18"}),
+ (OAK, token(200), "Studio Mac", {"side": "right", "platform": "macos", "shortcut_cycle": False})]
+ zones = [{"peer": peer[0], "kind": "edge"} for peer in peers]
+ if number == 3:
+ zones = [{"peer": BEE, "kind": "part", "parts": ["start", "end"]}]
+ if number in (4, 7):
+ zones += [{"peer": BEE, "kind": "corner", "corner": "top_left", "edge": "top"}]
+ if number == 5:
+ zones[0]["off"] = True
+ if number == 6:
+ zones = [{"peer": BEE, "kind": "edge"},
+ {"peer": SEA, "kind": "part", "parts": ["middle"]},
+ {"peer": SEA, "kind": "corner", "corner": "bottom_left", "edge": "left"},
+ {"peer": OAK, "kind": "edge"}]
+ theme.init_fonts()
+ with mock.patch.object(theme, "system_dark", return_value=True):
+ control = fixture.build(peers, zones)
+ settings = copy.deepcopy(fixture.store.current())
+ settings["name"] = "Studio MacBook"
+ own = settings["machine_id"]
+ settings["layout"] = {own: dict(x=0, y=0, w=160, h=100)}
+ for peer, _, _, fields in peers:
+ x, y = {"left": (-160, 0), "right": (160, 0), "top": (0, -100)}[fields["side"]]
+ settings["layout"][peer] = dict(x=x, y=y, w=160, h=100)
+ fixture.store.save_settings(settings)
+ control.controller.cfg = fixture.store.load()
+ control._design_peer_caps = lambda: {peer[0]: {"layout"} for peer in peers}
+ control._live = lambda peer: number != 6 or peer != OAK
+ control.key_recorder.set_value("cmd_r")
+ control.has_notch = True
+ control._select_page("crossing")
+ control.window.setFrame_display_(((100000, 100000), (640 if number == 7 else 960, 900)), False)
+ control._load_ways()
+ control._reflect()
+ for _ in range(4):
+ settle(control.window)
+ control.crossing_ledger.reflow()
+ destination = Path(destination)
+ destination.mkdir(parents=True, exist_ok=True)
+ page = control.pages["crossing"].documentView()
+ render(page, 2, destination / f"mac-state-{number}.png")
+ geometry = measure(control, "crossing")
+ assert not control.window.isVisible()
+ assert not control.pages["crossing"].hasHorizontalScroller()
+ assert not geometry["overflows"], geometry["overflows"]
+ assert (control.crossing_ledger.bounds().size.width < 620) == (number == 7)
+ print(f"state {number}: {page.bounds().size.width:g} x {page.bounds().size.height:g} pt, "
+ f"{len(control.crossing_ledger.rows)} rows, ledger {control.crossing_ledger.bounds().size.width:g} pt, "
+ f"{len(geometry['overflows'])} overflows")
+ finally:
+ fixture.doCleanups()
+
+
+if __name__ == "__main__":
+ built_state(int(sys.argv[1]), sys.argv[2])
diff --git a/mac_app/tests/test_appearance_contrast.py b/mac_app/tests/test_appearance_contrast.py
index 43f5643..469a17c 100644
--- a/mac_app/tests/test_appearance_contrast.py
+++ b/mac_app/tests/test_appearance_contrast.py
@@ -286,7 +286,7 @@ class AppearanceContrast(unittest.TestCase):
return checked, cards, failures
def test_every_page_reads_in_dark_and_in_light_chosen_from_another_page(self):
- # Toby's path: the window built dark, Light chosen on the Design page, then every other page.
+ # A user's path: the window built dark, Light chosen on the Design page, then every other page.
self._choose("dark")
self.control._select_page("design")
self._choose("light")
diff --git a/mac_app/tests/test_atlas_canvas.py b/mac_app/tests/test_atlas_canvas.py
new file mode 100644
index 0000000..fe1f379
--- /dev/null
+++ b/mac_app/tests/test_atlas_canvas.py
@@ -0,0 +1,876 @@
+import copy
+import sys
+import unittest
+from pathlib import Path
+from unittest import mock
+from types import SimpleNamespace
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+import AppKit
+import Quartz
+
+AppKit.NSApplication.sharedApplication()
+
+import diagram
+from core import protocol, settings_sync, ways as core_ways
+from test_crossing_page_machines import BEE, OAK, SEA, Page, entry, token
+from wake import WakingController
+
+
+class AtlasCanvas(Page):
+ def setUp(self):
+ super().setUp()
+ capture = mock.patch.object(WakingController, "start_input_capture")
+ capture.start()
+ self.addCleanup(capture.stop)
+
+ def layout(self, bee_x=320, bee_y=100):
+ window = self.build([(BEE, token(100), "Bee", {"side": "right"}),
+ (SEA, token(150), "Sea", {"side": "left"})])
+ window._design_peer_caps = lambda: {BEE: {"settings", "layout"}, SEA: {"settings", "layout"}}
+ window.controller._crossing_known_caps = {BEE: frozenset({"settings", "layout"}),
+ SEA: frozenset({"settings", "layout"})}
+ window.windows_input.server.caps_of.return_value = frozenset({"settings", "layout"})
+ own = self.store.current()["machine_id"]
+ tiles = {own: {"x": 160, "y": 100, "w": 160, "h": 100},
+ BEE: {"x": bee_x, "y": bee_y, "w": 160, "h": 100},
+ SEA: {"x": 160, "y": 200, "w": 160, "h": 100}}
+ window._atlas_layout_changed(tiles, BEE)
+ return window
+
+ def test_drag_drop_compiles_and_saves_the_tile_position(self):
+ window = self.layout(bee_x=0)
+ current = self.store.current()
+ self.assertEqual(current["layout"][BEE], {"x": 0, "y": 100, "w": 160, "h": 100})
+ self.assertEqual(next(peer for peer in current["peers"] if peer["id"] == BEE)["side"], "left")
+
+ def test_overlap_drop_uses_the_engine_snap_and_keeps_the_saved_position(self):
+ window = self.layout()
+ own = self.store.current()["machine_id"]
+ colliding = dict(self.store.current()["layout"])
+ colliding[BEE] = dict(colliding[own])
+ window._atlas_layout_changed(colliding, BEE)
+ saved = self.store.current()["layout"][BEE]
+ self.assertNotEqual(saved, colliding[BEE])
+ self.assertFalse(window.atlas_canvas.tiles[BEE] == colliding[BEE])
+ self.assertEqual(saved, window.atlas_canvas.tiles[BEE])
+
+ def test_unstamped_defaults_still_show_existing_edges(self):
+ window = self.build([(BEE, token(100), "Bee", {"side": "right"})])
+ self.assertEqual(window.atlas_canvas.states[BEE]["state"], "edge")
+
+ def test_disabled_edge_and_corner_are_not_drawn_as_crossings(self):
+ window = self.build([(BEE, token(100), "Bee", {"side": "right"})],
+ [{"peer": BEE, "kind": "edge", "off": True},
+ {"peer": BEE, "kind": "corner", "corner": "top_right", "edge": "right", "off": True}])
+ self.assertFalse(window.atlas_canvas.states[BEE]["crosses"])
+ self.assertEqual(window.atlas_canvas.states[BEE]["state"], "gap")
+ self.assertNotIn((self.store.current()["machine_id"], BEE, "signal"), window.atlas_canvas.contact_layers)
+ self.assertEqual(window.atlas_canvas.outcome_for_tile[BEE].string(), "Edge off")
+ self.assertEqual(core_ways.picked_thirds(core_ways.ways(self.store.current(), BEE)["methods"], []), [])
+
+ def test_tiles_show_the_peer_platform_and_the_mac_uses_its_platform_name(self):
+ window = self.build([(BEE, token(100), "Bee", {"platform": "linux", "side": "right"})])
+ window._live = lambda peer: True
+ window._show_arrangement([])
+ own = self.store.current()["machine_id"]
+ canvas = window.atlas_canvas
+ canvas.setFrame_(((0, 0), (480, canvas.HEIGHT)))
+ canvas._draw(False)
+ self.assertIn(own, canvas.tiles)
+ self.assertEqual(canvas.label_for_tile[own].string(), "This Mac")
+ self.assertIn(own, canvas.display_layers)
+ self.assertEqual(canvas.states[BEE]["platform"], "Linux")
+ self.assertEqual(canvas.state_for_tile[BEE].string(), "Linux · Linked")
+ self.assertTrue(canvas.state_for_tile[own].string().endswith(" · macOS"))
+ self.assertLess(canvas.dot_for_tile[BEE].frame().origin.x,
+ canvas.state_for_tile[BEE].frame().origin.x)
+
+ def test_own_tile_without_a_saved_name_uses_hostname_and_never_says_offline(self):
+ window = self.build([(BEE, token(100), "Bee", {"side": "right"})])
+ own = self.store.current()["machine_id"]
+ canvas = window.atlas_canvas
+ canvas.states[own].pop("machine_name", None)
+ canvas.setFrame_(((0, 0), (480, canvas.HEIGHT)))
+ canvas._draw(False)
+
+ self.assertIn("macOS", canvas.state_for_tile[own].string())
+ self.assertNotIn("Offline", canvas.state_for_tile[own].string())
+
+ def test_own_name_is_above_its_display_layers(self):
+ window = self.build([(BEE, token(100), "Bee", {"side": "right"})])
+ canvas = window.atlas_canvas
+ own = self.store.current()["machine_id"]
+ tiles = dict(canvas.tiles)
+ tiles[own] = {**tiles[own], "displays": {"main": {"x": 0, "y": 0, "w": 1728, "h": 1117}}}
+ canvas.show_layout(tiles, canvas.states, {**canvas.labels, own: "This Mac"}, own, BEE)
+ canvas.setFrame_(((0, 0), (480, canvas.HEIGHT)))
+ canvas._draw(False)
+
+ title = canvas.label_for_tile[own]
+ displays = canvas.display_layers[own]
+ self.assertEqual(title.string(), "This Mac")
+ self.assertTrue(displays)
+ self.assertGreater(title.zPosition(), max(layer.zPosition() for layer in displays))
+
+ def test_selected_machine_name_uses_tail_elision_and_keeps_full_accessible_text_at_320(self):
+ full_name = "M" * 60
+ window = self.build([(BEE, token(100), "Bee", {"side": "right"})],
+ [{"peer": BEE, "kind": "edge"}])
+ settings = self.store.current()
+ settings["peers"][0]["name"] = full_name
+ self.store.save_settings(settings)
+ window._show_arrangement([])
+ label = window.crossing_ledger.rows[BEE].name.view
+ label.setFrameSize_((320, label.frame().size.height))
+ attributed = label.attributedStringValue()
+ paragraph = attributed.attribute_atIndex_effectiveRange_(
+ AppKit.NSParagraphStyleAttributeName, 0, None
+ )[0]
+ with self.subTest("320 pt machine name uses tail elision"):
+ self.assertEqual(label.frame().size.width, 320)
+ self.assertEqual(paragraph.lineBreakMode(), AppKit.NSLineBreakByTruncatingTail)
+ with self.subTest("full name remains available"):
+ self.assertEqual(label.toolTip(), full_name)
+ self.assertEqual(label.accessibilityLabel(), full_name)
+
+ def test_fresh_edge_way_is_visible_and_tracks_the_saved_zone(self):
+ window = self.build([(BEE, token(100), "Bee", {"side": "right"})],
+ [{"peer": BEE, "kind": "edge"},
+ {"peer": BEE, "kind": "edge", "display": "main", "side": "right",
+ "target_side": "left"}])
+ own = self.store.current()["machine_id"]
+ settings = self.store.current()
+ settings["layout"][own] = {"x": 160, "y": 100, "w": 160, "h": 100,
+ "displays": {"main": {"x": 0, "y": 0, "w": 160, "h": 100}}}
+ settings["layout"][BEE] = {"x": 320, "y": 100, "w": 160, "h": 100,
+ "displays": {"main": {"x": 0, "y": 0, "w": 160, "h": 100}}}
+ self.store.save_settings(settings)
+ window.windows_input.server.links.return_value = []
+ window._load_ways()
+ window._show_arrangement([])
+ canvas = window.atlas_canvas
+ canvas.setFrame_(((0, 0), (480, canvas.HEIGHT)))
+ canvas._draw(False)
+
+ self.assertIn("edge", core_ways.ways(self.store.current(), BEE)["methods"])
+ signal = canvas.contact_layers[(own, BEE, "signal")]
+ self.assertIsNotNone(signal)
+ import theme
+ self.assertTrue(Quartz.CGColorEqualToColor(signal.strokeColor(), theme.cg("signal")))
+ self.assertEqual(signal.lineWidth(), 4)
+ self.assertEqual(signal.lineCap(), Quartz.kCALineCapRound)
+ frames, _scale = canvas._map()
+ seam = Quartz.CGPathGetBoundingBox(signal.path())
+ own_frame, peer_frame = frames[own], frames[BEE]
+ self.assertAlmostEqual(seam.origin.x, own_frame[0] + own_frame[2])
+ self.assertAlmostEqual(seam.origin.y, peer_frame[1] + 2)
+ self.assertAlmostEqual(seam.size.height, peer_frame[3] - 4)
+ self.assertGreater(signal.zPosition(), canvas.layer_for_tile[own].zPosition())
+ self.assertGreater(signal.zPosition(), canvas.layer_for_tile[BEE].zPosition())
+ self.assertEqual(canvas.outcome_for_tile[BEE].string(), "Offline")
+ for layer in (canvas.state_for_tile[BEE], canvas.outcome_for_tile[BEE],
+ canvas.dot_for_tile[BEE], canvas.cycle_for_tile[BEE]):
+ self.assertGreater(layer.zPosition(), max(item.zPosition() for item in canvas.display_layers[BEE]))
+ self.assertEqual(canvas.state_for_tile[BEE].string(), "Windows · Offline")
+ window._ledger_edge(BEE)
+ self.assertFalse(core_ways.has_way(self.store.current(), BEE))
+ self.assertFalse(core_ways.crosses_on_map(self.store.current(), BEE))
+ self.assertFalse(any(zone.get("peer") == BEE and zone.get("kind") in ("edge", "part")
+ for zone in self.store.current()["zones"]))
+ self.assertNotIn((own, BEE, "signal"), canvas.contact_layers)
+ self.assertTrue(canvas.states[BEE]["edge_off"])
+ self.assertEqual(canvas.outcome_for_tile[BEE].string(), "Offline")
+ window._atlas_layout_changed(self.store.current()["layout"], BEE)
+ self.assertFalse(core_ways.crosses_on_map(self.store.current(), BEE))
+ self.assertEqual(canvas.outcome_for_tile[BEE].string(), "Offline")
+ window._ledger_edge(BEE)
+ self.assertTrue(core_ways.has_way(self.store.current(), BEE))
+ self.assertIn((own, BEE, "signal"), canvas.contact_layers)
+
+ def test_gap_tile_edge_edit_waits_for_contact_without_moving_the_tile(self):
+ window = self.build([(BEE, token(100), "Bee", {"side": "right"})],
+ [{"peer": BEE, "kind": "edge", "off": True}])
+ settings = self.store.current()
+ own = settings["machine_id"]
+ settings["layout"] = {own: {"x": 160, "y": 100, "w": 160, "h": 100},
+ BEE: {"x": 600, "y": 400, "w": 160, "h": 100}}
+ self.store.save_settings(settings)
+ window._load_ways()
+ window._reflect()
+ self.assertEqual(window.atlas_canvas.states[BEE]["state"], "gap")
+ window._ledger_edge(BEE)
+
+ current = self.store.current()
+ self.assertEqual(current["layout"][BEE], {"x": 600, "y": 400, "w": 160, "h": 100})
+ self.assertFalse(core_ways.has_way(current, BEE))
+ self.assertNotIn((own, BEE, "signal"), window.atlas_canvas.contact_layers)
+
+ def test_corner_contact_does_not_move_the_tile_when_edge_text_is_clicked(self):
+ window = self.build([(BEE, token(100), "Bee", {"side": "right"})],
+ [{"peer": BEE, "kind": "edge", "off": True}])
+ settings = self.store.current()
+ own = settings["machine_id"]
+ settings["layout"] = {own: {"x": 160, "y": 100, "w": 160, "h": 100},
+ BEE: {"x": 320, "y": 200, "w": 160, "h": 100}}
+ self.store.save_settings(settings)
+ window._load_ways()
+ window._reflect()
+
+ window._ledger_edge(BEE)
+
+ self.assertEqual(self.store.current()["layout"][BEE], {"x": 320, "y": 200, "w": 160, "h": 100})
+
+ def test_edge_way_tick_covers_part_zones_and_turns_them_off(self):
+ window = self.build([(BEE, token(100), "Bee", {"side": "right"})],
+ [{"peer": BEE, "kind": "part", "parts": ["start"]}])
+ window._load_ways()
+
+ self.assertIn("part", core_ways.ways(self.store.current(), BEE)["methods"])
+ window._ledger_edge(BEE)
+ self.assertFalse(core_ways.has_way(self.store.current(), BEE))
+
+ def test_received_layout_refreshes_the_edge_sentence_from_compiled_zones(self):
+ window = self.build([(BEE, token(100), "Bee", {"side": "right"})],
+ [{"peer": BEE, "kind": "edge", "off": True}])
+ settings = self.store.current()
+ own = settings["machine_id"]
+ settings["layout"][own] = {"x": 160, "y": 100, "w": 160, "h": 100}
+ settings["layout"][BEE] = {"x": 500, "y": 100, "w": 160, "h": 100}
+ self.store.save_settings(settings)
+ window._design_peer_caps = lambda: {BEE: {"settings", "layout"}}
+ incoming = dict(settings["layout"])
+ incoming[BEE] = {"x": 320, "y": 100, "w": 160, "h": 100}
+ data = settings_sync.message_data(False, 0, by=own,
+ layout_state={"set_at": settings["layout_set_at"] + 1, "by": BEE, "tiles": incoming})
+
+ with mock.patch.object(window, "refresh"):
+ self.assertTrue(window._receive_layout(data, BEE))
+
+ self.assertNotIn("edge", core_ways.ways(self.store.current(), BEE)["methods"])
+ window._show_arrangement()
+ self.assertTrue(window.atlas_canvas.states[BEE]["edge_off"])
+
+ def test_tile_outcome_invites_connection_without_old_set_elsewhere_label(self):
+ self.assertEqual(diagram.outcome_for_tile("gap", False), "Drag to connect")
+ self.assertEqual(diagram.outcome_for_tile("set-elsewhere", False), "Drag to connect")
+ self.assertEqual(diagram.outcome_for_tile("between", True), "Drag to connect")
+
+ def test_crossing_page_omits_the_old_picker_and_current_chain(self):
+ window = self.layout()
+ for name in ("machine_row", "route_note", "ways_heading", "atlas_shelf", "atlas_inspector"):
+ self.assertFalse(hasattr(window, name), name)
+ self.assertEqual(window.crossing_ledger.accessibilityRole(), AppKit.NSAccessibilityTableRole)
+
+ def test_atlas_places_hint_legend_and_ledger_in_order(self):
+ window = self.layout()
+ arranged = list(window.atlas_legend.superview().arrangedSubviews())
+ self.assertLess(arranged.index(window.atlas_canvas), arranged.index(window.atlas_canvas_hint.view))
+ self.assertLess(arranged.index(window.atlas_canvas_hint.view), arranged.index(window.atlas_legend))
+ self.assertLess(arranged.index(window.atlas_legend), arranged.index(window.crossing_ledger))
+
+ def test_left_out_ledger_row_has_status_and_named_put_back_action(self):
+ window = self.build([(BEE, token(100), "Bee", {"left_out": True})])
+ row = window.crossing_ledger.rows[BEE]
+ self.assertEqual(row.name.view.stringValue(), "Bee")
+ self.assertEqual(row.status_text, "Windows · Left out")
+ button = row.leave
+ self.assertEqual(button.title(), "Put back")
+ self.assertEqual(button.accessibilityLabel(), "Put back Bee")
+ button.performClick_(None)
+ peer = next(entry for entry in self.store.current()["peers"] if entry["id"] == BEE)
+ self.assertFalse(peer.get("left_out", False))
+
+ def test_put_back_tooltip_and_shortcut_cycle_note_use_mac_wording(self):
+ window = self.layout()
+ window._set_atlas_left_out(BEE, True)
+ self.assertEqual(window.crossing_ledger.rows[BEE].leave.toolTip(),
+ "Left out machines stay paired and linked. The shortcut, menu and clipboard still reach them.")
+ window.shortcut_goes_to._choose("next")
+ self.assertIn("This Mac is always in the cycle.", window.shortcut_cycle_note.view.stringValue())
+ self.assertNotIn("Home is always in the cycle", window.shortcut_cycle_note.view.stringValue())
+
+ def test_not_in_use_ledger_put_back_uses_the_machine_direction_handler(self):
+ for left_out in (False, True):
+ with self.subTest(left_out=left_out):
+ window = self.build([(BEE, token(100), "Bee", {"in_use": False, "left_out": left_out})])
+ window.direction_handler = mock.Mock()
+ row = window.crossing_ledger.rows[BEE]
+ row.leave.performClick_(None)
+ window.direction_handler.assert_called_once_with(token(100), in_use=True)
+
+ def test_left_out_ledger_machine_can_be_excluded_from_the_shortcut_cycle(self):
+ window = self.layout()
+ window.shortcut_goes_to._choose("ticked")
+ window._set_atlas_left_out(BEE, True)
+ tick = window.crossing_ledger.rows[BEE].cycle
+ self.assertEqual(tick.state(), AppKit.NSControlStateValueOn)
+ tick.performClick_(None)
+ peer = next(peer for peer in self.store.current()["peers"] if peer["id"] == BEE)
+ self.assertFalse(peer["shortcut_cycle"])
+ self.assertNotIn(BEE, window.controller._shortcut_cycle())
+
+ def test_machine_list_row_can_exclude_a_left_out_machine_from_the_cycle(self):
+ window = self.layout()
+ window.shortcut_goes_to._choose("ticked")
+ window._set_atlas_left_out(BEE, True)
+ window.panel.refresh()
+ tick = window.panel._cycle_controls[token(100)]
+ tick.view.accessibilityPerformPress()
+ peer = next(peer for peer in self.store.current()["peers"] if peer["id"] == BEE)
+ self.assertFalse(peer["shortcut_cycle"])
+
+ def test_gap_machine_follows_visible_contacts_in_the_shortcut_cycle(self):
+ window = self.layout()
+ tiles = dict(window.atlas_canvas.tiles)
+ tiles[BEE] = {"x": 480, "y": 100, "w": 160, "h": 100}
+ window._atlas_layout_changed(tiles, BEE, snap=False)
+ self.assertEqual(window.controller._shortcut_cycle(), [SEA, BEE, None])
+
+ def test_distant_tile_with_a_notch_way_still_follows_placed_tiles(self):
+ window = self.layout()
+ tiles = dict(window.atlas_canvas.tiles)
+ tiles[BEE] = {"x": 480, "y": 100, "w": 160, "h": 100}
+ window._atlas_layout_changed(tiles, BEE, snap=False)
+ settings = self.store.current()
+ settings["zones"].append({"peer": BEE, "kind": "notch"})
+ self.store.save_settings(settings)
+ window._show_arrangement([])
+ self.assertEqual(window.atlas_canvas.states[BEE]["state"], "gap")
+ self.assertEqual(window.controller._shortcut_cycle(), [SEA, BEE, None])
+
+ def test_moving_a_tile_keeps_an_inactive_machine_position_and_ways(self):
+ window = self.layout()
+ settings = self.store.current()
+ original = dict(settings["layout"][SEA])
+ next(peer for peer in settings["peers"] if peer["id"] == SEA)["in_use"] = False
+ original_ways = copy.deepcopy(next(peer for peer in settings["peers"] if peer["id"] == SEA)["ways"])
+ self.store.save_settings(settings)
+ window._show_arrangement([])
+ tiles = dict(window.atlas_canvas.tiles)
+ tiles[BEE] = {"x": 0, "y": 100, "w": 160, "h": 100}
+ window._atlas_layout_changed(tiles, BEE, snap=False)
+ current = self.store.current()
+ self.assertEqual(current["layout"].get(SEA), original)
+ self.assertEqual(next(peer for peer in current["peers"] if peer["id"] == SEA)["ways"], original_ways)
+ self.assertFalse(any(zone["peer"] == SEA for zone in current["zones"]))
+
+ def test_incoming_layout_accepts_inactive_position_and_keeps_its_ways(self):
+ window = self.layout()
+ settings = self.store.current()
+ own = settings["machine_id"]
+ next(peer for peer in settings["peers"] if peer["id"] == SEA)["in_use"] = False
+ foreign = protocol.id_text(bytes(range(110, 126)))
+ next(peer for peer in settings["peers"] if peer["id"] == BEE)["paired_with"] = [foreign]
+ original = copy.deepcopy(settings)
+ self.store.save_settings(settings)
+ window._design_peer_caps = lambda: {BEE: {"settings", "layout"}}
+ incoming = copy.deepcopy(settings["layout"])
+ incoming[BEE] = {"x": 0, "y": 100, "w": 160, "h": 100}
+ incoming[SEA] = {"x": 320, "y": 100, "w": 160, "h": 100}
+ incoming[foreign] = {"x": 500, "y": 100, "w": 160, "h": 100, "name": "Test box"}
+ state = {"tiles": incoming, "set_at": settings["layout_set_at"] + 1, "by": BEE}
+ data = settings_sync.message_data(False, 0, by=own, layout_state=state)
+ with mock.patch.object(window, "refresh"):
+ self.assertTrue(window._receive_layout(data, BEE))
+ current = self.store.current()
+ self.assertEqual(current["layout"][SEA], incoming[SEA])
+ self.assertEqual(next(peer for peer in current["peers"] if peer["id"] == SEA)["ways"],
+ next(peer for peer in original["peers"] if peer["id"] == SEA)["ways"])
+ self.assertFalse(any(zone["peer"] == SEA for zone in current["zones"]))
+ self.assertNotIn("vouched_by", current["layout"][foreign])
+ self.assertEqual(window.controller.cfg, self.store.load())
+
+ def test_incoming_layout_keeps_a_named_third_party_from_the_current_paired_list(self):
+ window = self.layout()
+ settings = self.store.current()
+ own = settings["machine_id"]
+ fedora = protocol.id_text(bytes(range(110, 126)))
+ next(peer for peer in settings["peers"] if peer["id"] == BEE)["paired_with"] = [fedora]
+ settings["layout"][fedora] = {"x": 500, "y": 100, "w": 160, "h": 100, "name": "Test box"}
+ self.store.save_settings(settings)
+ incoming = {own: dict(settings["layout"][own]), BEE: dict(settings["layout"][BEE])}
+ data = settings_sync.message_data(False, 0, by=own,
+ layout_state={"set_at": settings["layout_set_at"] + 1, "by": BEE, "tiles": incoming})
+ window._design_peer_caps = lambda: {BEE: {"settings", "layout"}}
+
+ with mock.patch.object(window, "refresh"):
+ self.assertTrue(window._receive_layout(data, BEE))
+
+ self.assertEqual(self.store.current()["layout"][fedora], settings["layout"][fedora])
+
+ def test_crossing_map_drops_the_rc7_ghost_tile_reproduction(self):
+ window = self.build([(BEE, token(100), "Desk PC", {"left_out": True,
+ "paired_with": ["PHONE", "BOX"]}),
+ (SEA, token(150), "Laptop", {"paired_with": ["OLDPC"]})])
+ settings = self.store.current()
+ own = settings["machine_id"]
+ phone, box, old_pc = (protocol.id_text(bytes([value]) * 16) for value in (11, 12, 13))
+ next(peer for peer in settings["peers"] if peer["id"] == BEE)["paired_with"] = [phone, box]
+ next(peer for peer in settings["peers"] if peer["id"] == SEA)["paired_with"] = [old_pc]
+ settings["peers"].append({"id": phone, "name": "Phone", "port": 0, "in_use": True})
+ settings["layout"].update({
+ phone: {"x": 480, "y": 100, "w": 160, "h": 100, "vouched_by": BEE},
+ box: {"x": 640, "y": 100, "w": 160, "h": 100, "vouched_by": BEE},
+ old_pc: {"x": 800, "y": 100, "w": 160, "h": 100, "vouched_by": SEA},
+ })
+ self.store.save_settings(settings)
+ incoming = copy.deepcopy(settings["layout"])
+ data = settings_sync.message_data(False, 0, by=own,
+ layout_state={"set_at": self.store.current()["layout_set_at"] + 1, "by": SEA, "tiles": incoming})
+ window._design_peer_caps = lambda: {SEA: {"settings", "layout"}}
+
+ with mock.patch.object(window, "refresh"):
+ self.assertTrue(window._receive_layout(data, SEA))
+ window._show_arrangement([])
+
+ self.assertTrue({phone, box, old_pc}.isdisjoint(window.atlas_canvas.tiles))
+
+ def test_shortcut_destination_labels_fit_without_wrapping(self):
+ window = self.layout()
+ window._select_page("crossing")
+ control = window.shortcut_goes_to
+ window.window.contentView().layoutSubtreeIfNeeded()
+ for _value, cell, words in control.cells:
+ self.assertGreaterEqual(cell.frame().size.width, words.view.intrinsicContentSize().width + 8)
+
+ def test_canvas_focus_ring_follows_keyboard_navigation_and_leaves_with_focus(self):
+ window = self.layout()
+ window._select_page("crossing")
+ window.window.keyboard_navigation = True
+ window.window.makeFirstResponder_(window.atlas_canvas)
+ window.window.refresh_input_focus()
+ self.assertFalse(window.atlas_canvas.focus_layer.isHidden())
+ window.window.makeFirstResponder_(window.crossing_ledger.rows[BEE].name_field)
+ self.assertTrue(window.atlas_canvas.focus_layer.isHidden())
+
+ def test_in_use_and_not_in_use_are_carried_into_the_tile_state(self):
+ window = self.build([(BEE, token(100), "Bee", {"side": "right", "in_use": True}),
+ (SEA, token(150), "Sea", {"side": "left", "in_use": False})])
+ self.assertTrue(window.atlas_canvas.states[BEE]["in_use"])
+ self.assertFalse(window.atlas_canvas.states[SEA]["in_use"])
+
+ def test_stamped_layout_adds_a_tile_for_a_new_peer(self):
+ window = self.layout()
+ settings = self.store.current()
+ settings["peers"].append(entry(OAK, token(200), "Oak", own=settings["machine_id"]))
+ self.store.save_settings(settings)
+ window._show_arrangement([])
+ self.assertIn(OAK, window.atlas_canvas.tiles)
+
+ def test_arrow_key_moves_one_third_and_announces_the_move(self):
+ window = self.layout()
+ canvas = window.atlas_canvas
+ before = canvas.tiles[BEE]["x"]
+ event = mock.Mock()
+ event.keyCode.return_value = 124
+ event.modifierFlags.return_value = 0
+ canvas.keyDown_(event)
+ self.assertEqual(canvas.tiles[BEE]["x"], before + 53)
+ self.assertEqual(canvas.accessibilityLabel(), "Bee, right of This Mac. Drag to connect.")
+
+ def test_rename_action_uses_the_existing_peer_rename_path(self):
+ window = self.layout()
+ window._begin_atlas_rename(BEE)
+ field = window.crossing_ledger.rows[BEE].name_field
+ self.assertFalse(field.isHidden())
+ window.window.contentView().layoutSubtreeIfNeeded()
+ self.assertFalse(field.isHidden())
+ window._apply_appearance("dark")
+ view = window.window.contentView()
+ rep = view.bitmapImageRepForCachingDisplayInRect_(view.bounds())
+ view.cacheDisplayInRect_toBitmapImageRep_(view.bounds(), rep)
+ self.assertFalse(field.isHidden())
+ field.setStringValue_("Studio PC")
+ window.control_textView_doCommandBySelector_(field, None, "insertNewline:")
+ peer = next(peer for peer in self.store.current()["peers"] if peer["id"] == BEE)
+ self.assertEqual(peer["label"], "Studio PC")
+
+ def test_rename_stays_open_when_the_resized_page_has_not_laid_out(self):
+ window = self.two()
+ window._select_page("crossing")
+ window.window.setContentSize_((1040, 900))
+ window._begin_atlas_rename(BEE)
+ row = window.crossing_ledger.rows[BEE]
+ self.assertTrue(row.renaming)
+ self.assertFalse(row.name_field.isHidden())
+ cell = row.cells["machine"]
+ self.assertLessEqual(row.name_field.frame().origin.x + row.name_field.frame().size.width,
+ cell.bounds().size.width)
+
+ def test_leave_out_and_put_back_restore_the_machine_ways(self):
+ window = self.layout()
+ window._set_atlas_left_out(BEE, True)
+ peer = next(peer for peer in self.store.current()["peers"] if peer["id"] == BEE)
+ self.assertTrue(peer["left_out"])
+ self.assertNotIn(BEE, window.atlas_canvas.tiles)
+ self.assertEqual(window.chosen_peer, BEE)
+ window._set_atlas_left_out(BEE, False)
+ peer = next(peer for peer in self.store.current()["peers"] if peer["id"] == BEE)
+ self.assertNotIn("left_out", peer)
+ self.assertIn(BEE, window.atlas_canvas.tiles)
+
+ def test_shortcut_mode_and_cycle_ticks_are_saved(self):
+ window = self.layout()
+ window.shortcut_goes_to._choose("ticked")
+ window.atlas_canvas.toggle_cycle(BEE)
+ window._apply_settings()
+ self.assertEqual(self.store.current()["crossing"]["shortcut_goes_to"], "ticked")
+ peer = next(peer for peer in self.store.current()["peers"] if peer["id"] == BEE)
+ self.assertFalse(peer["shortcut_cycle"])
+
+ def test_dragging_this_mac_never_changes_its_tile_or_compiles_a_layout(self):
+ window = self.layout()
+ canvas = window.atlas_canvas
+ own = self.store.current()["machine_id"]
+ before = dict(canvas.tiles[own])
+ callback = mock.Mock()
+ canvas.on_layout_change = callback
+ canvas.window = mock.Mock()
+ canvas.convertPoint_fromView_ = mock.Mock(return_value=AppKit.NSMakePoint(10, 10))
+ canvas.tile_at = mock.Mock(return_value=own)
+ event = mock.Mock()
+ event.locationInWindow.return_value = AppKit.NSMakePoint(10, 10)
+ event.clickCount.return_value = 1
+ canvas.mouseDown_(event)
+ canvas.mouseDragged_(event)
+ canvas.mouseUp_(event)
+ self.assertEqual(canvas.tiles[own], before)
+ callback.assert_not_called()
+
+ def test_snap_tolerance_stays_twelve_visible_pixels_at_half_scale(self):
+ self.assertEqual(diagram.AtlasCanvas.snap_radius_for_scale(0.5), 24)
+
+ def test_arrangement_box_centres_and_refits_after_a_peer_moves(self):
+ window = self.layout()
+ canvas = window.atlas_canvas
+ canvas.setFrame_(((0, 0), (480, canvas.HEIGHT)))
+ def box():
+ frames, _scale = canvas._map()
+ return (min(frame[0] for frame in frames.values()), min(frame[1] for frame in frames.values()),
+ max(frame[0] + frame[2] for frame in frames.values()),
+ max(frame[1] + frame[3] for frame in frames.values()))
+
+ before = box()
+ self.assertAlmostEqual((before[0]+before[2])/2, 240)
+ self.assertAlmostEqual((before[1]+before[3])/2, canvas.HEIGHT/2)
+ before_scale = canvas._map()[1]
+ canvas.tiles[BEE] = {**canvas.tiles[BEE], "x": 520, "y": 180}
+ after = box()
+ scale = canvas._map()[1]
+ self.assertNotEqual(after, before)
+ self.assertAlmostEqual((after[0]+after[2])/2, 240)
+ self.assertAlmostEqual((after[1]+after[3])/2, canvas.HEIGHT/2)
+ self.assertNotEqual(scale, before_scale)
+
+ def test_fit_centres_a_column_when_this_mac_is_at_one_end(self):
+ window = self.layout()
+ canvas = window.atlas_canvas
+ canvas.setFrame_(((0, 0), (480, canvas.HEIGHT)))
+ own = canvas.own_id
+ canvas.tiles[own] = {**canvas.tiles[own], "x": 0, "y": 0}
+ canvas.tiles[BEE] = {**canvas.tiles[BEE], "x": 0, "y": 100}
+ canvas.tiles[SEA] = {**canvas.tiles[SEA], "x": 0, "y": 200}
+ frames, scale = canvas._map()
+ left = min(frame[0] for frame in frames.values())
+ top = min(frame[1] for frame in frames.values())
+ right = max(frame[0] + frame[2] for frame in frames.values())
+ bottom = max(frame[1] + frame[3] for frame in frames.values())
+ expected = min((480-2*canvas.INSET)/160, (canvas.HEIGHT-2*canvas.INSET)/300, 1.15)
+ self.assertAlmostEqual(scale, expected)
+ self.assertAlmostEqual((left+right)/2, 240)
+ self.assertAlmostEqual((top+bottom)/2, canvas.HEIGHT/2)
+
+ def test_map_fit_includes_split_display_offsets(self):
+ window = self.layout()
+ canvas = window.atlas_canvas
+ canvas.setFrame_(((0, 0), (480, canvas.HEIGHT)))
+ base_scale = canvas._map()[1]
+ canvas.tiles[BEE] = {**canvas.tiles[BEE],
+ "displays": {"main": {"x": 0, "y": 0, "w": 160, "h": 100}},
+ "display_offsets": {"main": {"x": 400, "y": 0}}}
+
+ self.assertLess(canvas._map()[1], base_scale)
+
+ def test_small_tiles_hide_detail_and_centre_the_title(self):
+ window = self.layout()
+ canvas = window.atlas_canvas
+ canvas.setFrame_(((0, 0), (480, canvas.HEIGHT)))
+ canvas.tiles[BEE] = {**canvas.tiles[BEE], "y": 1000}
+ canvas._draw(False)
+ frame = canvas._map()[0][BEE]
+
+ self.assertLess(frame[3], 56)
+ self.assertTrue(canvas.state_for_tile[BEE].isHidden())
+ self.assertTrue(canvas.dot_for_tile[BEE].isHidden())
+ self.assertTrue(canvas.outcome_for_tile[BEE].isHidden())
+ title = canvas.label_for_tile[BEE].frame()
+ self.assertAlmostEqual(title.origin.y + title.size.height / 2,
+ frame[1] + frame[3] / 2)
+
+ def test_edge_seam_lights_the_whole_contact_and_part_only_the_picked_thirds(self):
+ window = self.layout()
+ canvas = window.atlas_canvas
+ canvas.setFrame_(((0, 0), (480, canvas.HEIGHT)))
+ own = canvas.own_id
+ canvas.tiles[own] = {**canvas.tiles[own], "x": 0, "y": 0, "w": 160, "h": 90}
+ canvas.tiles[BEE] = {**canvas.tiles[BEE], "x": 160, "y": 20, "w": 160, "h": 90}
+ frames, scale = canvas._map()
+
+ def lit_height(lit):
+ canvas.states[BEE] = {**canvas.states.get(BEE, {}), "state": "edge", "crosses": True,
+ "thirds": ["middle", "end"], "lit_thirds": lit}
+ canvas._draw(False)
+ box = Quartz.CGPathGetBoundingBox(canvas.contact_layers[(own, BEE, "signal")].path())
+ return box.size.height / scale
+
+ self.assertAlmostEqual(lit_height([]), 70 - 4 / scale, delta=1)
+ # The selected machine's seam starts half the break gap plus its round cap after the third boundary.
+ self.assertAlmostEqual(lit_height(["end"]), 30 - (2 + diagram.THIRD_GAP / 2 + 2) / scale, delta=1)
+
+ def test_display_drag_keeps_its_map_transform_frozen(self):
+ window = self.layout()
+ canvas = window.atlas_canvas
+ canvas.setFrame_(((0, 0), (480, canvas.HEIGHT)))
+ canvas.tiles[BEE] = {**canvas.tiles[BEE],
+ "displays": {"main": {"x": 0, "y": 0, "w": 160, "h": 100}}}
+ frames, scale = canvas._map()
+ canvas.display_at = mock.Mock(return_value=(BEE, "main"))
+ canvas.window = mock.Mock()
+ canvas.convertPoint_fromView_ = mock.Mock(return_value=AppKit.NSMakePoint(10, 10))
+ event = mock.Mock()
+ event.locationInWindow.return_value = AppKit.NSMakePoint(10, 10)
+ event.clickCount.return_value = 1
+ event.modifierFlags.return_value = AppKit.NSEventModifierFlagOption
+
+ with mock.patch.object(diagram.AppKit, "NSCursor"):
+ canvas.mouseDown_(event)
+
+ self.assertEqual(canvas.dragging["map_x"], frames[canvas.own_id][0]
+ - canvas.tiles[canvas.own_id]["x"] * scale)
+ self.assertEqual(canvas.dragging["map_y"], frames[canvas.own_id][1]
+ - canvas.tiles[canvas.own_id]["y"] * scale)
+ self.assertEqual(canvas.dragging["scale"], scale)
+ own_frame = canvas._map()[0][canvas.own_id]
+ canvas.tiles[BEE] = {**canvas.tiles[BEE], "x": 1000}
+ self.assertEqual(canvas._map()[0][canvas.own_id], own_frame)
+
+ def test_selection_relayout_does_not_change_either_drag_transform(self):
+ for display in (None, "main"):
+ with self.subTest(display=display):
+ window = self.layout()
+ canvas = window.atlas_canvas
+ canvas.setFrame_(((0, 0), (480, canvas.HEIGHT)))
+ canvas.tiles[BEE] = {**canvas.tiles[BEE],
+ "displays": {"main": {"x": 0, "y": 0, "w": 160, "h": 100}}}
+ frames, scale = canvas._map()
+ own_frame = frames[canvas.own_id]
+ left = min(frame[0] for frame in frames.values())
+ right = max(frame[0] + frame[2] for frame in frames.values())
+ self.assertAlmostEqual((left+right)/2, 240)
+ canvas.on_select = lambda _key: canvas.setFrame_(((0, 0), (560, canvas.HEIGHT)))
+ canvas.display_at = mock.Mock(return_value=(BEE, display))
+ canvas.window = mock.Mock()
+ canvas.convertPoint_fromView_ = mock.Mock(return_value=AppKit.NSMakePoint(10, 10))
+ event = mock.Mock()
+ event.locationInWindow.return_value = AppKit.NSMakePoint(10, 10)
+ event.clickCount.return_value = 1
+ event.modifierFlags.return_value = AppKit.NSEventModifierFlagOption
+
+ with mock.patch.object(diagram.AppKit, "NSCursor"):
+ canvas.mouseDown_(event)
+
+ self.assertEqual(canvas.dragging["scale"], scale)
+ self.assertEqual(canvas._map()[0][canvas.own_id], own_frame)
+ canvas.tiles[BEE] = {**canvas.tiles[BEE], "x": 1000, "y": -500}
+ self.assertEqual(canvas._map()[0][canvas.own_id], own_frame)
+
+ def test_selected_and_own_tile_borders_use_neutral_roles(self):
+ window = self.layout()
+ canvas = window.atlas_canvas
+ canvas.setFrame_(((0, 0), (480, canvas.HEIGHT)))
+ canvas.selected = BEE
+ canvas.hovered = BEE
+ with mock.patch.object(diagram.theme, "tint", wraps=diagram.theme.tint) as tint:
+ canvas._draw(False)
+ for key, role, width in ((BEE, "ink_2", 2), (canvas.own_id, "edge", 1)):
+ tile = canvas.layer_for_tile[key]
+ call = next(call for call in tint.call_args_list if call.args[0] is tile)
+ self.assertEqual(call.kwargs["border"], role)
+ self.assertNotEqual(call.kwargs["border"], "signal")
+ self.assertEqual(tile.borderWidth(), width)
+ self.assertTrue(Quartz.CGColorEqualToColor(canvas.layer_for_tile[canvas.own_id].backgroundColor(),
+ diagram.theme.cg("well")))
+
+ def test_corner_crossing_uses_square_pad_without_contact_dot(self):
+ window = self.layout(bee_x=320, bee_y=0)
+ canvas = window.atlas_canvas
+ canvas.setFrame_(((0, 0), (480, canvas.HEIGHT)))
+ canvas.states[BEE] = {"state": "corner", "crosses": True, "corner_way": "top_right"}
+ canvas._draw(False)
+ self.assertNotIn((canvas.own_id, BEE, "signal"), canvas.contact_layers)
+ pad = canvas.mark_layers[(BEE, "corner", "top_right")]
+ bounds = Quartz.CGPathGetBoundingBox(pad.path())
+ self.assertEqual((bounds.size.width, bounds.size.height), (16, 16))
+
+ def test_recentre_places_selected_peer_and_commits_once(self):
+ window = self.layout()
+ canvas = window.atlas_canvas
+ own = canvas.tiles[canvas.own_id]
+ canvas.tiles[BEE] = {**canvas.tiles[BEE], "x": own["x"] + own["w"] + 24, "y": own["y"] + 18}
+ canvas.selected = BEE
+ callback = mock.Mock()
+ canvas.on_layout_change = callback
+
+ self.assertTrue(canvas.recentre_selected())
+
+ peer = canvas.tiles[BEE]
+ self.assertEqual(peer["x"], own["x"] + own["w"])
+ self.assertEqual(peer["y"], own["y"] + (own["h"] - peer["h"]) / 2)
+ callback.assert_called_once_with(canvas.tiles, BEE, snap=False)
+
+ def test_snap_preview_appears_only_inside_snap_radius(self):
+ window = self.layout()
+ canvas = window.atlas_canvas
+ canvas.setFrame_(((0, 0), (480, canvas.HEIGHT)))
+ frames, scale = canvas._map()
+ own = canvas.tiles[canvas.own_id]
+ canvas.dragging = {"key": BEE, "scale": scale,
+ "map_x": frames[canvas.own_id][0] - own["x"] * scale,
+ "map_y": frames[canvas.own_id][1] - own["y"] * scale}
+ canvas.tiles[BEE] = {**canvas.tiles[BEE], "y": own["y"] + 5}
+ self.assertEqual(canvas.snap_preview()["y"], canvas.tiles[canvas.own_id]["y"])
+ canvas.tiles[BEE] = {**canvas.tiles[BEE], "x": own["x"] + own["w"]
+ + round(3 * canvas.snap_radius_for_scale(scale))}
+ self.assertIsNone(canvas.snap_preview())
+
+ def test_release_commits_a_centre_snap_between_base_and_extended_radius(self):
+ window = self.layout()
+ canvas = window.atlas_canvas
+ canvas.setFrame_(((0, 0), (480, canvas.HEIGHT)))
+ frames, scale = canvas._map()
+ own = canvas.tiles[canvas.own_id]
+ radius = canvas.snap_radius_for_scale(scale)
+ distance = round(radius * 1.25)
+ canvas.tiles[BEE] = {**canvas.tiles[BEE], "x": own["x"] + own["w"] + distance, "y": own["y"]}
+ self.assertGreater(distance, radius)
+ self.assertLessEqual(distance, radius * 1.5)
+ canvas.dragging = {"key": BEE, "moved": True, "scale": scale,
+ "map_x": frames[canvas.own_id][0] - own["x"] * scale,
+ "map_y": frames[canvas.own_id][1] - own["y"] * scale}
+ self.assertEqual(canvas.snap_preview(), {**canvas.tiles[BEE], "x": own["x"] + own["w"]})
+ callback = mock.Mock()
+ canvas.on_layout_change = callback
+ canvas.window = mock.Mock()
+ canvas.convertPoint_fromView_ = mock.Mock(return_value=AppKit.NSMakePoint(10, 10))
+ event = mock.Mock()
+ event.locationInWindow.return_value = AppKit.NSMakePoint(10, 10)
+
+ with mock.patch.object(diagram.AppKit, "NSCursor"):
+ canvas.mouseUp_(event)
+
+ callback.assert_called_once_with(canvas.tiles, BEE, snap=False)
+ self.assertEqual(canvas.tiles[BEE]["x"], own["x"] + own["w"])
+
+ def test_c_key_recentres_selected_peer(self):
+ window = self.layout()
+ canvas = window.atlas_canvas
+ own = canvas.tiles[canvas.own_id]
+ canvas.tiles[BEE] = {**canvas.tiles[BEE], "x": own["x"] + own["w"] + 24, "y": own["y"] + 18}
+ canvas.selected = BEE
+ callback = mock.Mock()
+ canvas.on_layout_change = callback
+ event = mock.Mock()
+ event.keyCode.return_value = 8
+
+ canvas.keyDown_(event)
+
+ self.assertEqual(canvas.tiles[BEE]["x"], own["x"] + own["w"])
+ callback.assert_called_once_with(canvas.tiles, BEE, snap=False)
+
+ def test_non_touching_tile_invites_connection(self):
+ self.assertEqual(diagram.outcome_for_tile("between", False), "Drag to connect")
+
+ def test_a_drop_ten_visible_pixels_from_a_snap_point_snaps_on_a_small_map(self):
+ window = self.layout()
+ canvas = window.atlas_canvas
+ canvas.setFrame_(((0, 0), (240, canvas.HEIGHT)))
+ tiles = dict(canvas.tiles)
+ tiles[BEE] = {"x": 0, "y": 137, "w": 160, "h": 100}
+ window._atlas_layout_changed(tiles, BEE)
+ self.assertEqual(self.store.current()["layout"][BEE]["y"], 150)
+
+ def test_in_use_off_peer_keeps_its_ledger_row_without_map_tile(self):
+ window = self.build([(BEE, token(100), "Bee", {"in_use": False})])
+ self.assertNotIn(BEE, window.atlas_canvas.tiles)
+ self.assertIn(BEE, window.crossing_ledger.rows)
+ self.assertEqual(window.crossing_ledger.rows[BEE].leave.title(), "Put back")
+
+ def test_mouse_drop_announces_the_compiled_position(self):
+ window = self.layout(bee_x=320)
+ canvas = window.atlas_canvas
+ announced = []
+ canvas.announce = announced.append
+ tiles = dict(canvas.tiles)
+ tiles[BEE] = {"x": 0, "y": 100, "w": 160, "h": 100}
+ canvas.tiles = tiles
+ canvas.dragging = {"key": BEE, "moved": True}
+ canvas.window = mock.Mock()
+ canvas.convertPoint_fromView_ = mock.Mock(return_value=AppKit.NSMakePoint(10, 10))
+ event = mock.Mock()
+ event.locationInWindow.return_value = AppKit.NSMakePoint(10, 10)
+ with mock.patch.object(diagram.AppKit, "NSCursor"):
+ canvas.mouseUp_(event)
+ self.assertTrue(announced)
+ self.assertIn("Bee", announced[-1])
+
+ def test_accessible_tile_and_tick_expose_names_values_and_press_actions(self):
+ window = self.layout()
+ window.shortcut_goes_to._choose("ticked")
+ window._apply_settings()
+ canvas = window.atlas_canvas
+ children = canvas.accessibilityChildren()
+ bee = next(child for child in children if child.key == BEE and child.kind == "tile")
+ tick = next(child for child in children if child.key == BEE and child.kind == "cycle")
+ self.assertEqual(bee.accessibilityLabel(), "Bee")
+ self.assertEqual(tick.accessibilityValue(), True)
+ sea = next(child for child in children if child.key == SEA and child.kind == "tile")
+ sea.accessibilityPerformPress()
+ self.assertEqual(window.chosen_peer, SEA)
+ tick.accessibilityPerformPress()
+ self.assertFalse(tick.accessibilityValue())
+
+ def test_cycle_checkbox_is_keyboard_operable(self):
+ window = self.layout()
+ canvas = window.atlas_canvas
+ canvas.cycle_enabled = True
+ canvas.selected = BEE
+ event = mock.Mock()
+ event.keyCode.return_value = 49
+ event.modifierFlags.return_value = 0
+ canvas.keyDown_(event)
+ self.assertFalse(canvas.cycle[BEE])
+
+ def test_shortcut_cycle_uses_the_canvas_reading_order(self):
+ window = self.layout(bee_x=0)
+ self.assertEqual(window.controller._shortcut_cycle(), [SEA, BEE, None])
+
+ def test_left_out_peer_position_does_not_put_it_ahead_of_visible_peers(self):
+ window = self.two()
+ own = self.store.current()["machine_id"]
+ settings = self.store.current()
+ settings["layout"] = {
+ own: {"x": 160, "y": 100, "w": 160, "h": 100},
+ BEE: {"x": 0, "y": 100, "w": 160, "h": 100},
+ SEA: {"x": 320, "y": 100, "w": 160, "h": 100},
+ }
+ next(peer for peer in settings["peers"] if peer["id"] == BEE)["left_out"] = True
+ settings["layout_set_at"] = 1
+ self.store.save_settings(settings)
+ self.assertEqual(window.controller._shortcut_cycle(), [SEA, BEE, None])
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/mac_app/tests/test_beam_live.py b/mac_app/tests/test_beam_live.py
index 96f6953..34393ef 100644
--- a/mac_app/tests/test_beam_live.py
+++ b/mac_app/tests/test_beam_live.py
@@ -21,9 +21,11 @@ class LiveBeamFalloffTest(unittest.TestCase):
self.assertGreater(values[len(values) // 4], values[len(values) // 2])
def test_live_falloff_matches_the_windows_live_gradient(self):
+ import notch_beam
+
values = profile(live_glow("left", "large"), "left", 2)
depth = 67.02 * 2
- stops = ((0, 1), (.08, .85), (.3, .25), (1, 0))
+ stops = notch_beam.EDGE_FALLOFF
for index, alpha in enumerate(values):
at = (index + .5) / depth
expected = 0
@@ -31,8 +33,8 @@ class LiveBeamFalloffTest(unittest.TestCase):
if a <= at <= b:
expected = av + (bv - av) * (at - a) / (b - a)
break
- # The along-edge comet is at its midpoint; mask sampling can round by one alpha unit.
- self.assertAlmostEqual(alpha / values[0], expected / (1 - .15 * .5 / (.08 * depth)), delta=.025)
+ # The comet is at the edge midpoint, so only the shared inward falloff varies here.
+ self.assertAlmostEqual(alpha / values[0], expected, delta=.04)
def test_both_corner_walls_fade_inward(self):
for corner in ("top_left", "top_right", "bottom_left", "bottom_right"):
diff --git a/mac_app/tests/test_bridge.py b/mac_app/tests/test_bridge.py
index 3c647a2..224a8b6 100644
--- a/mac_app/tests/test_bridge.py
+++ b/mac_app/tests/test_bridge.py
@@ -24,6 +24,7 @@ from bridge import (
CONNECT_TIMEOUT_SECONDS,
CROSSING_RETRY_SECONDS,
KVMController,
+ KeyResult,
QuartzEventTranslator,
)
from bridge_fakes import ( # noqa: F401 (re-exported)
@@ -40,7 +41,7 @@ from bridge_fakes import ( # noqa: F401 (re-exported)
settle,
)
from fake_link import OTHER_ID, PEER_ID, FakeLink, bring_up
-from gestures import CHORD, DOCK_CONTROL_TYPE, MAGNIFY_TYPE, SWIPE_TYPE
+from gestures import CHORD, DOCK_CONTROL_TYPE, GESTURE_TYPE, MAGNIFY_TYPE, SWIPE_TYPE
from input_injector_mac import INJECTED_MARK
@@ -422,8 +423,42 @@ class ControllerTests(unittest.TestCase):
self.assertEqual(link.dropped, [])
self.assertFalse(link.stopped)
+ def test_hid_activity_missing_from_the_tap_returns_input_home(self):
+ class ActiveHIDQuartz(FakeQuartz):
+ kCGEventSourceStateHIDSystemState = 1
+ kCGAnyInputEventType = 0
+ hid_seconds_ago = 0.0
+
+ @classmethod
+ def CGEventSourceSecondsSinceLastEventType(cls, source, event_type):
+ return cls.hid_seconds_ago
+
+ controller = make_controller(self.clock, quartz=ActiveHIDQuartz)
+ self.addCleanup(controller.stop_event.set)
+ link = bring_up(controller)
+ controller.event_tap = object()
+ event = {FakeQuartz.kCGMouseEventDeltaX: 1, FakeQuartz.kCGMouseEventDeltaY: 0}
+ controller._event_tap_callback(None, FakeQuartz.kCGEventMouseMoved, event, None)
+ self.assertTrue(controller.set_redirecting(True))
+ self.clock.value += 3.0
+
+ with self.assertLogs(controller.logger, level="WARNING") as said:
+ controller._check_tap_watchdog()
+
+ self.assertFalse(controller.redirecting)
+ self.assertFalse(controller.owner.away)
+ self.assertIn(True, [enabled for _tap, enabled in ActiveHIDQuartz.tap_enable_calls])
+ self.assertTrue(any("event tap is not receiving input" in line for line in said.output), said.output)
+ self.assertTrue(link.live())
+
+ def test_move_logs_that_the_shortcut_double_tap_started_it(self):
+ bring_up(self.controller)
+ with self.assertLogs(self.controller.logger, level="INFO") as said:
+ self._double_tap()
+ self.assertTrue(any("move started by shortcut double-tap" in line for line in said.output), said.output)
+
def test_the_shortcut_there_and_back_never_clicks_on_this_mac(self):
- """Toby 06-10: a grey box round the pointer after the shortcut, "which clicked on return". A
+ """A report, 06-10: a grey box round the pointer after the shortcut, "which clicked on return". A
click made while away, and one held across the return, reach this Mac as nothing but the
user's own events: no button is posted, made or handed back that the hand did not press."""
bring_up(self.controller)
@@ -552,6 +587,39 @@ class ControllerTests(unittest.TestCase):
self.assertEqual(sent_home, [True])
self.assertFalse(self.controller.redirecting)
+ def test_next_shortcut_moves_from_home_to_the_first_machine(self):
+ cfg = crossing_config(PAIRED_TOKEN, methods=["shortcut"])
+ cfg.crossing["shortcut_goes_to"] = "next"
+ controller = make_controller(self.clock, cfg)
+ self.addCleanup(controller.stop_event.set)
+ bring_up(controller)
+ target = protocol.id_text(PEER_ID)
+ controller._shortcut_cycle = lambda: [target, None]
+ controller._ready = lambda _ident: True
+ selected = []
+ controller.set_redirecting = lambda value, **kwargs: selected.append((value, kwargs.get("peer"))) or True
+ controller._handle_trigger(KeyResult(True, True, False, []), object())
+ self.clock.value = 10.2
+ controller._handle_trigger(KeyResult(True, True, False, []), object())
+ self.assertEqual(selected, [(True, target)])
+
+ def test_hold_shortcut_announces_an_unready_last_machine(self):
+ cfg = crossing_config(PAIRED_TOKEN, methods=["shortcut"])
+ cfg.trigger_style = "hold"
+ controller = make_controller(self.clock, cfg)
+ self.addCleanup(controller.stop_event.set)
+ bring_up(controller)
+ first, second = "first", protocol.id_text(PEER_ID)
+ controller._last_peer = first
+ controller._shortcut_cycle = lambda: [first, second, None]
+ controller._ready = lambda ident: ident == second
+ skipped = []
+ selected = []
+ controller._announce_shortcut_skips = skipped.extend
+ controller.set_redirecting = lambda value, **kwargs: selected.append((value, kwargs.get("peer"))) or True
+ controller._handle_trigger(KeyResult(True, True, False, []), object())
+ self.assertEqual((selected, skipped), ([(True, second)], [first]))
+
def test_the_pcs_injected_trigger_is_not_this_macs_while_receiving(self):
sent_home = []
bring_up(self.controller)
@@ -599,6 +667,20 @@ class ControllerTests(unittest.TestCase):
# Must not raise even though the callback is broken.
self.assertFalse(self.controller.set_redirecting(True))
+ def test_holding_a_key_trigger_never_toggles(self):
+ # The Windows trigger counted autorepeat as taps until 1.5.2; the Mac reads the tap's
+ # autorepeat field, and this holds it to that.
+ bring_up(self.controller)
+ self.controller.cfg.trigger_key = "f13"
+ press = {FakeQuartz.kCGKeyboardEventKeycode: 0x69, FakeQuartz.kCGKeyboardEventAutorepeat: 0, "flags": 0}
+ repeat = dict(press)
+ repeat[FakeQuartz.kCGKeyboardEventAutorepeat] = 1
+ self._tap(FakeQuartz.kCGEventKeyDown, press)
+ for step in range(30):
+ self.clock.value = 10.5 + 0.033 * step
+ self._tap(FakeQuartz.kCGEventKeyDown, repeat)
+ self.assertFalse(self.controller.redirecting)
+
def test_double_tap_survives_a_missed_key_up(self):
# Regression: the old toggle-based modifier tracking desynced when a
# key-up went missing (e.g. a tap restart never delivered it), which
@@ -1026,16 +1108,17 @@ class MediaKeyWiringTests(unittest.TestCase):
{"type": protocol.MSG_KEYUP, "data": {"key": "volume_up"}},
)
- def test_non_media_system_event_passes_through(self):
- # NX code 3 is brightness-up, which Windows has no equivalent for.
+ def test_brightness_system_event_is_forwarded(self):
controller = self._controller(lambda event: (8, self._data1(3)))
redirect_to(controller)
- raw_event = object()
self.assertIs(
- controller._event_tap_callback(None, self.SYSDEFINED, raw_event, None),
- raw_event,
+ controller._event_tap_callback(None, self.SYSDEFINED, object(), None),
+ None,
+ )
+ self.assertEqual(
+ controller.outbound.get_nowait(),
+ {"type": protocol.MSG_KEYDOWN, "data": {"key": "brightness_down"}},
)
- self.assertTrue(controller.outbound.empty())
def test_not_redirecting_passes_through_without_converting(self):
calls = []
@@ -1220,6 +1303,27 @@ class DockControlWiringTests(unittest.TestCase):
self.assertTrue(controller.redirecting)
+class Type29GestureWiringTests(unittest.TestCase):
+ def test_zoom_fields_are_translated_and_swallowed_while_redirecting(self):
+ controller = make_controller(FakeClock())
+ redirect_to(controller)
+ raw_event = {110: 8, 113: 0.06, 132: 2}
+
+ returned = controller._event_tap_callback(None, GESTURE_TYPE, raw_event, None)
+
+ self.assertIsNone(returned)
+ self.assertEqual(controller.outbound.get_nowait(), {"type": CHORD, "data": {"action": "zoom_in"}})
+ self.assertTrue(controller.outbound.empty())
+
+ def test_type29_scroll_subtype_passes_through_unchanged(self):
+ controller = make_controller(FakeClock())
+ redirect_to(controller)
+ raw_event = {110: 6, 113: 0.5, 132: 2}
+
+ self.assertIs(controller._event_tap_callback(None, GESTURE_TYPE, raw_event, None), raw_event)
+ self.assertTrue(controller.outbound.empty())
+
+
class CrossingWiringTests(unittest.TestCase):
"""The engine is exercised in test_crossing.py; these prove the bridge
feeds it the right things at the right moment and acts on the answer."""
@@ -1682,6 +1786,37 @@ class RoundTripTests(unittest.TestCase):
class HeldKeyMappingTests(unittest.TestCase):
+ def test_command_tab_switches_to_alt_for_the_hold_and_releases_alt(self):
+ controller = KVMController.__new__(KVMController)
+ controller.cfg = types.SimpleNamespace(key_map=config.KEY_MAP_STYLES["semantic"])
+ controller._sent_names = {}
+ link = FakeLink("token", types.SimpleNamespace(peers=lambda: []), lambda: {})
+ link.peer_id = b"peer"
+ link._live = True
+ link.peer_platform = "windows"
+ controller._peers_up = {b"peer": link}
+
+ for kind, key in (
+ (protocol.MSG_KEYDOWN, "cmd"),
+ (protocol.MSG_KEYDOWN, "tab"),
+ (protocol.MSG_KEYDOWN, "tab"),
+ (protocol.MSG_KEYDOWN, "shift"),
+ (protocol.MSG_KEYDOWN, "tab"),
+ (protocol.MSG_KEYUP, "tab"),
+ (protocol.MSG_KEYUP, "shift"),
+ (protocol.MSG_KEYUP, "cmd"),
+ ):
+ controller._send(types.SimpleNamespace(peer=b"peer", message={"type": kind, "data": {"key": key}}))
+
+ self.assertEqual(
+ [(message["type"], message["data"]["key"]) for message in link._sent],
+ [(protocol.MSG_KEYDOWN, "ctrl"), (protocol.MSG_KEYUP, "ctrl"),
+ (protocol.MSG_KEYDOWN, "alt"), (protocol.MSG_KEYDOWN, "tab"),
+ (protocol.MSG_KEYDOWN, "tab"), (protocol.MSG_KEYDOWN, "shift"),
+ (protocol.MSG_KEYDOWN, "tab"), (protocol.MSG_KEYUP, "tab"),
+ (protocol.MSG_KEYUP, "shift"), (protocol.MSG_KEYUP, "alt")],
+ )
+
def test_key_release_keeps_the_mapping_used_for_its_press(self):
controller = KVMController.__new__(KVMController)
controller.cfg = types.SimpleNamespace(key_map=config.KEY_MAP_STYLES["semantic"])
diff --git a/mac_app/tests/test_click_focus.py b/mac_app/tests/test_click_focus.py
index ba56108..e0ac4cf 100644
--- a/mac_app/tests/test_click_focus.py
+++ b/mac_app/tests/test_click_focus.py
@@ -19,10 +19,15 @@ def key(window, characters, code):
def ring_shown(view):
- while view is not None and not isinstance(view, (widgets.Pressable, widgets._RulerView)):
+ while view is not None and not isinstance(view, (widgets.Pressable, widgets._RulerView,
+ kvm_bridge_app._DesignSlider)):
view = view.superview()
if isinstance(view, widgets._RulerView):
return widgets.keyboard_focus_visible(view)
+ if isinstance(view, kvm_bridge_app._DesignSlider):
+ window = view.window()
+ return (window is not None and window.keyboard_navigation
+ and window.firstResponder() == view)
return view.ring is not None and not view.ring.isHidden()
@@ -93,10 +98,8 @@ class ClickFocusTests(unittest.TestCase):
def test_click_on_each_control_type_draws_no_ring(self):
control = self.control
self.show('design')
- segment, words = control.length_select.cells[1][1], control.length_select.cells[1][2]
- self.assert_no_ring_after_click(segment, 'segment')
- self.assert_no_ring_after_click(words.view, 'segment label')
- self.assertIsNot(self.window.firstResponder(), words.view)
+ slider = control.length_select.slider
+ self.assert_no_ring_after_click(slider, 'design slider')
self.assert_no_ring_after_click(control.glow_box.view, 'switch')
self.assert_no_ring_after_click(control.glow_box.words.view, 'switch label')
tiles = control.notch_style_select.tiles
@@ -124,6 +127,39 @@ class ClickFocusTests(unittest.TestCase):
return
self.fail('no ruler found')
+ def test_keyboard_focus_invalidates_the_resistance_thumb(self):
+ from unittest import mock
+
+ control = self.control
+ self.show('crossing')
+ strip = control.push_strip
+ self.window.makeFirstResponder_(strip)
+ self.window.keyboard_navigation = True
+ strip.drawn_focus = False
+
+ with mock.patch.object(strip, 'setNeedsDisplay_', wraps=strip.setNeedsDisplay_) as redraw:
+ self.window.refresh_input_focus()
+
+ redraw.assert_called_once_with(True)
+
+ def test_resistance_thumb_redraws_on_responder_transitions(self):
+ from unittest import mock
+
+ self.show('crossing')
+ strip = self.control.push_strip
+ with mock.patch.object(strip, 'setNeedsDisplay_', wraps=strip.setNeedsDisplay_) as redraw:
+ self.assertTrue(strip.becomeFirstResponder())
+ redraw.assert_called_once_with(True)
+ redraw.reset_mock()
+ self.assertTrue(strip.resignFirstResponder())
+ redraw.assert_called_once_with(True)
+
+ def test_mouse_focus_does_not_highlight_the_resistance_thumb(self):
+ self.show('crossing')
+ strip = self.control.push_strip
+ self.click(strip)
+ self.assertFalse(widgets.keyboard_focus_visible(strip))
+
def _rulers(self, view):
if view.isHidden():
return
@@ -134,24 +170,24 @@ class ClickFocusTests(unittest.TestCase):
def test_other_keys_after_a_click_leave_the_ring_off(self):
self.show('design')
- segment = self.control.length_select.cells[1][1]
- self.click(segment)
+ slider = self.control.length_select.slider
+ self.click(slider)
self.press_key('a', 0)
self.assertFalse(self.window.keyboard_navigation)
- self.assertFalse(ring_shown(segment))
+ self.assertFalse(ring_shown(slider))
def test_tab_shows_a_ring_and_the_next_click_clears_it(self):
self.show('design')
- segment = self.control.length_select.cells[1][1]
- self.click(segment)
+ slider = self.control.length_select.slider
+ self.click(slider)
self.press_key('\t', 48)
self.assertTrue(self.window.keyboard_navigation)
responder = self.window.firstResponder()
- self.assertIsInstance(responder, widgets.Pressable)
+ self.assertIsInstance(responder, kvm_bridge_app._DesignSlider)
self.assertTrue(ring_shown(responder))
- self.click(segment)
+ self.click(slider)
self.assertFalse(ring_shown(responder))
- self.assertFalse(ring_shown(segment))
+ self.assertFalse(ring_shown(slider))
if __name__ == '__main__':
diff --git a/mac_app/tests/test_corner_marks.py b/mac_app/tests/test_corner_marks.py
new file mode 100644
index 0000000..3f01a16
--- /dev/null
+++ b/mac_app/tests/test_corner_marks.py
@@ -0,0 +1,263 @@
+import sys
+import unittest
+from unittest import mock
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+import AppKit
+import Quartz
+import diagram
+
+AppKit.NSApplication.sharedApplication()
+
+from test_crossing_page_machines import BEE, SEA, Page, token
+from wake import WakingController
+
+
+class CornerMarks(Page):
+ def setUp(self):
+ super().setUp()
+ capture = mock.patch.object(WakingController, "start_input_capture")
+ capture.start()
+ self.addCleanup(capture.stop)
+
+ def marked(self, corner="top_right", extra=None, off=False, notch=False, has_notch=False):
+ zones = [{"peer": BEE, "kind": "corner", "corner": corner, "edge": "right", "off": off}]
+ if notch:
+ zones.append({"peer": BEE, "kind": "notch", "off": off})
+ window = self.build([(BEE, token(100), "Bee", {"side": "right", **(extra or {})})], zones)
+ window.has_notch = has_notch
+ window.chosen_peer = BEE
+ window._show_arrangement([])
+ canvas = window.atlas_canvas
+ canvas.setFrame_(((0, 0), (480, canvas.HEIGHT)))
+ canvas._draw(False)
+ return window
+
+ def assert_bounds(self, layer, expected):
+ bounds = Quartz.CGPathGetBoundingBox(layer.path())
+ actual = (bounds.origin.x, bounds.origin.y, bounds.size.width, bounds.size.height)
+ for value, wanted in zip(actual, expected):
+ self.assertAlmostEqual(value, wanted)
+
+ def test_each_corner_pad_and_halo_are_centred_on_this_macs_vertex(self):
+ for corner in ("top_left", "top_right", "bottom_left", "bottom_right"):
+ with self.subTest(corner=corner):
+ canvas = self.marked(corner).atlas_canvas
+ key = (BEE, "corner", corner)
+ self.assertEqual(set(canvas.mark_layers), {key})
+ x, y, width, height = canvas._map()[0][canvas.own_id]
+ left = (x if corner.endswith("left") else x + width) - 8
+ top = (y if corner.startswith("top") else y + height) - 8
+ layer = canvas.mark_layers[key]
+ self.assert_bounds(layer, (left, top, 16, 16))
+ halo = canvas.corner_halo_layers[key]
+ chevron = layer.sublayers()[0]
+ self.assert_bounds(halo, (left - 3, top - 3, 22, 22))
+ self.assertEqual(chevron.lineWidth(), 1.8)
+ self.assertEqual(chevron.lineCap(), Quartz.kCALineCapRound)
+ self.assertGreater(layer.zPosition(), canvas.layer_for_tile[canvas.own_id].zPosition())
+
+ def test_two_machines_keep_their_corners_and_selected_opacity(self):
+ window = self.build([(BEE, token(100), "Bee", {"side": "right"}),
+ (SEA, token(150), "Sea", {"side": "left"})],
+ [{"peer": BEE, "kind": "corner", "corner": "top_right", "edge": "right"},
+ {"peer": SEA, "kind": "corner", "corner": "bottom_left", "edge": "left"}])
+ window.chosen_peer = BEE
+ window._show_arrangement([])
+ canvas = window.atlas_canvas
+ canvas.setFrame_(((0, 0), (480, canvas.HEIGHT)))
+ canvas._draw(False)
+ bee = canvas.mark_layers[(BEE, "corner", "top_right")]
+ sea = canvas.mark_layers[(SEA, "corner", "bottom_left")]
+ self.assertEqual(len(canvas.mark_layers), 2)
+ self.assertAlmostEqual(bee.opacity(), 1.0)
+ self.assertAlmostEqual(sea.opacity(), 0.55)
+ window.chosen_peer = SEA
+ window._show_arrangement([])
+ self.assertIs(canvas.mark_layers[(BEE, "corner", "top_right")], bee)
+ self.assertIs(canvas.mark_layers[(SEA, "corner", "bottom_left")], sea)
+ self.assertAlmostEqual(bee.opacity(), 0.55)
+ self.assertAlmostEqual(sea.opacity(), 1.0)
+
+ def test_a_corner_only_machine_has_its_pad_and_no_seam(self):
+ canvas = self.marked("top_right").atlas_canvas
+ self.assertTrue(canvas.states[BEE]["crosses"])
+ self.assertIn((BEE, "corner", "top_right"), canvas.mark_layers)
+ self.assertNotIn((canvas.own_id, BEE, "signal"), canvas.contact_layers)
+
+ def test_disabled_ways_have_no_marks(self):
+ canvas = self.marked(off=True, notch=True, has_notch=True).atlas_canvas
+ self.assertNotIn("corner_way", canvas.states[BEE])
+ self.assertFalse(canvas.states[BEE].get("notch_way"))
+ self.assertEqual(canvas.mark_layers, {})
+
+ def test_corner_and_notch_stay_visible_when_edge_is_off(self):
+ window = self.marked(notch=True, has_notch=True)
+ window._write_ways(BEE, edge=False)
+ window._show_arrangement([])
+ canvas = window.atlas_canvas
+ self.assertEqual(set(canvas.mark_layers), {(BEE, "corner", "top_right"), (BEE, "notch")})
+ self.assertFalse(canvas.states[BEE]["picked_thirds"])
+
+ def test_left_out_dormant_and_not_in_use_machines_have_no_marks(self):
+ for extra in ({"left_out": True}, {"dormant": True}, {"in_use": False}):
+ with self.subTest(extra=extra):
+ canvas = self.marked(extra=extra, notch=True, has_notch=True).atlas_canvas
+ self.assertNotIn("corner_way", canvas.states[BEE])
+ self.assertFalse(canvas.states[BEE].get("notch_way"))
+ self.assertEqual(canvas.mark_layers, {})
+
+ def test_notch_tab_is_centred_on_this_macs_top_border(self):
+ canvas = self.marked(notch=True, has_notch=True).atlas_canvas
+ layer = canvas.mark_layers[(BEE, "notch")]
+ x, y, width, _height = canvas._map()[0][canvas.own_id]
+ self.assert_bounds(layer, (x + width / 2 - 7, y - 2, 14, 4))
+ self.assertAlmostEqual(layer.opacity(), 1.0)
+ canvas.selected = canvas.own_id
+ canvas._draw(False)
+ self.assertIs(canvas.mark_layers[(BEE, "notch")], layer)
+ self.assertAlmostEqual(layer.opacity(), 0.55)
+
+ def test_notch_requires_both_the_way_and_a_notched_mac(self):
+ for notch, has_notch in ((False, True), (True, False), (False, False)):
+ with self.subTest(notch=notch, has_notch=has_notch):
+ canvas = self.marked(notch=notch, has_notch=has_notch).atlas_canvas
+ self.assertNotIn((BEE, "notch"), canvas.mark_layers)
+
+ def test_corner_bounds_with_display_metadata_still_use_this_macs_tile(self):
+ canvas = self.marked("bottom_right").atlas_canvas
+ tiles = {peer: dict(tile) for peer, tile in canvas.tiles.items()}
+ tiles[canvas.own_id]["displays"] = {
+ "main": {"x": 0, "y": 0, "w": 1728, "h": 1117},
+ "second": {"x": -1280, "y": 0, "w": 1280, "h": 1024},
+ }
+ canvas.show_layout(tiles, canvas.states, canvas.labels, canvas.own_id, BEE)
+ x, y, width, height = canvas._map()[0][canvas.own_id]
+ self.assert_bounds(canvas.mark_layers[(BEE, "corner", "bottom_right")],
+ (x + width - 8, y + height - 8, 16, 16))
+
+ def test_refresh_keeps_the_same_layers(self):
+ window = self.marked(notch=True, has_notch=True)
+ canvas = window.atlas_canvas
+ layers = dict(canvas.mark_layers)
+ window._show_arrangement([])
+ self.assertEqual(set(canvas.mark_layers), set(layers))
+ for key, layer in layers.items():
+ self.assertIs(canvas.mark_layers[key], layer)
+ canvas.setFrame_(((0, 0), (600, canvas.HEIGHT)))
+ canvas._draw(False)
+ for key, layer in layers.items():
+ self.assertIs(canvas.mark_layers[key], layer)
+
+ def test_turning_ways_off_removes_stale_layers(self):
+ window = self.marked(notch=True, has_notch=True)
+ canvas = window.atlas_canvas
+ layers = list(canvas.mark_layers.values())
+ window._write_ways(BEE, corner=False, notch=False)
+ window._load_ways()
+ window._show_arrangement([])
+ self.assertEqual(canvas.mark_layers, {})
+ for layer in layers:
+ self.assertIsNone(layer.superlayer())
+
+
+class CanvasCornerGeometry(unittest.TestCase):
+ def canvas(self, side="right", picked=None, edge_off=False):
+ canvas = diagram.AtlasCanvas.alloc().init().setup()
+ own = {"x": 100, "y": 100, "w": 160, "h": 100}
+ peer = {"x": 260 if side == "right" else 100, "y": 100 if side == "right" else 0,
+ "w": 160, "h": 100}
+ canvas.own_id, canvas.selected = "own", BEE
+ canvas.tiles = {"own": own, BEE: peer}
+ canvas.states = {BEE: {"state": "edge", "crosses": not edge_off, "edge_off": edge_off,
+ "linked": True, "picked_thirds": picked or [],
+ "lit_thirds": picked or [], "corner_way": "top_right"}}
+ return canvas, {"own": (30, 40, 160, 100), BEE: (190, 40, 160, 100)}
+
+ def test_corner_mark_is_square_pad_with_halo_and_outward_chevron(self):
+ canvas, frames = self.canvas()
+ canvas._draw_marks(frames)
+ pad = canvas.mark_layers[(BEE, "corner", "top_right")]
+ halo = canvas.corner_halo_layers[(BEE, "corner", "top_right")]
+ chevron = pad.sublayers()[0]
+ for layer, wanted in ((pad, (182, 32, 16, 16)), (halo, (179, 29, 22, 22)),
+ (chevron, (187, 36, 7, 7))):
+ bounds = Quartz.CGPathGetBoundingBox(layer.path())
+ actual = (bounds.origin.x, bounds.origin.y, bounds.size.width, bounds.size.height)
+ self.assertEqual(actual, wanted)
+ self.assertAlmostEqual(chevron.lineWidth(), 1.8)
+ self.assertEqual(chevron.lineCap(), Quartz.kCALineCapRound)
+
+ def test_lit_seam_stops_eleven_pixels_before_corner_halo(self):
+ canvas, frames = self.canvas(picked=["start", "middle", "end"])
+ canvas._draw_contacts(frames)
+ bounds = Quartz.CGPathGetBoundingBox(canvas.contact_layers[("own", BEE, "signal")].path())
+ self.assertAlmostEqual(bounds.origin.y, 51)
+ self.assertAlmostEqual(bounds.origin.y + bounds.size.height, 138)
+
+ def test_unpicked_track_stops_eleven_pixels_before_corner_halo(self):
+ canvas, frames = self.canvas(picked=["middle", "end"])
+ canvas._draw_contacts(frames)
+ bounds = Quartz.CGPathGetBoundingBox(canvas.third_layers[(BEE, "start", "track")].path())
+ self.assertAlmostEqual(bounds.origin.y, 51)
+
+ def test_halo_clips_another_machines_seam_at_the_same_vertex(self):
+ canvas, frames = self.canvas(picked=["start", "middle", "end"])
+ canvas.states[BEE].pop("corner_way")
+ canvas.states[SEA] = {"corner_way": "top_right"}
+ frames[SEA] = (350, 40, 160, 100)
+ canvas._draw_contacts(frames)
+ bounds = Quartz.CGPathGetBoundingBox(canvas.contact_layers[("own", BEE, "signal")].path())
+ self.assertAlmostEqual(bounds.origin.y, 51)
+
+ def test_offline_seam_keeps_its_ways_at_fifty_five_percent(self):
+ canvas, frames = self.canvas(picked=["start", "middle", "end"])
+ canvas.states[BEE]["linked"] = False
+ canvas._draw_contacts(frames)
+ self.assertAlmostEqual(canvas.contact_layers[("own", BEE, "signal")].opacity(), 0.55)
+
+ def test_edge_off_still_has_third_hits_but_no_tracks(self):
+ canvas, frames = self.canvas(edge_off=True)
+ self.assertEqual(len(canvas._third_segments(frames)), 3)
+ canvas._draw_thirds(frames)
+ self.assertFalse(any(key[-1] == "track" for key in canvas.third_layers))
+
+ def test_map_tile_without_received_state_draws_and_has_turn_on_tooltip(self):
+ canvas, frames = self.canvas()
+ canvas.states = {}
+ canvas._draw_thirds(frames)
+ self.assertFalse(any(key[-1] == "track" for key in canvas.third_layers))
+ self.assertEqual(canvas._third_tooltip(BEE, "start"), "Top third: click to turn it on")
+
+ def test_corner_only_tile_outcome_is_crosses(self):
+ canvas, _frames = self.canvas(edge_off=True)
+ canvas.states[BEE]["crosses"] = True
+ canvas.setFrame_(((0, 0), (480, 260)))
+ canvas._draw(False)
+ self.assertEqual(canvas.outcome_for_tile[BEE].string(), "Crosses")
+
+ def test_small_map_tiles_keep_outcome_without_overlapping_status(self):
+ canvas, _frames = self.canvas(picked=["start", "middle", "end"])
+ for height in (64, 77 + 1 / 3):
+ canvas.setFrame_(((0, 0), (2 * canvas.INSET + 320 * height / 100, 260)))
+ canvas._draw(False)
+ frame = canvas._map()[0][BEE]
+ title = canvas.label_for_tile[BEE]
+ status = canvas.state_for_tile[BEE]
+ outcome = canvas.outcome_for_tile[BEE]
+ with self.subTest(tile_height=height):
+ self.assertAlmostEqual(frame[3], height)
+ self.assertFalse(outcome.isHidden())
+ self.assertEqual(outcome.string(), "Crosses")
+ self.assertEqual(status.isHidden(), height < 72)
+ self.assertEqual(canvas.dot_for_tile[BEE].isHidden(), height < 72)
+ preceding = title if status.isHidden() else status
+ self.assertLessEqual(preceding.frame().origin.y + preceding.frame().size.height,
+ outcome.frame().origin.y)
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/mac_app/tests/test_crossing.py b/mac_app/tests/test_crossing.py
index a94ca21..693d6de 100644
--- a/mac_app/tests/test_crossing.py
+++ b/mac_app/tests/test_crossing.py
@@ -4,7 +4,7 @@ import sys
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
-from crossing import DECAY_S, CrossingEngine
+from crossing import DECAY_S, CrossingEngine, Ways
BOUNDS = (0, 0, 1728, 1117)
RIGHT_X = 1727.0
@@ -89,6 +89,39 @@ class ResistanceTests(unittest.TestCase):
self.assertEqual(machine.pressure, 0.0)
self.assertFalse(step.hold)
+ def test_decay_removes_the_same_pointer_travel_at_120_and_500(self):
+ for resistance in (120, 500):
+ machine = engine(resistance_px=resistance)
+ machine.feed(RIGHT_X, 500.0, 100, 0, BOUNDS, 1.0)
+ fraction = machine.pressure_at(1.2)
+ with self.subTest(resistance=resistance):
+ self.assertAlmostEqual(fraction * resistance, 40.0)
+
+ def test_sustained_push_examples_use_a_fixed_decay_rate(self):
+ for resistance, speed, expected_time, expected_travel in (
+ (120, 500, 0.6, 300), (500, 500, 2.5, 1250), (500, 1000, 0.71, 714)):
+ machine = engine(resistance_px=resistance)
+ step = None
+ interval = 0.01
+ for index in range(400):
+ step = machine.feed(RIGHT_X, 500.0, speed * interval, 0, BOUNDS,
+ 1.0 + index * interval)
+ if step.crossed:
+ break
+ with self.subTest(resistance=resistance, speed=speed):
+ self.assertTrue(step.crossed)
+ self.assertAlmostEqual(index * interval, expected_time, delta=0.025)
+ self.assertAlmostEqual((index + 1) * speed * interval, expected_travel, delta=15)
+
+
+ def test_track_endpoints_and_fill_head_share_the_same_coordinate_scale(self):
+ from core.resistance_strip import resistance_x
+
+ self.assertEqual(resistance_x(720, 0), 18.0)
+ self.assertEqual(resistance_x(720, 500), 702.0)
+ self.assertEqual(resistance_x(720, 250), 360.0)
+ self.assertEqual(resistance_x(720, 700), resistance_x(720, 500))
+
def test_a_slow_lean_never_builds(self):
machine = engine()
step = push_right(machine, 200, dx=1)
@@ -183,10 +216,11 @@ class BreakthroughTests(unittest.TestCase):
def test_arrival_point_sits_just_inside_the_edge(self):
self.assertEqual(CrossingEngine.arrival_point("left", 0.5, BOUNDS), (2.0, 558.0))
- self.assertEqual(CrossingEngine.arrival_point("right", 0.0, BOUNDS), (1725.0, 0.0))
- self.assertEqual(CrossingEngine.arrival_point("top", 1.0, BOUNDS), (1727.0, 2.0))
+ # An end of an edge lands LANDING_CLEAR_PX in, clear of the edge and corner beside it.
+ self.assertEqual(CrossingEngine.arrival_point("right", 0.0, BOUNDS), (1725.0, 10.0))
+ self.assertEqual(CrossingEngine.arrival_point("top", 1.0, BOUNDS), (1717.0, 2.0))
self.assertEqual(CrossingEngine.arrival_point("bottom", 0.5, BOUNDS), (863.5, 1114.0))
- self.assertEqual(CrossingEngine.arrival_point("left", 7.0, BOUNDS)[1], 1116.0)
+ self.assertEqual(CrossingEngine.arrival_point("left", 7.0, BOUNDS)[1], 1106.0)
class GuardTests(unittest.TestCase):
@@ -343,6 +377,22 @@ class MonitorLayoutTests(unittest.TestCase):
step = self.feed_at(engine(), 1727.0, 500.0, 20, 0, side, (0, 0, 3648, 1117))
self.assertFalse(step.crossed)
+ def test_a_zone_on_one_display_holds_and_crosses_at_its_internal_seam(self):
+ machine = CrossingEngine(
+ resistance_px=20,
+ ways=[Ways("peer", frozenset({"edge"}), "right", frozenset(), "top_right",
+ "0", "display-a", "left")],
+ )
+ displays = [(0, 0, 100, 100), (100, 0, 200, 100)]
+ result = None
+ for index in range(20):
+ result = machine.feed(99, 50, 5, 0, (0, 0, 200, 100), 1 + index * 0.01,
+ displays=displays)
+ if result.crossed:
+ break
+ self.assertTrue(result.crossed)
+ self.assertEqual((result.display, result.side), ("display-a", "left"))
+
def test_the_bottom_of_a_short_display_beside_a_tall_one_crosses(self):
tall_short = [(0, 0, 100, 300), (100, 0, 200, 100)]
step = self.feed_at(engine(edge="bottom"), 150.0, 99.0, 0, 20, tall_short, (0, 0, 200, 300))
@@ -367,6 +417,19 @@ class MonitorLayoutTests(unittest.TestCase):
self.assertEqual(x, 2.0)
self.assertGreater(y, 982)
+ def test_an_arrival_with_no_display_named_lands_where_it_crossed_as_on_the_pc(self):
+ # rc16 bug hunt (11-10-2026): a switch naming no display (a 1.5.1 peer, or a picture without
+ # this Mac's displays) laid the whole edge's fraction across one display, about a display's
+ # width from where the pointer crossed. return_edge.arrival_position keeps the point.
+ side_by_side = [(0, 0, 1920, 1080), (1920, 0, 3840, 1080)]
+ x, y = CrossingEngine.arrival_point("top", 0.49, (0, 0, 3840, 1080), displays=side_by_side)
+ self.assertAlmostEqual(x, 0.49 * 3839, delta=1.0)
+ self.assertEqual(y, 2.0)
+ stacked = [(0, 0, 1920, 1080), (0, 1080, 1920, 2160)]
+ x, y = CrossingEngine.arrival_point("left", 0.25, (0, 0, 1920, 2160), displays=stacked)
+ self.assertAlmostEqual(y, 0.25 * 2159, delta=1.0)
+ self.assertEqual(x, 2.0)
+
class CornerAndEdgeTests(unittest.TestCase):
diff --git a/mac_app/tests/test_crossing_handlers.py b/mac_app/tests/test_crossing_handlers.py
new file mode 100644
index 0000000..68219e0
--- /dev/null
+++ b/mac_app/tests/test_crossing_handlers.py
@@ -0,0 +1,325 @@
+"""Crossing outcomes rebuild and re-arm before sending over either Mac link."""
+
+import copy
+import json
+import logging
+import sys
+import tempfile
+import threading
+import unittest
+from pathlib import Path
+from types import SimpleNamespace
+from unittest import mock
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[2]))
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+import AppKit
+AppKit.NSApplication.sharedApplication()
+
+import bridge
+from bridge import KVMController, links_from_store
+from bridge_fakes import FakeQuartz, PAIRED_TOKEN, make_config
+from core import crossing_state, protocol, receiver, ways as core_ways
+import kvm_bridge_app
+import settings_store
+
+
+PEER = protocol.id_text(bytes(range(1, 17)))
+OTHER = protocol.id_text(bytes(range(21, 37)))
+
+
+class CrossingOutcomeTests(unittest.TestCase):
+ def controller(self):
+ controller = KVMController(make_config(), quartz=FakeQuartz,
+ logger=logging.getLogger("crossing-outcome-test"))
+ own = protocol.id_text(controller.identity()["id"])
+ self.events = []
+ self.held = dict(machine_id=own, peers=[dict(id=PEER, side="right", side_set_at=100,
+ side_by=own, port=24820, send=True, in_use=True)],
+ zones=[dict(peer=PEER, kind="edge", side="right")],
+ layout={own: dict(x=0, y=0, w=160, h=100),
+ PEER: dict(x=160, y=0, w=160, h=100)})
+
+ def save(settings):
+ self.events.append("save")
+ self.held = copy.deepcopy(settings)
+
+ controller.book = receiver.PeerBook(lambda: self.held, save, threading.RLock())
+ controller.responder = SimpleNamespace(
+ peers_changed=lambda: self.events.append("peers_changed"),
+ rearm=lambda: self.events.append("rearm"), links=lambda: [],
+ send=lambda *args: self.events.append("inbound_tell"))
+ controller.zones_changed = lambda: self.events.append("zones_changed")
+ controller.send_arrangement = lambda *args: self.events.append("tell") or True
+ controller.announce = lambda: [protocol.settings_msg({"own": True})]
+ controller._send_crossing_picture = lambda data, source=None: self.events.append(("picture", data, source))
+ return controller
+
+ def test_saved_ways_rearm_before_telling_the_peer(self):
+ controller = self.controller()
+ outcome = crossing_state.edit_ways(self.held, PEER, platform="mac", edge=False,
+ live=None, gone=None, now=200, capable={PEER})
+ controller.carry_crossing(outcome)
+ self.assertEqual(self.events, ["save", "zones_changed", "peers_changed", "rearm", "tell"])
+ self.assertFalse(self.held["peers"][0]["ways"]["edge"])
+ self.assertEqual(self.held["zones"], [])
+
+ def test_event_compute_and_save_hold_the_book_but_rearm_does_not(self):
+ controller = self.controller()
+ original_save = controller.book._save
+
+ def save(settings):
+ self.assertTrue(controller.book.lock._is_owned())
+ original_save(settings)
+
+ def handler(settings, **kwargs):
+ self.assertTrue(controller.book.lock._is_owned())
+ return crossing_state.edit_ways(settings, PEER, edge=False, **kwargs)
+
+ controller.book._save = save
+ controller.responder.rearm = lambda: self.assertFalse(controller.book.lock._is_owned())
+ controller.crossing_event(handler, platform="mac", live=None, gone=None, now=200)
+ self.assertEqual(self.events.count("save"), 1)
+ self.assertEqual(self.events[:3], ["save", "zones_changed", "peers_changed"])
+
+ def test_forwarded_picture_keeps_the_arrival_and_excludes_its_source(self):
+ controller = self.controller()
+ state = dict(set_at=200, by=PEER, tiles=copy.deepcopy(self.held["layout"]))
+ state["tiles"][PEER].update(x=0, y=-100)
+ outcome = crossing_state.receive_picture(self.held, state, source=PEER, platform="mac",
+ capable={PEER}, live=None, gone=None, own_displays={}, now=201)
+ arrival = {"layout": state, "unrelated": "retained"}
+ controller.carry_crossing(outcome, source=PEER, arrived=arrival)
+ self.assertEqual(self.events[:4], ["save", "zones_changed", "peers_changed", "rearm"])
+ self.assertEqual(self.events[-1], ("picture", arrival, PEER))
+ self.assertEqual(self.held["peers"][0]["side"], "top")
+
+ def test_old_picture_does_not_reset_a_push_in_progress(self):
+ controller = self.controller()
+ self.held.update(layout_set_at=200, layout_by=PEER)
+ outcome = crossing_state.receive_picture(self.held,
+ dict(set_at=199, by=PEER, tiles=self.held["layout"]), source=PEER, platform="mac",
+ capable={PEER}, live=None, gone=None, own_displays={}, now=201)
+ controller.carry_crossing(outcome)
+ self.assertEqual(self.events, [])
+
+ def test_a_picture_peer_arrangement_keeps_position_and_sends_no_reply(self):
+ controller = self.controller()
+ before = copy.deepcopy(self.held["layout"])
+ outcome = crossing_state.receive_arrangement(self.held, PEER,
+ dict(edge="top", set_at=200, by=protocol.read_id(PEER), way_back=False),
+ platform="mac", capable={PEER}, live=None, gone=None, now=201)
+ controller.carry_crossing(outcome)
+ self.assertEqual(self.events, ["save", "zones_changed", "peers_changed", "rearm"])
+ self.assertEqual(self.held["layout"], before)
+ self.assertEqual(self.held["peers"][0]["side"], "right")
+ self.assertFalse(self.held["peers"][0]["way_back"])
+
+ def test_a_tell_uses_the_inbound_link_when_no_outbound_link_is_up(self):
+ controller = self.controller()
+ controller.send_arrangement = lambda *args: False
+ outcome = crossing_state.edit_ways(self.held, PEER, platform="mac", edge=False,
+ live=None, gone=None, now=200, capable={PEER})
+ controller.carry_crossing(outcome)
+ self.assertEqual(self.events[-2:], ["rearm", "inbound_tell"])
+
+ def test_pictures_use_only_layout_peers_and_do_not_duplicate_two_links(self):
+ controller = self.controller()
+ self.held["peers"].append(dict(id=OTHER, port=24820))
+ old = protocol.id_text(bytes(range(41, 57)))
+ self.held["peers"].append(dict(id=old, port=24820))
+ sent = []
+
+ def outbound(peer, caps):
+ return SimpleNamespace(caps=caps, live=lambda: True,
+ post=lambda message: sent.append((peer, message)))
+
+ controller._peers_up = {PEER: outbound(PEER, {"settings", "layout"}),
+ old: outbound(old, {"settings"})}
+ controller.responder.links = lambda: [protocol.read_id(PEER), protocol.read_id(OTHER)]
+ controller.responder.caps_of = lambda peer: {"settings", "layout"}
+ controller.responder.send = lambda peer, message: sent.append((protocol.id_text(peer), message))
+ KVMController._send_crossing_picture(controller, {"same_on_both": False})
+ self.assertEqual([peer for peer, _message in sent], [PEER, OTHER])
+ sent.clear()
+ KVMController._send_crossing_picture(controller, {"same_on_both": False}, source=PEER)
+ self.assertEqual([peer for peer, _message in sent], [OTHER])
+
+ def test_disconnecting_a_picture_peer_keeps_its_observed_capability(self):
+ controller = self.controller()
+ controller._peers_up = {PEER: SimpleNamespace(caps={"layout"})}
+ self.assertIn(PEER, controller.crossing_capable())
+ controller._peers_up.clear()
+ self.assertIn(PEER, controller.crossing_capable())
+ self.held["peers"].clear()
+ self.assertNotIn(PEER, controller.crossing_capable())
+
+
+class ShortcutCycleStore:
+ """A store that injects a link-up settings save between an unlocked read and write."""
+
+ def __init__(self):
+ self.lock = threading.RLock()
+ self.settings = {"peers": [{"id": PEER, "shortcut_cycle": False},
+ {"id": OTHER, "shortcut_cycle": True}],
+ "link_up_displays": ["old"]}
+ self.injected = False
+ self.saved_under_lock = False
+
+ def current(self):
+ if not self.lock._is_owned() and not self.injected:
+ self.injected = True
+ snapshot = copy.deepcopy(self.settings)
+ self.settings["link_up_displays"] = ["new"]
+ return snapshot
+ if self.lock._is_owned() and not self.injected:
+ self.injected = True
+ self.settings["link_up_displays"] = ["new"]
+ return copy.deepcopy(self.settings)
+
+ def save_settings(self, settings):
+ self.saved_under_lock = self.lock._is_owned()
+ self.settings = copy.deepcopy(settings)
+
+ def load(self):
+ return {"loaded": True}
+
+
+class CrossingHandlerTests(unittest.TestCase):
+ def stored_controller(self):
+ directory = tempfile.TemporaryDirectory()
+ self.addCleanup(directory.cleanup)
+ store = settings_store.SettingsStore(Path(directory.name) / "settings.json")
+ settings = copy.deepcopy(store.current())
+ settings["peers"] = [{**settings_store.PEER_DEFAULTS, "id": PEER,
+ "token": PAIRED_TOKEN, "platform": "windows", "host": "192.0.2.10",
+ "port": 24820, "side": "right"}]
+ settings["zones"] = [{"peer": PEER, "kind": "edge"}]
+ store.save_settings(settings)
+ book, identity = links_from_store(store, "1.5.2")
+ controller = KVMController(store.load(), quartz=FakeQuartz, book=book, identity=identity)
+ return store, controller
+
+ def test_crossing_save_keeps_the_immediate_full_screen_hold_before_debounce(self):
+ store, controller = self.stored_controller()
+ window = SimpleNamespace(controller=controller, _changed=lambda: None)
+ controller.full_screen_app = "Steam"
+ kvm_bridge_app.ControlWindow._hold_changed(window, True)
+ self.assertEqual(controller.full_screen_app, "Steam")
+
+ outcome = controller.crossing_event(crossing_state.edit_ways, PEER,
+ platform="mac", edge=False, live=None, gone=None, now=200)
+
+ self.assertTrue(outcome["changed"])
+ self.assertEqual(controller.full_screen_app, "Steam")
+ self.assertFalse(store.current()["crossing"]["hold_full_screen"])
+ self.assertNotIn("edge", controller.cfg.crossing["methods"])
+ self.assertFalse(controller.crossing.armed)
+ kvm_bridge_app.ControlWindow._hold_changed(window, False)
+ self.assertIsNone(controller.full_screen_app)
+
+ def test_a_full_screen_toggle_during_the_crossing_config_copy_is_not_lost(self):
+ _store, controller = self.stored_controller()
+ snapshot = threading.Event()
+ toggle_attempt = threading.Event()
+ errors = []
+ original_lock = controller._cfg_lock
+ original_replace = bridge.dataclasses.replace
+
+ class ObservedLock:
+ def __enter__(self):
+ if threading.current_thread().name == "hold-toggle":
+ toggle_attempt.set()
+ original_lock.acquire()
+
+ def __exit__(self, *_args):
+ original_lock.release()
+
+ controller._cfg_lock = ObservedLock()
+ window = SimpleNamespace(controller=controller, _changed=toggle_attempt.set)
+
+ def replace(*args, **kwargs):
+ snapshot.set()
+ if not toggle_attempt.wait(2):
+ raise AssertionError("the hold toggle never attempted its update")
+ return original_replace(*args, **kwargs)
+
+ def toggle():
+ try:
+ if not snapshot.wait(2):
+ raise AssertionError("the crossing config was never copied")
+ kvm_bridge_app.ControlWindow._hold_changed(window, True)
+ except Exception as exc:
+ errors.append(exc)
+
+ worker = threading.Thread(target=toggle, name="hold-toggle")
+ worker.start()
+ try:
+ with mock.patch.object(bridge.dataclasses, "replace", side_effect=replace):
+ controller.crossing_event(crossing_state.edit_ways, PEER,
+ platform="mac", edge=False, live=None, gone=None, now=200)
+ finally:
+ snapshot.set()
+ worker.join(3)
+ self.assertFalse(worker.is_alive())
+ self.assertEqual(errors, [])
+ controller.full_screen_app = "Steam"
+ self.assertEqual(controller.full_screen_app, "Steam")
+
+ def test_shortcut_cycle_reads_and_saves_under_lock_without_losing_link_state(self):
+ store = ShortcutCycleStore()
+ window = SimpleNamespace(
+ _flush=lambda: None,
+ settings_store=store,
+ controller=SimpleNamespace(cfg=None),
+ _show_arrangement=lambda: None,
+ logger=logging.getLogger("crossing-handler-test"),
+ )
+
+ kvm_bridge_app.ControlWindow._set_shortcut_cycle(window, PEER, True)
+
+ self.assertTrue(store.saved_under_lock)
+ self.assertTrue(store.settings["peers"][0]["shortcut_cycle"])
+ self.assertTrue(store.settings["peers"][1]["shortcut_cycle"])
+ self.assertEqual(store.settings["link_up_displays"], ["new"])
+
+ def test_ledger_handlers_ignore_left_out_or_not_in_use_peers(self):
+ with tempfile.TemporaryDirectory() as directory:
+ raw = settings_store.config_to_raw(settings_store.editable_default_config())
+ path = Path(directory) / "config.json"
+ path.write_text(json.dumps(raw))
+ store = settings_store.SettingsStore(path)
+ settings = copy.deepcopy(store.current())
+ own = settings["machine_id"]
+ settings["peers"] = [{**settings_store.PEER_DEFAULTS, "id": PEER,
+ "token": "test-peer-token", "platform": "windows", "port": 24820,
+ "side": "right"}]
+ settings["layout"] = {own: {"x": 0, "y": 0, "w": 100, "h": 100},
+ PEER: {"x": 100, "y": 0, "w": 100, "h": 100}}
+ settings["zones"] = [{"peer": PEER, "kind": "edge", "side": "right"}]
+ store.save_settings(settings)
+ window = SimpleNamespace(settings_store=store, has_notch=True,
+ chosen_peer=PEER, _write_ways=mock.Mock(),
+ _reflect=mock.Mock(), _load_ways=mock.Mock())
+
+ for exclusion in ({"left_out": True}, {"in_use": False}):
+ with self.subTest(exclusion=exclusion):
+ active = copy.deepcopy(store.current())
+ peer = next(item for item in active["peers"] if item["id"] == PEER)
+ peer.update(left_out=False, in_use=True)
+ peer.update(exclusion)
+ store.save_settings(active)
+ tiles = core_ways.derive_layout(store.current(), gap=0)
+ self.assertEqual(core_ways._rect_contact(tiles[own], tiles[PEER])[0], "right")
+ window._write_ways.reset_mock()
+
+ kvm_bridge_app.ControlWindow._ledger_edge(window, PEER)
+ kvm_bridge_app.ControlWindow._ledger_corner(window, PEER, "top_left")
+ kvm_bridge_app.ControlWindow._ledger_notch(window, PEER, True)
+
+ window._write_ways.assert_not_called()
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/mac_app/tests/test_crossing_ledger.py b/mac_app/tests/test_crossing_ledger.py
new file mode 100644
index 0000000..0a18aae
--- /dev/null
+++ b/mac_app/tests/test_crossing_ledger.py
@@ -0,0 +1,437 @@
+"""Direction A section 9: native ledger controls, round trips and accessibility."""
+
+import copy
+import itertools
+from unittest import mock
+
+import AppKit
+
+from core import ways
+import test_part_edge_thirds as thirds
+from test_crossing_page_machines import BEE, SEA, Page, press, token
+
+
+class LedgerTests(Page):
+ layout = thirds.PartEdgeThirds.layout
+ row = thirds.PartEdgeThirds.row
+ picked = thirds.PartEdgeThirds.picked
+ pick_thirds = thirds.PartEdgeThirds.pick_thirds
+ whole_edge = thirds.PartEdgeThirds.whole_edge
+
+ def rebuilt(self):
+ window = self.build([(peer["id"], peer["token"], peer["name"],
+ {key: value for key, value in peer.items() if key not in ("id", "token", "name")})
+ for peer in self.store.current()["peers"]], self.store.current()["zones"])
+ window.atlas_canvas.setFrame_(((0, 0), (480, window.atlas_canvas.HEIGHT)))
+ window.atlas_canvas._draw(False)
+ return window
+
+ def test_seven_third_combinations_rebuild_to_same_cells_and_map(self):
+ self.layout()
+ for count in (1, 2, 3):
+ for combination in itertools.combinations(ways.PARTS, count):
+ with self.subTest(thirds=combination):
+ self.pick_thirds(combination)
+ self.assertEqual(self.store.current()["peers"][0]["ways"]["thirds"], list(combination))
+ self.rebuilt()
+ self.assertEqual(self.picked(), list(combination))
+ self.assertEqual(self.window.atlas_canvas.states[BEE]["picked_thirds"], list(combination))
+
+ def test_last_ledger_segment_off_then_off_click_lights_only_that_segment(self):
+ self.layout()
+ self.pick_thirds(["start"])
+ press(self.row().edge_glyph.hits["start"])
+ self.assertEqual(self.row().edge_text, "Off")
+ self.assertEqual(self.picked(), [])
+ self.assertFalse(self.store.current()["peers"][0]["ways"]["edge"])
+ press(self.row().edge_glyph.hits["middle"])
+ self.assertEqual(self.picked(), ["middle"])
+ press(self.row().edge_detail)
+ self.assertEqual(self.picked(), [])
+ press(self.row().edge_title)
+ self.assertEqual(self.picked(), list(ways.PARTS))
+
+ def test_every_corner_on_and_off_survives_page_rebuild(self):
+ self.layout()
+ for corner in ways.CORNERS:
+ with self.subTest(corner=corner):
+ press(self.row().corner_glyph.hits[corner])
+ self.assertIn("corner", self.ways_of(BEE)["methods"])
+ self.assertEqual(self.ways_of(BEE)["corner"], corner)
+ self.rebuilt()
+ self.assertEqual(self.row().corner_title.text, corner.replace("_", " ").capitalize())
+ self.assertEqual(self.row().corner_glyph.hits[corner].accessibilityValue(), "on")
+ self.assertIn((BEE, "corner", corner), self.window.atlas_canvas.mark_layers)
+ press(self.row().corner_glyph.hits[corner])
+ self.rebuilt()
+ self.assertNotIn("corner", self.ways_of(BEE)["methods"])
+ self.assertEqual(self.row().corner_title.text, "None")
+
+ def test_second_corner_moves_and_another_machines_corner_refuses_the_click(self):
+ self.layout(second=True)
+ row = self.row()
+ press(row.corner_glyph.hits["top_left"])
+ press(row.corner_glyph.hits["bottom_right"])
+ self.assertEqual(self.ways_of(BEE)["corner"], "bottom_right")
+ sea = self.window.crossing_ledger.rows[SEA]
+ self.assertFalse(sea.corner_glyph.hits["bottom_right"].isEnabled())
+ self.assertEqual(sea.corner_glyph.hits["bottom_right"].toolTip(), "Bee's corner")
+ before = copy.deepcopy(self.store.current())
+ press(sea.corner_glyph.hits["bottom_right"])
+ self.assertEqual(self.store.current(), before)
+
+ def test_notch_on_and_off_rebuild_and_no_notch_is_disabled(self):
+ self.layout()
+ self.window.has_notch = True
+ for on in (True, False):
+ self.row().notch.setState_(int(on))
+ press(self.row().notch)
+ self.assertEqual("notch" in self.ways_of(BEE)["methods"], on)
+ self.rebuilt()
+ self.window.has_notch = True
+ self.window._show_arrangement()
+ self.assertEqual(self.row().notch.state(), int(on))
+ self.row().notch.setState_(1)
+ press(self.row().notch)
+ self.window.has_notch = False
+ self.window._show_arrangement()
+ self.assertEqual(self.row().no_notch.text, "No notch")
+ self.assertFalse(self.row().no_notch.view.isHidden())
+ self.assertEqual(self.row().notch.accessibilityLabel(), "Notch, no notch")
+ self.assertFalse(self.row().notch.isEnabled())
+
+ def test_cycle_tick_and_jump_chord_round_trip_without_changing_ways(self):
+ self.layout()
+ before = self.ways_of(BEE)
+ for on in (False, True):
+ self.row().cycle.setState_(int(on))
+ press(self.row().cycle)
+ self.rebuilt()
+ self.assertEqual(self.row().cycle.state(), int(on))
+ import widgets
+ recorder = self.row().jump
+ event = mock.Mock()
+ event.type.return_value = AppKit.NSEventTypeKeyDown
+ event.modifierFlags.return_value = AppKit.NSEventModifierFlagCommand
+ event.keyCode.return_value = next(code for code, name in widgets.SPECIAL_KEY_NAMES.items() if name == "f18")
+ event_api = mock.Mock()
+ event_api.addLocalMonitorForEventsMatchingMask_handler_.return_value = object()
+ with mock.patch.object(widgets.AppKit, "NSEvent", event_api):
+ recorder._clicked()
+ self.assertIsNotNone(recorder.monitor)
+ self.assertIsNone(recorder._recorded(event))
+ self.assertIsNone(recorder.monitor)
+ self.rebuilt()
+ self.assertEqual(self.row().jump.value, "cmd+f18")
+ self.assertIn("F18", self.row().jump.view.toolTip())
+ self.assertEqual(self.ways_of(BEE), before)
+ press(self.row().clear)
+ self.assertEqual(self.row().jump.value, "")
+
+ def test_offline_row_is_dimmed_but_ways_remain_live_and_saved(self):
+ self.layout()
+ self.window.windows_input.server.links.return_value = []
+ self.window._show_arrangement()
+ row = self.row()
+ self.assertTrue(row.dimmed)
+ self.assertEqual(row.status_text, "Windows · Offline, ways kept")
+ self.assertEqual(row.cells["edge"].alphaValue(), .5)
+ self.assertTrue(row.edge_glyph.hits["start"].isEnabled())
+ press(row.edge_glyph.hits["middle"])
+ self.assertEqual(self.picked(), ["start", "end"])
+
+ def test_armed_jump_survives_a_cell_refresh_and_escape_cancels(self):
+ import widgets
+ self.layout()
+ recorder = self.row().jump
+ event_api = mock.Mock()
+ event_api.addLocalMonitorForEventsMatchingMask_handler_.return_value = object()
+ with mock.patch.object(widgets.AppKit, "NSEvent", event_api):
+ recorder._clicked()
+ prompt = recorder.key.text
+ press(self.row().edge_glyph.hits["start"])
+ self.assertIsNotNone(recorder.monitor)
+ self.assertEqual(recorder.key.text, prompt)
+ escape = mock.Mock()
+ escape.type.return_value = AppKit.NSEventTypeKeyDown
+ escape.modifierFlags.return_value = 0
+ escape.keyCode.return_value = 53
+ self.assertIsNone(recorder._recorded(escape))
+ self.assertIsNone(recorder.monitor)
+ self.assertEqual(recorder.value, "")
+
+ def test_arming_another_row_cancels_the_first_without_dropping_the_guard(self):
+ import widgets
+ self.layout(second=True)
+ ledger = self.window.crossing_ledger
+ first, second = ledger.rows[BEE].jump, ledger.rows[SEA].jump
+ event_api = mock.Mock()
+ event_api.addLocalMonitorForEventsMatchingMask_handler_.side_effect = [object(), object()]
+ with mock.patch.object(widgets.AppKit, "NSEvent", event_api):
+ first._clicked()
+ with mock.patch.object(self.window, "_jump_arming", wraps=self.window._jump_arming) as guard:
+ second._clicked()
+ self.assertIsNone(first.monitor)
+ self.assertIsNotNone(second.monitor)
+ self.assertTrue(self.controller.jump_recording)
+ self.assertTrue(all(call.args[0] for call in guard.call_args_list))
+ first.cancel()
+ self.assertTrue(self.controller.jump_recording)
+ second.cancel()
+ self.assertFalse(self.controller.jump_recording)
+
+ def test_in_use_false_disables_kept_glyphs_like_left_out(self):
+ self.layout()
+ settings = self.store.current()
+ settings["peers"][0]["in_use"] = False
+ self.store.save_settings(settings)
+ self.window._show_arrangement()
+ row = self.row()
+ self.assertIn("Left out", row.status_text)
+ for glyph in (row.edge_glyph, row.corner_glyph):
+ for button in glyph.hits.values():
+ self.assertFalse(button.isEnabled())
+ self.assertEqual(button.toolTip(), "Left out: Put back to change its ways")
+
+ def test_glyphs_sit_left_of_top_aligned_text_in_both_layouts(self):
+ self.layout()
+ for width in (687, 399):
+ self.window.crossing_ledger.setFrameSize_((width, 700))
+ row = self.row()
+ for glyph, title, detail in ((row.edge_glyph, row.edge_title, row.edge_detail),
+ (row.corner_glyph, row.corner_title.view, row.corner_detail.view)):
+ self.assertGreaterEqual(title.frame().origin.x,
+ glyph.frame().origin.x + glyph.frame().size.width)
+ self.assertEqual(title.frame().origin.y, 0)
+ self.assertEqual(detail.frame().origin.x, title.frame().origin.x)
+ self.assertLessEqual(detail.frame().origin.y + detail.frame().size.height,
+ row.cells["edge"].frame().size.height)
+
+ def test_standard_width_corner_text_fits_on_one_line_and_elides_when_constrained(self):
+ __import__("theme").init_fonts()
+ self.layout()
+ press(self.row().corner_glyph.hits["bottom_left"])
+ ledger = self.window.crossing_ledger
+ ledger.setFrameSize_((687, 700))
+ for label in (self.row().corner_title, self.row().corner_detail):
+ view = label.view
+ self.assertGreaterEqual(view.frame().size.width - 4,
+ view.attributedStringValue().size().width)
+ self.assertFalse(view.cell().wraps())
+ self.assertEqual(view.cell().lineBreakMode(), AppKit.NSLineBreakByTruncatingTail)
+ self.assertEqual(view.toolTip(), label.text)
+ ledger.setFrameSize_((620, 700))
+ self.assertEqual(self.row().corner_title.text, "Bottom left")
+ self.assertEqual(self.row().corner_detail.view.toolTip(), "diagonal push")
+
+ def test_selected_machine_status_dot_is_inset_from_the_rule_at_both_widths(self):
+ self.layout()
+ for width in (687, 399):
+ self.window.crossing_ledger.setFrameSize_((width, 700))
+ row = self.row()
+ self.assertTrue(row.selected)
+ machine = row.cells["machine"].frame()
+ self.assertGreaterEqual(machine.origin.x + 1, 12)
+ self.assertGreaterEqual(machine.origin.x + row.name.view.frame().origin.x, 12)
+ self.assertGreaterEqual(row.status.view.frame().origin.x, 12)
+
+ def test_jump_idle_is_a_text_button_or_fitted_chip_and_only_armed_is_a_field(self):
+ import widgets
+ self.layout()
+ row = self.row()
+ self.window.crossing_ledger.setFrameSize_((687, 700))
+ self.assertGreaterEqual(row.jump_caption.view.frame().size.width - 4,
+ row.jump_caption.view.attributedStringValue().size().width)
+ self.assertEqual(row.jump.key.text, "Set a key")
+ self.assertEqual(row.jump.view.layer().borderWidth(), 0)
+ row.jump.on_change("cmd+f18")
+ chip = row.jump.view
+ self.assertEqual(chip.layer().cornerRadius(), 4)
+ self.assertEqual(chip.layer().borderWidth(), 1)
+ self.assertTrue(row.jump.key.mono)
+ self.assertEqual(row.jump.key.size, __import__("theme").TYPE["small"])
+ self.assertGreaterEqual(chip.frame().size.width, row.jump.key.view.attributedStringValue().size().width + 12)
+ self.assertFalse(row.clear.isHidden())
+ self.assertEqual(row.clear.frame().origin.y, chip.frame().origin.y)
+ idle_height = chip.frame().size.height
+ event_api = mock.Mock()
+ event_api.addLocalMonitorForEventsMatchingMask_handler_.return_value = object()
+ with mock.patch.object(widgets.AppKit, "NSEvent", event_api):
+ row.jump._clicked()
+ self.assertGreater(chip.frame().size.height, idle_height)
+ self.assertFalse(row.jump.hint.view.isHidden())
+ row.jump.cancel()
+ self.assertEqual(chip.frame().size.height, idle_height)
+
+ def test_narrow_block_insets_every_cell_from_the_selection_rule(self):
+ self.layout(second=True)
+ ledger = self.window.crossing_ledger
+ ledger.setFrameSize_((399, 700))
+ for row in ledger.rows.values():
+ for key in ("edge", "corner", "notch", "keys"):
+ self.assertGreaterEqual(row.cells[key].frame().origin.x, 10)
+ self.assertGreaterEqual(row.cells["machine"].frame().origin.y, 12)
+ self.assertGreaterEqual(row.cells["keys"].frame().origin.y,
+ row.cells["edge"].frame().origin.y + row.cells["edge"].frame().size.height)
+ self.assertLess(row.frame().size.height, 250)
+
+ def test_left_out_row_keeps_intent_and_put_back_restores_controls(self):
+ self.layout()
+ before = self.ways_of(BEE)
+ press(self.row().leave)
+ row = self.row()
+ self.assertTrue(row.dimmed)
+ self.assertEqual(row.status_text, "Windows · Left out")
+ self.assertIn("Put back", row.leave.accessibilityLabel())
+ self.assertFalse(row.edge_glyph.hits["start"].isEnabled())
+ self.assertFalse(row.corner_glyph.hits["top_left"].isEnabled())
+ held = copy.deepcopy(self.store.current())
+ press(row.edge_glyph.hits["start"])
+ press(row.corner_glyph.hits["top_left"])
+ self.assertEqual(self.store.current(), held)
+ self.assertEqual(self.ways_of(BEE), before)
+ press(row.leave)
+ self.assertFalse(self.row().dimmed)
+ self.assertTrue(self.row().edge_glyph.hits["start"].isEnabled())
+ self.assertEqual(self.ways_of(BEE), before)
+
+ def test_row_order_follows_map_position_and_left_out_stays_present(self):
+ window = self.layout(second=True)
+ self.assertEqual(window.crossing_ledger.order, [SEA, BEE])
+ press(window.crossing_ledger.rows[SEA].leave)
+ self.assertIn(SEA, window.crossing_ledger.order)
+
+ def test_no_contact_disables_edge_while_corner_stays_clickable(self):
+ self.layout()
+ settings = self.store.current()
+ settings["layout"][BEE]["x"] += 100
+ self.store.save_settings(settings)
+ self.window._show_arrangement()
+ self.assertEqual(self.row().edge_text, "Off")
+ self.assertEqual(self.row().edge_detail.attributedTitle().string(), "place it on the map")
+ self.assertFalse(self.row().edge_title.isEnabled())
+ before = copy.deepcopy(self.store.current())
+ press(self.row().edge_glyph.hits["start"])
+ self.assertEqual(self.store.current(), before)
+ press(self.row().corner_glyph.hits["top_left"])
+ self.assertIn("corner", self.ways_of(BEE)["methods"])
+
+ def test_narrow_cells_and_visible_controls_fit_inside_the_ledger(self):
+ self.layout()
+ self.row().jump.on_change("cmd+f18")
+ ledger = self.window.crossing_ledger
+ ledger.setFrameSize_((440, 700))
+ self.assertTrue(all(header.view.isHidden() for header in ledger.headers))
+ row = self.row()
+ self.assertEqual(row.cells["machine"].frame().origin.x + row.cells["machine"].frame().size.width, 440)
+ self.assertEqual(row.cells["edge"].frame().origin.y, row.cells["corner"].frame().origin.y)
+ self.assertEqual(row.cells["notch"].frame().origin.y, row.cells["keys"].frame().origin.y)
+ for cell in row.cells.values():
+ frame = cell.frame()
+ self.assertGreaterEqual(frame.origin.x, 0)
+ self.assertLessEqual(frame.origin.x + frame.size.width, 440)
+ for control in cell.subviews():
+ if not control.isHidden():
+ frame = control.frame()
+ self.assertGreaterEqual(cell.frame().origin.x + frame.origin.x, 0)
+ self.assertLessEqual(frame.origin.x + frame.size.width, cell.bounds().size.width)
+ self.assertLessEqual(cell.frame().origin.y + frame.origin.y + frame.size.height,
+ row.frame().size.height)
+
+ def test_window_width_selects_table_or_stacked_rows_without_sideways_scroll(self):
+ from mac_app.tests.design_offscreen import settle
+ from mac_app.tests.settings_layout_offscreen import measure
+ self.layout(second=True)
+ self.window._select_page("crossing")
+ for width, narrow in ((960, False), (640, True), (1440, False)):
+ with self.subTest(width=width):
+ self.window.window.setFrame_display_(((100000, 100000), (width, 900)), False)
+ for _ in range(4):
+ settle(self.window.window)
+ table = self.window.crossing_ledger
+ self.assertEqual(table.bounds().size.width < 620, narrow)
+ self.assertEqual(all(header.view.isHidden() for header in table.headers), narrow)
+ self.assertFalse(self.window.pages["crossing"].hasHorizontalScroller())
+ self.assertEqual(measure(self.window, "crossing")["overflows"], [])
+ self.assertFalse(self.window.window.isVisible())
+
+ def test_glyph_hit_bands_reach_the_button_outside_the_screen_outline(self):
+ for side in ways.EDGES:
+ self.layout(side)
+ self.window._select_page("crossing")
+ self.window.crossing_ledger.setFrameSize_((700, 700))
+ row = self.row()
+ cell = row.cells["edge"]
+ glyph = row.edge_glyph
+ band = glyph.hits["middle"]
+ frame = band.frame()
+ if side in ("top", "bottom"):
+ point = (frame.origin.x + frame.size.width / 2,
+ frame.origin.y + (1 if side == "top" else frame.size.height - 1))
+ else:
+ point = (frame.origin.x + (1 if side == "left" else frame.size.width - 1),
+ frame.origin.y + frame.size.height / 2)
+ point = (glyph.frame().origin.x + point[0], glyph.frame().origin.y + point[1])
+ point = (cell.frame().origin.x + point[0], cell.frame().origin.y + point[1])
+ with self.subTest(side=side):
+ self.assertIs(cell.hitTest_(point), band)
+
+ def test_changes_keep_the_same_row_controls_and_do_not_hide_the_ledger(self):
+ self.layout()
+ row = self.row()
+ controls = list(row.edge_glyph.hits.values()) + list(row.corner_glyph.hits.values())
+ with mock.patch("motion.set_hidden", wraps=__import__("motion").set_hidden) as hidden:
+ press(row.edge_glyph.hits["middle"])
+ press(row.corner_glyph.hits["top_left"])
+ self.assertIs(self.row(), row)
+ self.assertEqual(controls, list(row.edge_glyph.hits.values()) + list(row.corner_glyph.hits.values()))
+ self.assertFalse(self.window.crossing_ledger.isHidden())
+ self.assertFalse(any(call.args[0] in (row, self.window.crossing_ledger) for call in hidden.call_args_list))
+
+ def test_accessibility_table_rows_columns_named_segment_states_and_text_button(self):
+ self.layout("top")
+ ledger, row = self.window.crossing_ledger, self.row()
+ self.assertEqual(ledger.accessibilityRole(), AppKit.NSAccessibilityTableRole)
+ self.assertEqual(row.accessibilityRole(), AppKit.NSAccessibilityRowRole)
+ self.assertEqual(ledger.accessibilityRows(), [row])
+ self.assertEqual(len(ledger.accessibilityColumns()), 5)
+ self.assertEqual(row.accessibilityLabel(), "Bee")
+ button = row.edge_glyph.hits["start"]
+ self.assertEqual(button.accessibilityRole(), AppKit.NSAccessibilityButtonRole)
+ self.assertEqual(button.accessibilityLabel(), "Top edge, left third, on")
+ press(button)
+ self.assertEqual(button.accessibilityLabel(), "Top edge, left third, off")
+ corner = row.corner_glyph.hits["top_left"]
+ self.assertEqual(corner.accessibilityLabel(), "Top left corner, off")
+ press(corner)
+ self.assertEqual(corner.accessibilityLabel(), "Top left corner, on")
+ self.whole_edge()
+ self.assertEqual(row.edge_title.accessibilityLabel(), "Edge, whole top edge")
+ press(row.edge_title)
+ self.assertEqual(row.edge_title.accessibilityLabel(), "Edge, off")
+
+ def test_inline_rename_cancel_and_save_use_the_same_row(self):
+ self.layout()
+ row = self.row()
+ press(row.rename)
+ self.assertTrue(row.renaming)
+ self.assertEqual(row.rename_hint.text, "Return saves, Escape cancels")
+ row.name_field.setStringValue_("Cancelled")
+ row.finish_rename(False)
+ self.assertEqual(row.name.text, "Bee")
+ press(row.rename)
+ row.name_field.setStringValue_("Studio PC")
+ row.finish_rename(True)
+ self.assertIs(self.row(), row)
+ self.assertEqual(row.name.text, "Studio PC")
+
+ def test_inline_rename_scope_stays_inside_machine_cell_before_the_next_block(self):
+ self.layout()
+ self.controller.cfg.same_on_both = False
+ row = self.row()
+ press(row.rename)
+ for width in (399, 687):
+ self.window.crossing_ledger.setFrameSize_((width, 700))
+ self.assertFalse(row.scope.view.isHidden())
+ scope = row.scope.view.frame()
+ self.assertLessEqual(scope.origin.y + scope.size.height, row.cells["machine"].frame().size.height)
diff --git a/mac_app/tests/test_crossing_matrix.py b/mac_app/tests/test_crossing_matrix.py
index 6f69607..6e46039 100644
--- a/mac_app/tests/test_crossing_matrix.py
+++ b/mac_app/tests/test_crossing_matrix.py
@@ -8,11 +8,12 @@ import os
import sys
import types
import unittest
+from unittest import mock
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
from bridge_fakes import PAIRED_TOKEN, FakeQuartz, crossing_config
-from core import protocol
+from core import protocol, return_edge, ways
from core.tests.responder_harness import HERE
from crossing import CORNERS, EDGES, OPPOSITE, CrossingEngine
from settings_store import config_to_raw
@@ -25,6 +26,14 @@ PC_EDGE_POINT = {"left": (0, 540), "right": (1919, 540), "top": (960, 0), "botto
MAC_EDGE_POINT = {"left": (0, 558), "right": (1727, 558), "top": (863, 0), "bottom": (863, 1116)}
+def setUpModule():
+ # These push home the moment input lands; the arrival grace is test_arrival_grace's subject,
+ # not theirs, as in test_way_home and core's loopback tests.
+ grace = mock.patch.object(return_edge, "ARRIVAL_GRACE_SECONDS", 0.0)
+ grace.start()
+ unittest.addModuleCleanup(grace.stop)
+
+
def side_point(side, third):
f = THIRDS[third]
return {
@@ -167,15 +176,17 @@ class ArrangementFromEitherSideTests(unittest.TestCase):
def window(self, edge="right", stamp=0):
cfg = crossing_config(edge=edge, arrangement_set_at=stamp)
self.store.save(config_to_raw(cfg))
+ settings = self.store.current()
+ self.peer = protocol.id_text(HERE)
+ settings["peers"][0].update(id=self.peer, side=edge, side_set_at=stamp, side_by=self.SMALL)
+ settings["layout"] = ways.derive_layout(settings, gap=0)
+ self.store.save_settings(settings)
cfg = self.store.load()
self.rebuilt = 0
self.told = []
- def zones_changed():
- self.rebuilt += 1
-
- return types.SimpleNamespace(
- controller=types.SimpleNamespace(cfg=cfg, crossing=None, zones_changed=zones_changed, _alert=lambda *a: None),
+ window = types.SimpleNamespace(
+ controller=types.SimpleNamespace(cfg=cfg),
settings_store=self.store,
logger=types.SimpleNamespace(info=lambda *a: self.logged.append(a), exception=lambda *a: None),
refresh=lambda: None,
@@ -183,11 +194,26 @@ class ArrangementFromEitherSideTests(unittest.TestCase):
_flush=lambda: None,
_tell=lambda peer: self.told.append(peer),
_live=lambda peer: True,
+ _crossing_args=lambda: dict(platform="mac", capable=(), live=lambda peer: True,
+ gone=lambda peer: False, now=10000),
)
+ def carry(outcome):
+ if outcome["changed"]:
+ self.store.save_settings(outcome["settings"])
+ window.controller.cfg = self.store.load()
+ self.rebuilt += 1
+ self.told.extend(outcome["tell"])
+ window._carry_crossing = carry
+ def event(handler, *args, **options):
+ outcome = handler(self.store.current(), *args, **options)
+ carry(outcome)
+ return outcome
+ window.controller.crossing_event = event
+ return window
def test_a_newer_arrangement_from_the_pc_is_applied_with_its_stamp_and_arms_the_new_edge(self):
window = self.window("right", stamp=100)
- self.apply(window, "", "right", 200, self.BY)
+ self.apply(window, self.peer, "right", 200, self.BY)
self.assertEqual(window.controller.cfg.crossing["edge"], "left")
self.assertEqual(window.controller.cfg.crossing["arrangement_set_at"], 200)
self.assertEqual(self.rebuilt, 1)
@@ -196,21 +222,21 @@ class ArrangementFromEitherSideTests(unittest.TestCase):
def test_an_older_one_is_ignored(self):
window = self.window("right", stamp=200)
- self.apply(window, "", "right", 100, self.BY)
+ self.apply(window, self.peer, "right", 100, self.BY)
self.assertEqual(window.controller.cfg.crossing["edge"], "right")
self.assertEqual(self.rebuilt, 0)
def test_the_same_one_over_the_second_link_changes_nothing_the_second_time(self):
window = self.window("left", stamp=300)
- self.apply(window, "", "left", 400, self.BY)
- self.apply(window, "", "left", 400, self.BY)
+ self.apply(window, self.peer, "left", 400, self.BY)
+ self.apply(window, self.peer, "left", 400, self.BY)
self.assertEqual(self.rebuilt, 1)
def test_two_different_arrangements_stamped_in_the_same_second_settle_on_the_larger_id(self):
window = self.window("right", stamp=300)
- self.apply(window, "", "right", 300, self.SMALL)
+ self.apply(window, self.peer, "right", 300, self.SMALL)
self.assertEqual(window.controller.cfg.crossing["edge"], "right")
- self.apply(window, "", "right", 300, self.BY)
+ self.apply(window, self.peer, "right", 300, self.BY)
self.assertEqual(window.controller.cfg.crossing["edge"], "left")
@@ -269,14 +295,14 @@ class ArrangementOverTheLinksTests(unittest.TestCase):
peer, read = duo.pc_responder.arrangements[0]
self.assertEqual((read["edge"], read["set_at"], read["by"]), ("top", 300, HERE))
- def test_the_one_machine_never_placed_is_announced_on_the_right_unstamped_as_the_page_shows_it(self):
+ def test_an_unplaced_machine_sends_no_legacy_side_until_one_is_explicit(self):
duo = self.duo(side="")
duo.link_mac_to_pc()
# What a link announces goes before anything sent after it, so this one is the fence.
self.assertTrue(duo.mac.send_arrangement(protocol.id_text(HERE), "left", 9))
self.assertTrue(wait_for(lambda: self.heard(duo, 9)))
self.assertEqual([(read["edge"], read["set_at"]) for _, read in duo.pc_responder.arrangements],
- [("right", 0), ("left", 9)])
+ [("left", 9)])
class WhatIsSharedTests(unittest.TestCase):
@@ -486,16 +512,14 @@ class MacDrivenTests(unittest.TestCase):
self.assertIsNotNone(duo.pc_switch(), "this Mac's left edge never led home")
duo.close()
- def test_a_mac_whose_one_machine_was_never_placed_leads_home_through_the_right_it_shows(self):
+ def test_an_unplaced_machine_has_no_invented_edge_way_home(self):
duo = self.duo(side="")
duo.link_pc_to_mac()
duo.pc_drives("left", 0.5)
- for edge in [edge for edge in EDGES if edge != "right"]:
+ for edge in EDGES:
duo.pc_leans(MAC_EDGE_POINT[edge], *outward(edge), times=3)
self.assertIsNone(duo.pc_switch(0.2), edge)
self.assertTrue(duo.mac.receiving)
- duo.pc_leans(MAC_EDGE_POINT["right"], *outward("right"), times=3)
- self.assertIsNotNone(duo.pc_switch(), "the right edge the page shows never led home")
def test_a_pc_this_mac_does_not_allow_to_drive_it_is_refused(self):
duo = self.duo(allow_drive=False)
diff --git a/mac_app/tests/test_crossing_page_machines.py b/mac_app/tests/test_crossing_page_machines.py
index fd4e4ea..77a70a7 100644
--- a/mac_app/tests/test_crossing_page_machines.py
+++ b/mac_app/tests/test_crossing_page_machines.py
@@ -1,7 +1,4 @@
-"""The Crossing page with several machines paired, in the real settings window (WIRE.md sections 5
-and 8): a machine is chosen at the top of Ways in, everything per machine below it shows and writes
-that machine's ways, the drawing places every machine, and the menu bar sends input to each. Built
-as the README's screenshots build it, never put on screen, starting no network."""
+"""The offscreen Crossing page: stable per-machine ledger rows and menu routing."""
import base64
import copy
@@ -15,18 +12,18 @@ from unittest import mock
sys.path.insert(0, str(Path(__file__).resolve().parents[2]))
-import AppKit # noqa: E402
-import rumps.rumps as rumps_module # noqa: E402
+import AppKit
+import rumps.rumps as rumps_module
AppKit.NSApplication.sharedApplication()
-import bridge # noqa: E402
-import kvm_bridge_app # noqa: E402
-import settings_store # noqa: E402
-from bridge_fakes import PAIRED_TOKEN # noqa: E402
-from core import protocol, ways # noqa: E402
-from fake_link import FakeLink # noqa: E402
-from wake import WakingController # noqa: E402
+import bridge
+import kvm_bridge_app
+import settings_store
+from bridge_fakes import PAIRED_TOKEN
+from core import protocol, ways
+from fake_link import FakeLink
+from wake import WakingController
BEE = protocol.id_text(bytes(range(40, 56)))
SEA = protocol.id_text(bytes(range(70, 86)))
@@ -43,11 +40,13 @@ def entry(ident, secret, name, side="", own="", **extra):
"side_set_at": 100 if side else 0, "side_by": own if side else "", **extra}
-class Page(unittest.TestCase):
- """This Mac with Bee on its right by its edge, and Sea on its left by its top third."""
+def press(button):
+ button._ledger_target.fire_(button)
+
+class Page(unittest.TestCase):
def setUp(self):
- self.directory = tempfile.TemporaryDirectory()
+ self.directory = tempfile.TemporaryDirectory(dir=Path(__file__).resolve().parents[1])
self.addCleanup(self.directory.cleanup)
path = Path(self.directory.name) / "config.json"
raw = settings_store.config_to_raw(settings_store.editable_default_config())
@@ -66,9 +65,10 @@ class Page(unittest.TestCase):
settings["zones"] = list(zones)
self.store.save_settings(settings)
logger = logging.getLogger("test-crossing-page-machines")
- book, identity = bridge.links_from_store(self.store, "1.5.0")
+ book, identity = bridge.links_from_store(self.store, "1.5.2")
self.controller = WakingController(self.store.load(), logger=logger, book=book, identity=identity,
link_factory=FakeLink)
+ self.controller.start_input_capture = mock.Mock()
with mock.patch.object(kvm_bridge_app, "accessibility_granted", return_value=True), \
mock.patch.object(kvm_bridge_app, "input_monitoring_granted", return_value=True):
self.window = kvm_bridge_app.ControlWindow.alloc().initWithController_settingsStore_logger_(
@@ -76,13 +76,14 @@ class Page(unittest.TestCase):
self.addCleanup(self.window.appearance_watch.stop)
self.window.windows_input = mock.Mock()
self.window.windows_input.send_arrangement.return_value = True
- # Every machine linked to this Mac: one with no link gives way instead (core/ways.py give_way).
self.window.windows_input.server.links.return_value = [protocol.read_id(peer[0]) for peer in peers]
self.window.windows_input.server.caps_of.return_value = None
+ self.window.windows_input.server.owner = None
self.sent = []
self.sent_by = []
self.controller.send_arrangement = lambda peer, edge, set_at, by=None: (
self.sent.append((peer, edge, set_at)) or self.sent_by.append(by) or True)
+ self.window._show_arrangement()
return self.window
def two(self):
@@ -95,518 +96,84 @@ class Page(unittest.TestCase):
return ways.ways(self.store.current(), peer)
def methods(self):
- return [name for name, tile in self.window.method_boxes.items() if tile.value]
+ return self.ways_of(self.window.chosen_peer)["methods"]
def toggle(self, way):
- self.window.method_boxes[way]._toggle()
+ peer = self.window.chosen_peer
+ if way == "edge":
+ press(self.window.crossing_ledger.rows[peer].edge_title)
+ elif way == "corner":
+ self.window._ledger_corner(peer, self.ways_of(peer)["corner"])
+ elif way == "notch":
+ self.window._ledger_notch(peer, "notch" not in self.methods())
+ elif way == "shortcut":
+ self.window.method_boxes[way]._toggle()
+ else:
+ raise ValueError(way)
def pick(self, peer):
- self.window.machine_select._choose(peer)
-
-
-class OneOrNoMachine(Page):
- def test_with_one_machine_there_is_no_picker_and_the_page_reads_as_today(self):
- window = self.build([(BEE, token(100), "Bee", {"side": "left"})], [{"peer": BEE, "kind": "edge"}])
- self.assertTrue(window.machine_row.isHidden())
- self.assertEqual(window.edge_caption.text, "Where the other machine is")
- self.assertEqual(window.edge_select.value, "left")
- self.assertEqual(self.methods(), ["edge", "shortcut"])
-
- def test_one_machine_with_no_side_shows_right_as_it_always_has(self):
- window = self.build([(BEE, token(100), "Bee")])
- self.assertEqual(window.edge_select.value, "right")
-
- def test_one_machine_not_placed_holds_the_shown_right_unstamped_before_any_save_so_its_own_side_wins(self):
- window = self.build([(BEE, token(100), "Bee")], [{"peer": BEE, "kind": "edge"}])
- held = self.store.current()["peers"][0]
- self.assertEqual((held["side"], held["side_set_at"], held["side_by"]), ("right", 0, ""))
- window._apply_settings()
- self.assertEqual(self.sent, [])
- window.apply_arrangement(BEE, "bottom", 1_790_000_000, BEE, True)
- self.assertEqual(self.ways_of(BEE)["side"], "top")
-
-
-class SharingSide(Page):
- def build_blocked(self):
- window = self.build(
- [(BEE, token(100), "Bee", {"side": "right"}), (SEA, token(150), "Sea", {"side": "right"})],
- [{"peer": BEE, "kind": "edge"}, {"peer": SEA, "kind": "edge", "off": True}])
- window._machine_picked(SEA)
- window._select_page("crossing")
- return window
-
- def test_the_panel_offers_thirds_under_the_side_picker_and_replaces_the_blocked_sentence(self):
- window = self.build_blocked()
- self.assertFalse(window.share_box.isHidden())
- self.assertEqual([window.share_tiles[p].name.text for p in ("start", "middle", "end")],
- ["Top", "Middle", "Bottom"])
- self.assertEqual([window.share_tiles[p].detail.text for p in ("start", "middle", "end")],
- ["Bee", "Bee", "Sea"])
- self.assertTrue(window.blocked_note.view.isHidden())
-
- def test_a_tile_moves_to_the_next_machine_and_share_writes_and_tells_both(self):
- window = self.build_blocked()
- window.share_tiles["start"]._toggle()
- self.assertEqual(window.share_tiles["start"].detail.text, "Sea")
- window._share_side()
- zones = {(z["peer"], z["kind"]): z for z in self.store.current()["zones"]}
- self.assertEqual(zones[(BEE, "part")]["parts"], ["middle"])
- self.assertEqual(zones[(SEA, "part")]["parts"], ["start", "end"])
- self.assertTrue(zones[(BEE, "edge")].get("off"))
- self.assertTrue(zones[(SEA, "edge")].get("off"))
- self.assertEqual({peer for peer, _edge, _stamp in self.sent}, {BEE, SEA})
-
- def test_turning_on_edge_keeps_it_off_and_focuses_the_share_panel(self):
- window = self.build_blocked()
- self.toggle("edge")
- window._flush()
- self.assertFalse(window.method_boxes["edge"].value)
- self.assertFalse(window.share_box.isHidden())
- self.assertTrue(window.blocked_note.view.isHidden())
- self.assertIs(window.window.firstResponder(), window.share_button.view)
-
- def test_edge_turns_on_over_a_machine_with_no_link_and_that_machines_edge_goes_off(self):
- # 06-10-2026: a machine gone for good held the side, and Edge would not turn on until it was moved.
- window = self.build_blocked()
- window.windows_input.server.links.return_value = [protocol.read_id(SEA)]
- window._show_machines()
- self.assertTrue(window.share_box.isHidden())
- self.toggle("edge")
- window._flush()
- self.assertTrue(window.method_boxes["edge"].value)
- zones = {(zone["peer"], zone["kind"]): zone for zone in self.store.current()["zones"]}
- self.assertTrue(zones[(BEE, "edge")].get("off"))
- self.assertTrue(zones[(BEE, "edge")].get("aside"))
- self.assertIsNone(zones[(SEA, "edge")].get("off"))
- self.assertIsNone(ways.clash(self.store.current(), "this Mac"))
-
- def lid_shut(self):
- """Sea given Bee's side while Bee, with its lid shut, has no link to this Mac."""
- window = self.build_blocked()
- window.windows_input.server.links.return_value = [protocol.read_id(SEA)]
- window._show_machines()
- self.toggle("edge")
- window._flush()
- return window
-
- def bee_zone(self):
- return next(zone for zone in self.store.current()["zones"] if zone["peer"] == BEE and zone["kind"] == "edge")
-
- def test_a_machine_with_its_lid_shut_has_its_edge_set_aside_and_gets_it_back_when_it_connects(self):
- window = self.lid_shut()
- self.assertEqual(self.bee_zone(), {"peer": BEE, "kind": "edge", "off": True, "aside": True})
- self.toggle("edge")
- window._flush()
- window.settle_presence()
- self.assertTrue(self.bee_zone().get("aside"))
- window.windows_input.server.links.return_value = [protocol.read_id(BEE), protocol.read_id(SEA)]
- self.sent.clear()
- window.settle_presence()
- self.assertEqual(self.bee_zone(), {"peer": BEE, "kind": "edge"})
- self.assertIn(BEE, {peer for peer, _edge, _stamp in self.sent})
- self.assertIsNone(ways.clash(self.store.current(), "this Mac"))
-
- def test_a_machine_back_over_a_side_another_holds_stays_off_and_the_page_offers_thirds(self):
- window = self.lid_shut()
- window.windows_input.server.links.return_value = [protocol.read_id(BEE), protocol.read_id(SEA)]
- window.settle_presence()
- self.assertEqual(self.bee_zone(), {"peer": BEE, "kind": "edge", "off": True})
- window._machine_picked(BEE)
- self.assertFalse(window.share_box.isHidden())
-
- def test_a_machine_that_removed_this_pairing_stays_off_for_good_and_the_page_says_so(self):
- window = self.lid_shut()
- link = FakeLink(token(100), self.controller.book, None)
- link.kind = "forgotten"
- self.controller.links[token(100)] = link
- alerts = []
- self.controller.on_user_alert = lambda title, message: alerts.append(message)
- window.settle_presence()
- self.assertEqual(self.bee_zone(), {"peer": BEE, "kind": "edge", "off": True})
- self.assertEqual(alerts, ["Bee no longer has this pairing, so its edge stays off. Remove Bee here and pair "
- "the two again."])
- window._machine_picked(BEE)
- self.assertIn("Bee no longer has this pairing", window.blocked_note.text)
- self.assertFalse(window.blocked_note.view.isHidden())
-
- def test_turning_on_an_overlapping_part_keeps_it_off_and_focuses_the_share_panel(self):
- window = self.build_blocked()
- self.toggle("part")
- window._flush()
- self.assertFalse(window.method_boxes["part"].value)
- self.assertFalse(window.share_box.isHidden())
- self.assertTrue(window.blocked_note.view.isHidden())
- self.assertIs(window.window.firstResponder(), window.share_button.view)
-
- def test_the_first_machine_paired_crosses_at_the_right_edge_the_page_shows_with_nothing_saved(self):
- # beta.4 on three machines: Edge showed on, the pointer did not cross until a Notch save wrote the side.
- window = self.build([])
- self.store.add_peer(entry(BEE, token(100), "Bee", linked=False))
- window.peers_changed()
- self.controller.cfg = self.store.load()
- self.controller.zones_changed()
- self.assertEqual(window.edge_select.value, "right")
- self.assertIn("edge", self.ways_of(BEE)["methods"])
- found = [(way.peer, way.edge, "edge" in way.methods) for way in self.controller.crossing.ways]
- self.assertEqual(found, [(BEE, "right", True)])
- self.assertEqual(self.sent, [])
-
- def test_a_second_machine_paired_is_given_no_side_and_the_first_keeps_its_right(self):
- window = self.build([(BEE, token(100), "Bee")], [{"peer": BEE, "kind": "edge"}])
- self.store.add_peer(entry(SEA, token(150), "Sea", linked=False))
- window.peers_changed()
- self.assertEqual([(peer["side"], peer["side_set_at"]) for peer in self.store.current()["peers"]],
- [("right", 0), ("", 0)])
-
- def test_with_one_machine_a_change_writes_its_ways_and_sends_it_the_side(self):
- window = self.build([(BEE, token(100), "Bee", {"side": "left"})], [{"peer": BEE, "kind": "edge"}])
- window.edge_select._choose("top")
- window._apply_settings()
- self.assertEqual(self.ways_of(BEE)["side"], "top")
- self.assertEqual([(peer, edge) for peer, edge, _at in self.sent], [(BEE, "top")])
-
- def test_with_none_paired_the_page_writes_the_flat_settings_as_today(self):
- window = self.build([])
- self.assertTrue(window.machine_row.isHidden())
- self.toggle("corner")
- window._apply_settings()
- self.assertIn("corner", self.store.load().crossing["methods"])
-
-
-class ChoosingAMachine(Page):
- def test_with_two_machines_the_picker_names_each_and_starts_on_the_first(self):
- window = self.two()
- self.assertFalse(window.machine_row.isHidden())
- self.assertEqual([title for _value, title in window.machine_select.choices], ["Bee", "Sea"])
- self.assertEqual(window.machine_select.value, BEE)
- self.assertEqual(window.edge_caption.text, "Where Bee is")
- self.assertEqual((window.edge_select.value, self.methods()), ("right", ["edge", "shortcut"]))
+ self.window._atlas_selected(peer)
- def test_the_picker_omits_machines_not_in_use_and_keeps_their_zones(self):
- window = self.two()
- zones = list(self.store.current()["zones"])
- self.store.set_peer(token(150), in_use=False)
- window._show_machines()
- self.assertEqual(window._picker_choices, [(BEE, "Bee")])
- self.assertTrue(window.machine_row.isHidden())
- self.assertEqual(self.store.current()["zones"], zones)
-
- def test_turning_off_the_chosen_machine_selects_an_active_machine(self):
- window = self.two()
- window._machine_picked(SEA)
- self.store.set_peer(token(150), in_use=False)
- window._show_machines()
- self.assertEqual(window.chosen_peer, BEE)
- self.assertTrue(window.machine_row.isHidden())
- def test_choosing_a_machine_shows_its_ways(self):
- window = self.two()
- self.pick(SEA)
- self.assertEqual(window.edge_caption.text, "Where Sea is")
- self.assertEqual(window.edge_select.value, "left")
- self.assertEqual(self.methods(), ["part", "corner", "shortcut"])
- self.assertEqual([name for name, tile in window.part_boxes.items() if tile.value], ["start"])
- self.assertEqual(window.corner_select.value, "bottom_left")
- self.assertEqual(window.push_strip.other_name, "Sea")
-
- def test_a_change_writes_the_chosen_machines_ways_and_leaves_the_others_alone(self):
- window = self.two()
- bee = self.ways_of(BEE)
- self.pick(SEA)
- self.toggle("notch")
- window._apply_settings()
- self.assertIn("notch", self.ways_of(SEA)["methods"])
- self.assertEqual(self.ways_of(BEE), bee)
- self.assertEqual(self.sent, [])
+class Machines(Page):
+ def test_no_paired_machine_has_no_ledger_rows(self):
+ self.assertEqual(self.build([]).crossing_ledger.rows, {})
- def test_a_new_side_is_sent_to_that_machine_and_over_its_own_link_when_this_macs_is_down(self):
- window = self.two()
- self.pick(SEA)
- window.edge_select._choose("top")
- window._apply_settings()
- stamp = next(peer for peer in self.store.current()["peers"] if peer["id"] == SEA)["side_set_at"]
- self.assertEqual(self.sent, [(SEA, "top", stamp)])
- window.windows_input.send_arrangement.assert_not_called()
- self.controller.send_arrangement = lambda *_args: False
- window.edge_select._choose("bottom")
- window._apply_settings()
- window.windows_input.send_arrangement.assert_called_once()
- self.assertEqual(window.windows_input.send_arrangement.call_args.args[:2], (SEA, "bottom"))
-
- def test_the_engine_is_built_again_once_a_machines_ways_change(self):
- window = self.two()
- self.pick(SEA)
- with mock.patch.object(self.controller, "zones_changed") as rebuilt:
- self.toggle("notch")
- window._apply_settings()
- rebuilt.assert_called()
+ def test_each_paired_desktop_has_a_named_row_and_phone_has_none(self):
+ window = self.build([(BEE, token(100), "Bee", {"side": "right"}),
+ (SEA, token(150), "Phone", {"platform": "ios", "port": 0})])
+ self.assertEqual(list(window.crossing_ledger.rows), [BEE])
+ self.assertEqual(window.crossing_ledger.rows[BEE].name.text, "Bee")
- def test_a_way_that_overlaps_an_existing_side_shows_the_share_panel_without_writing(self):
+ def test_selecting_a_row_only_changes_map_and_row_selection(self):
window = self.two()
- self.pick(SEA)
- # Moved onto Bee's side, Sea keeps the side and its ways there go off (core/ways.py settle).
- window.edge_select._choose("right")
- window._apply_settings()
- before = copy.deepcopy(self.store.current())
- self.toggle("edge")
- window._apply_settings()
- self.assertFalse(window.method_boxes["edge"].value)
- self.assertFalse(window.share_box.isHidden())
- self.assertIn("Bee already crosses from the right edge", window.share_sentence.text)
- self.assertTrue(window.blocked_note.view.isHidden())
- self.assertEqual(window.edge_select.value, "right")
- self.assertEqual(self.store.current()["zones"], before["zones"])
-
- def test_a_corner_clash_keeps_its_refusal_naming_both_and_the_controls_go_back(self):
- window = self.build(
- [(BEE, token(100), "Bee", {"side": "right"}), (SEA, token(150), "Sea", {"side": "right"})],
- [{"peer": BEE, "kind": "corner", "corner": "top_right", "edge": "right"},
- {"peer": SEA, "kind": "corner", "corner": "top_right", "edge": "right", "off": True}])
- self.pick(SEA)
before = copy.deepcopy(self.store.current())
- self.toggle("corner")
- window._apply_settings()
- self.assertEqual(window.message_label.ink, "fault")
- self.assertIn("Bee", window.message_label.text)
- self.assertIn("Sea", window.message_label.text)
- self.assertFalse(window.method_boxes["corner"].value)
- self.assertEqual(self.store.current()["zones"], before["zones"])
-
- def test_switching_machines_saves_a_change_still_waiting_first(self):
- window = self.two()
- self.toggle("corner")
- self.assertTrue(self.later)
self.pick(SEA)
- self.assertIn("corner", self.ways_of(BEE)["methods"])
- sea = self.ways_of(SEA)
- for call in self.later:
- call()
- self.assertEqual(self.ways_of(SEA), sea)
- self.assertEqual(self.methods(), ["part", "corner", "shortcut"])
-
- def test_the_shortcut_resistance_and_drag_guard_stay_this_macs_own(self):
- window = self.two()
- self.pick(SEA)
- held = (self.ways_of(BEE), self.ways_of(SEA))
- dragging = self.store.load().crossing["block_while_dragging"]
- self.toggle("shortcut")
- window.dragging_box._toggle()
- window._apply_settings()
- self.assertFalse(self.store.current()["shortcut"])
- self.assertNotIn("shortcut", self.store.load().crossing["methods"])
- self.assertEqual(self.store.load().crossing["block_while_dragging"], not dragging)
- self.assertEqual((self.ways_of(BEE), self.ways_of(SEA)), held)
- self.pick(BEE)
- self.assertFalse(window.method_boxes["shortcut"].value)
-
- def test_a_machine_with_no_side_shows_none_with_several_paired(self):
- window = self.build([(BEE, token(100), "Bee", {"side": "right"}), (OAK, token(200), "Oak")],
- [{"peer": BEE, "kind": "edge"}])
- self.pick(OAK)
- self.assertIsNone(window.edge_select.value or None)
- window._apply_settings()
- self.assertEqual(self.ways_of(OAK)["side"], "")
-
- def test_removing_the_chosen_machine_falls_back_to_the_first_and_one_left_hides_the_picker(self):
- window = self.two()
- self.pick(SEA)
- self.store.remove_peer(token(150))
- window.peers_changed()
- self.assertTrue(window.machine_row.isHidden())
- self.assertEqual(window.edge_select.value, "right")
- self.assertEqual(window.edge_caption.text, "Where the other machine is")
-
- def test_a_third_machine_paired_joins_the_picker(self):
- window = self.two()
- self.store.add_peer(entry(OAK, token(200), "Oak"))
- window.peers_changed()
- self.assertEqual([title for _value, title in window.machine_select.choices], ["Bee", "Sea", "Oak"])
-
- def test_a_name_learnt_on_a_link_reaches_the_picker_on_the_next_tick(self):
- window = self.two()
- settings = copy.deepcopy(self.store.current())
- settings["peers"][1]["name"] = "Sea Studio"
- self.store.save_settings(settings)
- window.refresh()
- self.assertEqual([title for _value, title in window.machine_select.choices], ["Bee", "Sea Studio"])
+ self.assertEqual(window.chosen_peer, SEA)
+ self.assertTrue(window.crossing_ledger.rows[SEA].selected)
+ self.assertFalse(window.crossing_ledger.rows[BEE].selected)
+ self.assertEqual(window.atlas_canvas.selected, SEA)
+ self.assertEqual(self.store.current(), before)
- def test_an_arrangement_from_the_chosen_machine_moves_its_control(self):
+ def test_peer_way_change_saves_immediately_and_preserves_other_peers(self):
window = self.two()
+ before = self.ways_of(BEE)
self.pick(SEA)
- window.apply_arrangement(SEA, "top", 5000, SEA)
- self.assertEqual(window.edge_select.value, "bottom")
- self.assertEqual(window.machine_select.value, SEA)
+ press(window.crossing_ledger.rows[SEA].edge_title)
+ self.assertFalse(set(self.ways_of(SEA)["methods"]) & {"edge", "part"})
+ self.assertEqual(self.ways_of(BEE), before)
+ self.assertFalse(window._save_pending)
- def test_an_arrangement_arriving_keeps_a_change_still_waiting(self):
+ def test_way_change_rearms_the_engine(self):
window = self.two()
- self.pick(SEA)
- self.toggle("notch")
- window.apply_arrangement(BEE, "right", 5000, BEE)
- self.assertIn("notch", self.ways_of(SEA)["methods"])
- self.assertTrue(window.method_boxes["notch"].value)
- self.assertEqual(self.ways_of(BEE)["side"], "left")
+ with mock.patch.object(self.controller, "zones_changed") as rebuilt:
+ press(window.crossing_ledger.rows[BEE].edge_title)
+ rebuilt.assert_called()
- def test_a_machine_paired_keeps_a_change_still_waiting(self):
+ def test_pairing_and_forgetting_add_and_remove_rows(self):
window = self.two()
- self.pick(SEA)
- self.toggle("notch")
- self.store.add_peer(entry(OAK, token(200), "Oak"))
+ row = window.crossing_ledger.rows[BEE]
+ self.store.add_peer(entry(OAK, token(180), "Oak"))
window.peers_changed()
- self.assertIn("notch", self.ways_of(SEA)["methods"])
- self.assertTrue(window.method_boxes["notch"].value)
-
- def test_a_change_waiting_for_a_machine_just_removed_is_dropped_without_a_fault(self):
- window = self.two()
- self.pick(SEA)
- self.toggle("notch")
+ self.assertIn(OAK, window.crossing_ledger.rows)
self.store.remove_peer(token(150))
window.peers_changed()
- self.assertNotIn(SEA, [item["id"] for item in self.store.current()["peers"]])
- self.assertEqual(window.machine_select, None)
-
- def test_a_missing_pairing_is_noted_under_the_ways(self):
- window = self.build([(BEE, token(100), "Bee", {"side": "right", "allow_drive": True, "paired_with": []}),
- (SEA, token(150), "Sea", {"side": "left", "allow_drive": True, "paired_with": [BEE]})],
- [{"peer": BEE, "kind": "edge"}])
- expected = ways.missing_sentence(self.store.current(), SEA, "this Mac")
- self.assertTrue(expected)
- self.assertEqual(window.missing_note.view.isHidden(), not ways.missing_sentence(self.store.current(), BEE, "this Mac"))
- self.pick(SEA)
- self.assertFalse(window.missing_note.view.isHidden())
- self.assertEqual(window.missing_note.text, expected)
-
-
-class WayBack(Page):
- """`arrangement`'s `way_back` (WIRE.md section 8): what each machine is told, and what it said."""
-
- def entry_of(self, peer):
- return next(item for item in self.store.current()["peers"] if item["id"] == peer)
+ self.assertNotIn(SEA, window.crossing_ledger.rows)
+ self.assertIs(window.crossing_ledger.rows[BEE], row)
- def test_turning_off_every_way_to_a_machine_tells_it_so_with_its_side_as_it_was(self):
+ def test_link_name_changes_update_the_existing_row(self):
window = self.two()
- self.pick(SEA)
- self.toggle("part")
- self.toggle("corner")
- window._apply_settings()
- self.assertEqual(self.sent, [(SEA, "left", 100)])
- self.assertEqual(self.sent_by, [self.store.current()["machine_id"]])
- self.toggle("corner")
- window._apply_settings()
- self.assertEqual(len(self.sent), 2)
-
- def test_moving_one_machine_tells_every_machine_whose_way_back_it_changed(self):
- # Sol's review, 02-10-2026: Sea was told Bee holds its side, and moving Bee told Bee alone,
- # so Sea's page kept naming Bee as in the way.
- window = self.build([(BEE, token(100), "Bee", {"side": "right"}), (SEA, token(150), "Sea", {"side": "right"})],
- [{"peer": BEE, "kind": "edge"}, {"peer": SEA, "kind": "edge", "off": True}])
- self.assertEqual(ways.way_back_by(self.store.current(), SEA), BEE)
- self.pick(BEE)
- window.edge_select._choose("top")
- window._apply_settings()
- self.assertEqual(sorted(peer for peer, _edge, _at in self.sent), sorted([BEE, SEA]))
- self.assertIsNone(ways.way_back_by(self.store.current(), SEA))
-
- def test_removing_the_machine_in_the_way_tells_the_one_it_blocked(self):
- # Opus review: unpairing Sea left Bee told Sea held its side until Bee's link next came up.
- window = self.build([(BEE, token(100), "Bee", {"side": "left"}), (SEA, token(150), "Sea", {"side": "left"})],
- [{"peer": BEE, "kind": "edge", "off": True}, {"peer": SEA, "kind": "edge"}])
- self.assertEqual(ways.way_back_by(self.store.current(), BEE), SEA)
- window.panel._remove(token(150))
- self.assertIn(BEE, [peer for peer, _edge, _at in self.sent])
-
- def test_an_arrangement_that_changed_something_is_answered_with_this_macs_own(self):
- window = self.two()
- window.apply_arrangement(SEA, "top", 5000, SEA, True)
- self.assertEqual(self.sent, [(SEA, "bottom", 5000)])
- self.assertEqual(self.sent_by, [SEA])
- self.assertIs(self.entry_of(SEA)["way_back"], True)
- window.apply_arrangement(SEA, "top", 5000, SEA, True)
- self.assertEqual(len(self.sent), 1)
- window.apply_arrangement(SEA, "top", 5000, SEA, False)
- self.assertEqual(len(self.sent), 2)
- self.assertIs(self.entry_of(SEA)["way_back"], False)
-
- def test_the_answer_goes_over_the_link_the_machine_opened_when_this_macs_is_down(self):
- window = self.two()
- self.controller.send_arrangement = lambda *_args: False
- window.apply_arrangement(SEA, "top", 5000, SEA, True)
- window.windows_input.send_arrangement.assert_called_once_with(SEA, "bottom", 5000, SEA)
-
-
-class TheNotes(Page):
- """What the page says under the ways about a machine it cannot reach, or that cannot reach back."""
-
- def test_a_machine_whose_side_another_holds_is_named_in_the_share_panel(self):
- window = self.build([(BEE, token(100), "Bee", {"side": "right"}), (SEA, token(150), "Sea", {"side": "right"})],
- [{"peer": BEE, "kind": "edge"}, {"peer": SEA, "kind": "edge", "off": True}])
- self.pick(SEA)
- self.assertFalse(window.share_box.isHidden())
- self.assertIn("Bee already crosses from the right edge", window.share_sentence.text)
- self.assertTrue(window.blocked_note.view.isHidden())
- self.pick(BEE)
- self.assertTrue(window.share_box.isHidden())
-
- def test_a_machine_that_said_no_way_leads_back_is_named_until_it_says_one_does(self):
- window = self.build([(BEE, token(100), "Bee", {"side": "right"}),
- (SEA, token(150), "Sea", {"side": "left", "way_back": False})],
- [{"peer": BEE, "kind": "edge"}, {"peer": SEA, "kind": "edge"}])
- self.assertTrue(window.no_way_back_note.view.isHidden())
- self.pick(SEA)
- self.assertFalse(window.no_way_back_note.view.isHidden())
- self.assertEqual(window.no_way_back_note.text, ways.no_way_back_sentence(self.store.current(), SEA))
- window.apply_arrangement(SEA, "right", 5000, SEA, True)
- self.assertTrue(window.no_way_back_note.view.isHidden())
-
- def test_an_arrangement_names_the_machine_holding_the_way_back_side(self):
- window = self.build([(BEE, token(100), "Bee", {"side": "right"}),
- (SEA, token(150), "Sea", {"side": "left"})],
- [{"peer": BEE, "kind": "edge"}, {"peer": SEA, "kind": "edge", "off": True}])
- self.pick(SEA)
- window.apply_arrangement(SEA, "right", 5000, SEA, False, BEE)
- entry = next(item for item in self.store.current()["peers"] if item["id"] == SEA)
- self.assertEqual(entry["way_back_by"], BEE)
- self.assertIn("Bee on its right too", window.no_way_back_note.text)
-
-
-class TheOverview(Page):
- def test_the_address_shown_is_the_machine_the_status_speaks_of(self):
- window = self.build([(BEE, token(100), "Bee", {"host": "192.0.2.31"}), (SEA, token(150), "Sea", {"host": "192.0.2.32"})])
- with mock.patch.object(self.controller, "_in_question", return_value=SEA):
- window._show_peer()
- self.assertIn("192.0.2.32", window.peer_footer.text)
-
-
-class TheDrawing(Page):
- def test_the_drawing_has_every_machine_with_the_chosen_one_marked(self):
- window = self.build([(BEE, token(100), "Bee", {"side": "right"}), (SEA, token(150), "Sea", {"side": "top"}),
- (OAK, token(200), "Oak")], [{"peer": BEE, "kind": "edge"}])
- self.pick(SEA)
- machines = window.arrangement_diagram.machines
- self.assertEqual([(m["label"], m["side"], m["chosen"]) for m in machines],
- [("Bee", "right", False), ("Sea", "top", True), ("Oak", "", False)])
- self.assertEqual(machines[0]["methods"], ["edge"])
- label = window.arrangement_diagram.accessibilityLabel()
- for words in ("Bee is to the right of this Mac.", "Sea is above this Mac.", "Oak is not placed yet."):
- self.assertIn(words, label)
- drawing = window.arrangement_diagram
- drawing.setFrame_(((0, 0), (480, drawing.HEIGHT)))
- drawing._draw(False)
- self.assertEqual(drawing.not_placed.string(), "Not placed yet: Oak")
- self.assertTrue(drawing.screens[OAK][0].isHidden())
- self.assertFalse(drawing.screens[SEA][0].isHidden())
-
- def test_the_chosen_machines_drawing_follows_the_controls_before_the_save(self):
- window = self.two()
- self.pick(SEA)
- window.edge_select._choose("bottom")
- sea = window.arrangement_diagram.machines[1]
- self.assertEqual((sea["side"], sea["chosen"]), ("bottom", True))
-
+ row = window.crossing_ledger.rows[SEA]
+ settings = self.store.current()
+ next(peer for peer in settings["peers"] if peer["id"] == SEA)["name"] = "Sea Studio"
+ self.store.save_settings(settings)
+ window._show_arrangement()
+ self.assertIs(window.crossing_ledger.rows[SEA], row)
+ self.assertEqual(row.name.text, "Sea Studio")
-class Wording(Page):
- def test_the_switch_is_same_on_all_machines(self):
+ def test_same_on_both_offers_granular_groups(self):
window = self.two()
- self.assertEqual(window.same_switch.words.text, "Same on all machines")
+ self.assertEqual(set(window.same_checks), {"crossing", "design", "shortcut", "names", "everything"})
class TheMenuBar(Page):
@@ -616,15 +183,27 @@ class TheMenuBar(Page):
tray.control_window = self.window
return tray
- def test_a_machines_item_sends_input_to_it(self):
+ def menu_tray(self):
+ tray = self.tray()
+ tray.menu = rumps_module.Menu()
+ tray.toggle_item = kvm_bridge_app.rumps.MenuItem(kvm_bridge_app.TOGGLE_ITEM)
+ tray.menu.add(tray.toggle_item)
+ tray.menu.add(kvm_bridge_app.rumps.MenuItem("Pause crossing"))
+ tray._send_keys = []
+ return tray
+
+ def titles(self, tray):
+ return [item.title for item in tray.menu.values() if not item.hidden]
+
+ def test_a_machine_menu_item_routes_input_to_that_peer(self):
self.two()
self.controller.event_tap = object()
self.controller.input_error = None
with mock.patch.object(self.controller, "set_redirecting", return_value=True) as switch:
kvm_bridge_app.TrayApp._send_to(self.tray(), SEA)
- switch.assert_called_once_with(True, peer=SEA)
+ switch.assert_called_once_with(True, peer=SEA, reason="menu")
- def test_the_item_of_the_machine_input_is_on_brings_it_back(self):
+ def test_the_current_machine_menu_item_brings_input_back(self):
self.two()
self.controller.event_tap = object()
self.controller.input_error = None
@@ -634,7 +213,7 @@ class TheMenuBar(Page):
kvm_bridge_app.TrayApp._send_to(self.tray(), SEA)
switch.assert_called_once_with(False)
- def test_another_machines_item_moves_input_straight_there(self):
+ def test_another_machine_menu_item_moves_input_directly(self):
self.two()
self.controller.event_tap = object()
self.controller.input_error = None
@@ -642,22 +221,9 @@ class TheMenuBar(Page):
self.controller.redirecting = True
with mock.patch.object(self.controller, "set_redirecting", return_value=True) as switch:
kvm_bridge_app.TrayApp._send_to(self.tray(), SEA)
- self.assertEqual(switch.call_args_list, [mock.call(True, peer=SEA)])
+ switch.assert_called_once_with(True, peer=SEA, reason="menu")
- def menu_tray(self):
- tray = self.tray()
- # The menu rumps.App keeps, which rumps does not export.
- tray.menu = rumps_module.Menu()
- tray.toggle_item = kvm_bridge_app.rumps.MenuItem(kvm_bridge_app.TOGGLE_ITEM)
- tray.menu.add(tray.toggle_item)
- tray.menu.add(kvm_bridge_app.rumps.MenuItem("Pause crossing"))
- tray._send_keys = []
- return tray
-
- def titles(self, tray):
- return [item.title for item in tray.menu.values() if not item.hidden]
-
- def test_with_two_machines_the_menu_has_an_item_each_in_place_of_the_one(self):
+ def test_two_machines_have_two_menu_items_and_current_says_bring_back(self):
self.two()
tray = self.menu_tray()
kvm_bridge_app.TrayApp._machine_items(tray)
@@ -667,21 +233,20 @@ class TheMenuBar(Page):
kvm_bridge_app.TrayApp._machine_items(tray)
self.assertEqual(self.titles(tray), ["Send input to Bee", "Bring input back", "Pause crossing"])
- def test_with_one_machine_the_menu_keeps_its_one_item(self):
+ def test_one_machine_keeps_the_single_menu_item(self):
self.build([(BEE, token(100), "Bee", {"side": "left"})])
tray = self.menu_tray()
kvm_bridge_app.TrayApp._machine_items(tray)
self.assertEqual(self.titles(tray), [kvm_bridge_app.TOGGLE_ITEM, "Pause crossing"])
- def test_a_machine_switched_off_leaves_the_menu(self):
+ def test_a_send_disabled_machine_leaves_the_menu(self):
self.two()
tray = self.menu_tray()
- kvm_bridge_app.TrayApp._machine_items(tray)
self.store.set_peer(token(150), send=False)
kvm_bridge_app.TrayApp._machine_items(tray)
self.assertEqual(self.titles(tray), [kvm_bridge_app.TOGGLE_ITEM, "Pause crossing"])
- def test_without_the_permissions_nothing_is_sent_and_it_says_why(self):
+ def test_permissions_missing_prevent_the_menu_sending_input(self):
self.two()
self.controller.event_tap = None
tray = self.tray()
diff --git a/mac_app/tests/test_design_offscreen.py b/mac_app/tests/test_design_offscreen.py
index 0e2637a..b6c747b 100644
--- a/mac_app/tests/test_design_offscreen.py
+++ b/mac_app/tests/test_design_offscreen.py
@@ -5,7 +5,8 @@ import time
from unittest import mock
from mac_app.tests.design_offscreen import (
- AppKit, kvm_bridge_app, lit_pixels, offscreen_control_window, rect_list, resize_measurements, settle, tiles,
+ AppKit, accent_pixels_near_top_edge, kvm_bridge_app, lit_pixels, offscreen_control_window,
+ raster, rect_list, resize_measurements, settle, tiles,
)
widgets = kvm_bridge_app.widgets
@@ -29,22 +30,6 @@ def measured_stack(vertical=True, spacing=10):
return view
-def raster(view):
- rep = view.bitmapImageRepForCachingDisplayInRect_(view.bounds())
- view.cacheDisplayInRect_toBitmapImageRep_(view.bounds(), rep)
- return rep
-
-
-def accent_pixels_near_top_edge(view):
- rep = raster(view)
- left, right = int(rep.pixelsWide() * .25), int(rep.pixelsWide() * .75)
- return sum(
- 1 for y in range(2, min(16, rep.pixelsHigh())) for x in range(left, right)
- if (lambda colour: colour.blueComponent() > .55 and
- colour.blueComponent() - colour.redComponent() > .18)(rep.colorAtX_y_(x, y))
- )
-
-
def raster_difference(a, b):
if (a.pixelsWide(), a.pixelsHigh()) != (b.pixelsWide(), b.pixelsHigh()):
return 0
@@ -162,12 +147,20 @@ class DesignOffscreenTests(unittest.TestCase):
control._select_page("design")
control.window.setFrame_display_(((100000, 100000), control.window.minSize()), False)
settle(control.window)
- for selector in (control.length_select, control.size_select):
- self.assertLessEqual(selector.view.frame().size.width, 240)
- self.assertEqual(selector.layout_columns, 1)
- for _, cell, words in selector.cells:
- self.assertGreaterEqual(cell.bounds().size.height, 28)
- self.assertGreaterEqual(words.view.frame().size.width, words.view.attributedStringValue().size().width)
+ # The 320 pt window's column leaves the track about 100 pt beside its readout; what must hold
+ # is that the value reads in full, the track stays wider than it, and neither leaves the row.
+ for selector, readout in ((control.length_select, control.length_readout),
+ (control.size_select, control.size_readout)):
+ slider, words = selector.slider, readout.view
+ row = slider.superview().frame().size.width
+ self.assertTrue(slider.isEnabled())
+ self.assertGreaterEqual(words.frame().size.width, words.attributedStringValue().size().width)
+ self.assertGreater(slider.frame().size.width, words.frame().size.width)
+ for view in (slider, words):
+ # Alignment rects: a slider's frame runs 2 pt past its track on each side by design.
+ laid = view.alignmentRectForFrame_(view.frame())
+ self.assertGreaterEqual(laid.origin.x, -1)
+ self.assertLessEqual(laid.origin.x + laid.size.width, row + 1)
def test_stacked_length_and_size_share_the_field_column(self):
control = offscreen_control_window()
@@ -184,9 +177,9 @@ class DesignOffscreenTests(unittest.TestCase):
control._select_page("design")
control.window.setFrame_display_(((100000, 100000), (1900, 900)), False)
settle(control.window)
- self.assertAlmostEqual(control.length_select.view.frame().size.width, 240, delta=1)
- self.assertAlmostEqual(control.size_select.view.frame().size.width, 240, delta=1)
- self.assertAlmostEqual(control.length_row.frame().size.width, control.size_row.frame().size.width, delta=1)
+ self.assertAlmostEqual(control.length_select.slider.frame().size.width,
+ control.size_select.slider.frame().size.width, delta=1)
+ self.assertGreater(control.length_select.slider.frame().size.width, 240)
def test_trackpad_options_do_not_truncate_at_any_width(self):
control = offscreen_control_window()
diff --git a/mac_app/tests/test_design_sliders.py b/mac_app/tests/test_design_sliders.py
new file mode 100644
index 0000000..499e511
--- /dev/null
+++ b/mac_app/tests/test_design_sliders.py
@@ -0,0 +1,69 @@
+import unittest
+import sys
+from pathlib import Path
+from unittest import mock
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+from mac_app import kvm_bridge_app
+from core import effects
+import config as mac_config
+
+
+class LengthSizeSliderTests(unittest.TestCase):
+ def test_native_slider_exposes_accessibility_and_arrow_step(self):
+ calls = []
+ control = kvm_bridge_app._DesignSliderChoice(
+ "Length", 25, 250, 5, 100, (0.5, 1.0, 2.0), effects.LENGTHS,
+ lambda owner, sender: calls.append(sender.doubleValue()), "Sets playback time.")
+ slider = control.slider
+ self.assertIsInstance(slider, kvm_bridge_app.AppKit.NSSlider)
+ self.assertEqual(slider.accessibilityLabel(), "Length")
+ self.assertIn("playback time", slider.accessibilityHelp())
+ control.set_accessible_value("1.0 s")
+ self.assertEqual(slider.accessibilityValueDescription(), "1.0 s")
+ slider.keyDown_(mock.Mock(keyCode=lambda: 124))
+ self.assertEqual(slider.doubleValue(), 105)
+ self.assertEqual(calls, [105.0])
+
+ def test_slider_keyboard_steps_cover_arrows_page_and_range_ends(self):
+ key_value = kvm_bridge_app.design_slider_key_value
+ self.assertEqual(key_value(123, 100, 25, 250, 5, 25), 95)
+ self.assertEqual(key_value(124, 100, 25, 250, 5, 25), 105)
+ self.assertEqual(key_value(125, 100, 25, 250, 5, 25), 95)
+ self.assertEqual(key_value(126, 100, 25, 250, 5, 25), 105)
+ self.assertEqual(key_value(116, 100, 25, 250, 5, 25), 125)
+ self.assertEqual(key_value(121, 100, 25, 250, 5, 25), 75)
+ self.assertEqual(key_value(115, 100, 25, 250, 5, 25), 25)
+ self.assertEqual(key_value(119, 100, 25, 250, 5, 25), 250)
+
+ def test_drag_detent_and_fixed_width_readouts(self):
+ self.assertEqual(effects.snap_detent(54, 25, 250, (50, 100, 200)), 50)
+ length, size = effects.design_slider_readouts("beam", 2.0, 0.06, 1920, 1080)
+ self.assertEqual(length, "1.2 s")
+ self.assertTrue(size.endswith(" pt"))
+ constraint = mock.Mock()
+ anchor = mock.Mock()
+ anchor.constraintEqualToConstant_.return_value = constraint
+ view = mock.Mock()
+ view.widthAnchor.return_value = anchor
+ label = mock.Mock(view=view)
+ with mock.patch.object(kvm_bridge_app.widgets, "Label", return_value=label):
+ readout = kvm_bridge_app.design_readout()
+ self.assertIs(readout, label)
+ anchor.constraintEqualToConstant_.assert_called_once_with(effects.DESIGN_READOUT_WIDTH)
+ constraint.setActive_.assert_called_once_with(True)
+ self.assertEqual(effects.play_through_seconds("beam", 2.0), 1.2)
+
+ def test_preset_only_mac_settings_migrate_to_both_forms(self):
+ config = mac_config.parse_config({
+ "host": "192.0.2.1", "port": 51820, "auth_token": "synthetic",
+ "crossing": {"effect_length": "long", "effect_size": "small"},
+ })
+ crossing = config.crossing
+ self.assertEqual((crossing["effect_pace"], crossing["effect_size_fraction"],
+ crossing["effect_length"], crossing["effect_size"]),
+ (2.0, 0.03, "long", "small"))
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/mac_app/tests/test_design_tiles.py b/mac_app/tests/test_design_tiles.py
index 0e5f4f1..078603a 100644
--- a/mac_app/tests/test_design_tiles.py
+++ b/mac_app/tests/test_design_tiles.py
@@ -1,10 +1,67 @@
"""Measure Design tile states without ordering a window."""
+import math
import unittest
+from unittest import mock
-from mac_app.tests.design_offscreen import offscreen_control_window, settle, tiles
-from mac_app.tests.test_design_offscreen import raster, accent_pixels_near_top_edge
+from core import effects
+from mac_app.tests.design_offscreen import (
+ accent_pixels_near_top_edge, kvm_bridge_app, offscreen_control_window, raster, settle, tiles,
+)
import theme
+widgets = kvm_bridge_app.widgets
+import Quartz
+
+
+def relative_luminance(rgb):
+ linear = [x / 12.92 if x <= .04045 else ((x + .055) / 1.055) ** 2.4 for x in (c / 255 for c in rgb)]
+ return sum(x * weight for x, weight in zip(linear, (.2126, .7152, .0722)))
+
+
+def picture_metrics(tile, scale):
+ """Effect contrast and coverage, excluding the screen outlines and the pointer."""
+ import previews
+ import effects_overlay
+
+ preview = tile.tile_content.preview
+ if isinstance(preview, previews.TileStack):
+ preview = preview.current()
+ width, height = preview.bounds().size
+ ground = tuple(round(channel * 255) for channel in theme.rgb(theme.T["ground"]))
+
+ def paint():
+ context = Quartz.CGBitmapContextCreate(
+ None, round(width * scale), round(height * scale), 8, 0,
+ Quartz.CGColorSpaceCreateWithName(Quartz.kCGColorSpaceSRGB), Quartz.kCGImageAlphaPremultipliedLast)
+ Quartz.CGContextTranslateCTM(context, 0, height * scale)
+ Quartz.CGContextScaleCTM(context, scale, -scale)
+ Quartz.CGContextSetFillColorWithColor(context, theme.cg("ground"))
+ Quartz.CGContextFillRect(context, ((0, 0), (width, height)))
+ preview.painter(context, width, height)
+ return theme.AppKit.NSBitmapImageRep.alloc().initWithCGImage_(Quartz.CGBitmapContextCreateImage(context))
+
+ rep = paint()
+ original = effects_overlay.draw_scene
+
+ def without_marks(cg, ctx, scene, *args, **kwargs):
+ return original(cg, ctx, dict(scene, pens=[]), *args, **kwargs)
+
+ with mock.patch.object(effects_overlay, "draw_scene", without_marks):
+ baseline = paint()
+ data, before = bytes(rep.bitmapData()), bytes(baseline.bitmapData())
+ row, channels = rep.bytesPerRow(), rep.samplesPerPixel()
+ ground_lum = relative_luminance(ground)
+ ratios = []
+ for y in range(rep.pixelsHigh()):
+ for x in range(rep.pixelsWide()):
+ offset = y * row + x * channels
+ rgb = tuple(data[offset:offset + 3])
+ if max(abs(a - b) for a, b in zip(rgb, before[offset:offset + 3])) > 3:
+ lum = relative_luminance(rgb)
+ ratios.append((max(lum, ground_lum) + .05) / (min(lum, ground_lum) + .05))
+ ratios.sort()
+ contrast = ratios[min(len(ratios) - 1, math.ceil(.9 * len(ratios)) - 1)] if ratios else 1.0
+ return contrast, len(ratios) / max(1, rep.pixelsWide() * rep.pixelsHigh())
def luminance(colour):
@@ -15,6 +72,43 @@ def luminance(colour):
class DesignTileMeasurements(unittest.TestCase):
+ def test_still_time_is_inside_the_loop_and_deterministic(self):
+ first = effects.still_time("beam", "edge")
+ self.assertGreaterEqual(first, 0)
+ self.assertLess(first, effects.PREVIEW_LOOP_S)
+ self.assertEqual(first, effects.still_time("beam", "edge"))
+ switch = effects.still_time("aperture", "switch")
+ self.assertGreaterEqual(switch, 0)
+ self.assertLess(switch, effects.SWITCH_LOOP_S)
+ self.assertEqual(switch, effects.still_time("aperture", "switch"))
+
+ def test_real_tile_previews_reach_contrast_and_coverage_in_both_appearances_and_scales(self):
+ control = offscreen_control_window()
+ control._select_page("design")
+ # The page shows one family at a time; both are measured as they look when shown.
+ control.switch_styles_box.setHidden_(False)
+ previous = theme.is_dark()
+ try:
+ for appearance in ("dark", "light"):
+ control._apply_appearance(appearance)
+ for family, choices in (("crossing", control.glow_style_select),
+ ("switch", control.switch_style_select)):
+ choices.value = None
+ settle(control.window)
+ for row in choices.rows:
+ for style, tile, _name in row.tiles:
+ for scale in (1, 2):
+ contrast, coverage = picture_metrics(tile, scale)
+ with self.subTest(family=family, style=style, appearance=appearance, scale=scale):
+ self.assertGreaterEqual(contrast, 3.0)
+ # The Qt test holds the same 1% floor. The Rule switch is four
+ # small ticks round the pointer, under 1% in Light, and its
+ # geometry is the effect's own, so it alone is held to 0.5%.
+ floor = .005 if (family, style) == ("switch", "rule") else .01
+ self.assertGreaterEqual(coverage, floor)
+ finally:
+ theme.set_dark(previous)
+
def test_hover_background_brightens_in_both_appearances(self):
control = offscreen_control_window()
tile = control.glow_style_select.rows[0].tiles[1][1]
@@ -56,6 +150,49 @@ class DesignTileMeasurements(unittest.TestCase):
self.assertEqual(tiles(control), before)
hovered._tile_hover_owner.mouseExited_(None)
+ def test_selected_badge_is_a_signal_circle_with_ground_check_on_the_name_line(self):
+ kvm_bridge_app.AppKit.NSApplication.sharedApplication()
+ Quartz = kvm_bridge_app.Quartz
+ previous = theme.is_dark()
+ try:
+ for dark in (True, False):
+ theme.set_dark(dark)
+ tile = widgets.pressable(lambda: None, "ground", "rule", theme.RADIUS["segment"])
+ tile.setFrame_(((0, 0), (80, 48)))
+ tile.add_selection_mark()
+ tile.show_selection_mark(True)
+ tile.layout()
+ rep = raster(tile)
+ self.assertFalse(tile.selection_mark.isHidden())
+ self.assertFalse(tile.selection_check.isHidden())
+ self.assertTrue(Quartz.CGColorEqualToColor(tile.selection_mark.fillColor(), theme.cg("signal")))
+ self.assertTrue(Quartz.CGColorEqualToColor(tile.selection_check.strokeColor(), theme.cg("ground")))
+ self.assertEqual(tile.selection_check.lineWidth(), 2)
+ self.assertEqual(tile.selection_mark.bounds().size.width, 16)
+ data = bytes(rep.bitmapData())
+ channels = rep.samplesPerPixel()
+ near_signal = sum(max(data[offset:offset + 3]) - min(data[offset:offset + 3]) > 70
+ and data[offset + 2] > data[offset] + 50
+ for offset in range(0, len(data), channels))
+ with self.subTest(dark=dark):
+ self.assertGreater(near_signal, 80)
+ finally:
+ theme.set_dark(previous)
+
+ def test_design_badge_sits_before_the_indented_name_below_the_preview(self):
+ control = offscreen_control_window()
+ control._select_page("design")
+ tile = control.glow_style_select.rows[0].tiles[0][1]
+ settle(control.window)
+ mark = tile.selection_mark.frame()
+ name = tile.tile_content.name.view.frame()
+ preview = tile.tile_content.preview.frame()
+ self.assertAlmostEqual(mark.origin.x + mark.size.width + 6, name.origin.x, delta=1)
+ self.assertAlmostEqual(mark.origin.y + mark.size.height / 2,
+ name.origin.y + name.size.height / 2, delta=1)
+ # The tile is unflipped: below the preview is a lower y.
+ self.assertLess(mark.origin.y + mark.size.height, preview.origin.y)
+
def test_preview_hint_uses_secondary_ink_with_readable_contrast(self):
control = offscreen_control_window()
hint = control.style_preview_hint
diff --git a/mac_app/tests/test_dock_visibility.py b/mac_app/tests/test_dock_visibility.py
new file mode 100644
index 0000000..91f2925
--- /dev/null
+++ b/mac_app/tests/test_dock_visibility.py
@@ -0,0 +1,29 @@
+import sys
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+import dock_visibility
+
+
+class DockVisibilityTests(unittest.TestCase):
+ def test_existing_settings_default_to_showing_beamer_in_the_dock(self):
+ settings = dock_visibility.complete_settings({"name": "Mac"})
+ self.assertTrue(settings["show_in_dock"])
+
+ def test_hidden_preference_is_preserved(self):
+ settings = dock_visibility.complete_settings({"show_in_dock": False})
+ self.assertFalse(settings["show_in_dock"])
+
+ def test_setting_rejects_non_boolean_values(self):
+ with self.assertRaises(ValueError):
+ dock_visibility.validate_settings({"show_in_dock": "yes"})
+
+ def test_accessory_policy_applies_only_when_hidden_and_window_closed(self):
+ self.assertEqual(dock_visibility.activation_policy(True, False), "regular")
+ self.assertEqual(dock_visibility.activation_policy(False, True), "regular")
+ self.assertEqual(dock_visibility.activation_policy(False, False), "accessory")
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/mac_app/tests/test_dock_window.py b/mac_app/tests/test_dock_window.py
new file mode 100644
index 0000000..0d0ef71
--- /dev/null
+++ b/mac_app/tests/test_dock_window.py
@@ -0,0 +1,122 @@
+"""Show in Dock through the real window, tray and launch code: which activation policy each moment
+asks for. NSApp's calls are recorded rather than made, so no Dock icon or window appears."""
+
+import json
+import logging
+import sys
+import tempfile
+import types
+import unittest
+from pathlib import Path
+from unittest import mock
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+sys.path.insert(0, str(Path(__file__).resolve().parents[2]))
+
+import kvm_bridge_app # noqa: E402
+import settings_store # noqa: E402
+from bridge_fakes import PAIRED_TOKEN # noqa: E402
+from fake_link import FakeLink # noqa: E402
+from test_same_on_both import PEER, pc_message # noqa: E402
+from wake import WakingController # noqa: E402
+
+AppKit = kvm_bridge_app.AppKit
+REGULAR, ACCESSORY = AppKit.NSApplicationActivationPolicyRegular, AppKit.NSApplicationActivationPolicyAccessory
+
+
+class DockWindowTests(unittest.TestCase):
+ def setUp(self):
+ self.directory = tempfile.TemporaryDirectory()
+ self.addCleanup(self.directory.cleanup)
+ path = Path(self.directory.name) / "config.json"
+ # A settings file from before the switch existed: no show_in_dock in it.
+ raw = settings_store.config_to_raw(settings_store.editable_default_config())
+ raw.update(host="192.0.2.20", auth_token=PAIRED_TOKEN)
+ path.write_text(json.dumps(raw))
+ self.store = settings_store.SettingsStore(path)
+ logger = logging.getLogger("test-dock-window")
+ with mock.patch.object(kvm_bridge_app, "accessibility_granted", return_value=True), \
+ mock.patch.object(kvm_bridge_app, "input_monitoring_granted", return_value=True):
+ self.window = kvm_bridge_app.ControlWindow.alloc().initWithController_settingsStore_logger_(
+ WakingController(self.store.load(), logger=logger, link_factory=FakeLink, book=self.store.book()),
+ self.store, logger)
+ self.addCleanup(self.window.appearance_watch.stop)
+ self.sent = []
+ self.window.controller.send_settings = lambda data, source=None: self.sent.append(data) or True
+ self.policies = []
+ self.events = []
+ app = mock.Mock()
+ app.setActivationPolicy_.side_effect = lambda policy: self.policies.append(policy) or self.events.append(policy)
+ app.activateIgnoringOtherApps_.side_effect = lambda _flag: self.events.append("activate")
+ patch = mock.patch.object(AppKit, "NSApp", app)
+ patch.start()
+ self.addCleanup(patch.stop)
+ self.visible = False
+ self.tray = types.SimpleNamespace(
+ settings_store=self.store, hidden=False, notices=mock.Mock(),
+ control_window=types.SimpleNamespace(window=types.SimpleNamespace(isVisible=lambda: self.visible)))
+ self.tray.apply_activation_policy = lambda window_open=None: kvm_bridge_app.TrayApp.apply_activation_policy(
+ self.tray, window_open)
+ self.window.activation_policy_handler = self.tray.apply_activation_policy
+
+ def show(self):
+ """ControlWindow.show with the window itself stood in for, so nothing is put on screen."""
+ with mock.patch.object(self.window, "window", mock.Mock()), \
+ mock.patch.object(self.window, "_select_page"), mock.patch.object(self.window, "refresh"), \
+ mock.patch.object(self.window, "_run_previews"):
+ self.window.show()
+ self.visible = True
+
+ def close(self):
+ with mock.patch.object(self.window, "_remember_normal_frame"):
+ self.window.windowWillClose_(None)
+ self.visible = False
+
+ def test_an_existing_settings_file_shows_beamer_in_the_dock(self):
+ self.assertTrue(self.store.current()["show_in_dock"])
+ self.assertTrue(self.window.dock_switch.value)
+ self.tray.apply_activation_policy(window_open=False)
+ self.assertEqual(self.policies, [REGULAR])
+
+ def test_turned_off_it_stays_while_the_window_is_open_and_goes_when_it_closes(self):
+ self.show()
+ self.window._set_show_in_dock(False)
+ self.assertFalse(type(self.store)(self.store.path).current()["show_in_dock"])
+ self.assertEqual(self.policies[-1], REGULAR)
+ self.close()
+ self.assertEqual(self.policies[-1], ACCESSORY)
+
+ def test_reopened_from_the_menu_bar_it_comes_back_before_taking_focus_and_goes_again(self):
+ self.window._set_show_in_dock(False)
+ self.assertEqual(self.policies[-1], ACCESSORY)
+ self.events.clear()
+ self.show()
+ # Regular first: an Accessory app cannot become the active app the window needs.
+ self.assertEqual(self.events, [REGULAR, "activate"])
+ self.close()
+ self.assertEqual(self.policies[-1], ACCESSORY)
+
+ def test_a_background_login_launch_with_it_off_stays_out_of_the_dock(self):
+ self.window._set_show_in_dock(False)
+ self.policies.clear()
+ watch = kvm_bridge_app._LaunchWatch.alloc().initWithTray_(self.tray)
+ self.addCleanup(AppKit.NSNotificationCenter.defaultCenter().removeObserver_, watch)
+ watch.launched_(types.SimpleNamespace(userInfo=lambda: {"NSApplicationLaunchIsDefaultLaunchKey": False}))
+ self.assertTrue(self.tray.hidden)
+ self.assertEqual(self.policies, [ACCESSORY])
+
+ def test_same_on_all_machines_never_changes_this_macs_choice(self):
+ self.window._set_show_in_dock(False)
+ # message_data never carries it, so it is put in by hand where a peer could put it.
+ data = pc_message(True, 100, by=PEER)
+ for section in (data, data["crossing"], data["design"]):
+ section["show_in_dock"] = True
+ self.window.apply_same(data, peer=PEER)
+ self.assertFalse(type(self.store)(self.store.path).current()["show_in_dock"])
+ self.window._set_same(True)
+ self.assertTrue(self.sent)
+ self.assertNotIn("show_in_dock", json.dumps(self.sent))
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/mac_app/tests/test_dormant_rows.py b/mac_app/tests/test_dormant_rows.py
new file mode 100644
index 0000000..3a2b75a
--- /dev/null
+++ b/mac_app/tests/test_dormant_rows.py
@@ -0,0 +1,192 @@
+import base64
+import copy
+import sys
+import unittest
+from unittest import mock
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[2] / "mac_app"))
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+import machines
+import machines_panel
+import pages
+from core import pairing, protocol, settings_sync
+from test_crossing_page_machines import Page, SEA, token
+
+
+TOKEN = base64.urlsafe_b64encode(bytes(range(32))).decode().rstrip("=")
+PEER = protocol.id_text(bytes(range(20, 36)))
+
+
+def entry(**fields):
+ return {"id": PEER, "name": "Desk", "token": TOKEN, "host": "192.0.2.10", "port": 24820,
+ "platform": "windows", "send": True, "allow_drive": True, "linked": True, **fields}
+
+
+class DormantRowTests(unittest.TestCase):
+ def test_row_shows_needs_repair_and_the_saved_reason_even_when_offline(self):
+ row = machines.row(entry(dormant=True, dormant_reason="forgotten"), "Desk", False, "unreachable", "offline",
+ False, False, False, True)
+ self.assertEqual((row.state.key, row.state.word, row.state.detail),
+ ("dormant", "Needs re-pair", "The other machine no longer has this pairing."))
+
+ def test_wrong_id_has_a_distinct_reason(self):
+ row = machines.row(entry(dormant=True, dormant_reason="wrong_id"), "Desk", False, "wrong_id", "refused",
+ False, False, False, True)
+ self.assertEqual(row.state.detail, "The saved pairing now identifies a different machine.")
+
+ def test_dormant_machines_mark_overview_and_crossing_for_attention(self):
+ self.assertEqual(pages.dots(True, True, "", dormant=True),
+ {"overview": "amber", "crossing": "amber"})
+
+ def test_re_pair_opens_the_existing_code_sheet_for_the_saved_address(self):
+ panel = machines_panel.MachinesPanel.__new__(machines_panel.MachinesPanel)
+ panel.controller = mock.Mock()
+ panel.controller.book.peers.return_value = [entry(dormant=True, dormant_reason="forgotten")]
+ panel.controller.cfg.hide_addresses = False
+ panel.owner = mock.Mock()
+ panel.find_field = mock.Mock()
+ panel.find_secret = mock.Mock()
+ panel.code_boxes = mock.Mock()
+ panel.refresh = mock.Mock()
+ panel.open = False
+ panel.chosen = None
+ panel._heard_key = None
+
+ panel.re_pair(TOKEN)
+
+ self.assertTrue(panel.open)
+ self.assertEqual(panel.find_field.setStringValue_.call_args_list,
+ [mock.call(""), mock.call("192.0.2.10")])
+ panel.refresh.assert_called_once_with()
+ panel.code_boxes.focus.assert_called_once_with(panel.owner.window)
+
+
+class DormantCrossingTests(Page):
+ def build_dormant(self, **fields):
+ window = self.build([(PEER, TOKEN, "Desk", {"side": "right", "dormant": True,
+ "dormant_reason": "forgotten", **fields}),
+ (SEA, token(150), "Other", {"side": "left"})],
+ [{"peer": PEER, "kind": "edge"}, {"peer": SEA, "kind": "edge"}])
+ window._live = lambda peer: peer != PEER
+ window._show_arrangement()
+ return window
+
+ def test_persisted_dormant_peer_keeps_an_offline_ledger_row(self):
+ window = self.build_dormant()
+ self.assertNotIn(PEER, window.atlas_canvas.tiles)
+ row = window.crossing_ledger.rows[PEER]
+ self.assertEqual(row.status_text, "Windows · Offline, ways kept")
+ self.assertTrue(row.dimmed)
+ window._machine_picked(PEER)
+ self.assertEqual(window.chosen_peer, PEER)
+ self.assertTrue(window.crossing_ledger.rows[PEER].selected)
+ self.assertNotIn(PEER, window.atlas_canvas.tiles)
+
+ def test_dormant_layout_and_intent_survive_another_machine_moving(self):
+ window = self.build_dormant()
+ settings = self.store.current()
+ own = settings["machine_id"]
+ settings["layout"] = {own: {"x": 0, "y": 0, "w": 160, "h": 100},
+ PEER: {"x": 160, "y": 0, "w": 160, "h": 100},
+ SEA: {"x": -160, "y": 0, "w": 160, "h": 100}}
+ settings["layout_set_at"] = 10
+ self.store.save_settings(settings)
+ window._show_arrangement([])
+ tiles = copy.deepcopy(window.atlas_canvas.tiles)
+ tiles[SEA]["y"] = 33
+ window._atlas_layout_changed(tiles, SEA, snap=False)
+ current = self.store.current()
+ self.assertEqual(current["layout"][PEER], settings["layout"][PEER])
+ self.assertEqual(next(peer for peer in current["peers"] if peer["id"] == PEER)["ways"],
+ next(peer for peer in settings["peers"] if peer["id"] == PEER)["ways"])
+ self.assertFalse(any(zone["peer"] == PEER for zone in current["zones"]))
+
+ def test_incoming_layout_accepts_dormant_position_and_keeps_intent(self):
+ window = self.build_dormant()
+ settings = self.store.current()
+ own = settings["machine_id"]
+ settings["layout"] = {own: {"x": 0, "y": 0, "w": 160, "h": 100},
+ PEER: {"x": 160, "y": 0, "w": 160, "h": 100},
+ SEA: {"x": 320, "y": 0, "w": 160, "h": 100}}
+ self.store.save_settings(settings)
+ settings = self.store.current()
+ original = copy.deepcopy(settings)
+ incoming = copy.deepcopy(settings["layout"])
+ incoming[PEER]["x"] += 160
+ state = {"tiles": incoming, "set_at": settings.get("layout_set_at", 0) + 1, "by": SEA}
+ data = settings_sync.message_data(False, 0, by=settings["machine_id"], layout_state=state)
+ window._design_peer_caps = lambda: {SEA: {"settings", "layout"}}
+
+ with mock.patch.object(window, "refresh"):
+ self.assertTrue(window._receive_layout(data, SEA))
+
+ current = self.store.current()
+ self.assertEqual(current["layout"][PEER], incoming[PEER])
+ self.assertEqual(next(peer for peer in current["peers"] if peer["id"] == PEER)["ways"],
+ next(peer for peer in original["peers"] if peer["id"] == PEER)["ways"])
+ self.assertFalse(any(zone["peer"] == PEER for zone in current["zones"]))
+
+ def test_a_sleeping_peer_is_kept_on_the_canvas(self):
+ window = self.build([(PEER, TOKEN, "Desk", {"side": "right"})])
+ self.assertIn(PEER, window.atlas_canvas.tiles)
+ self.assertIn(PEER, window.crossing_ledger.rows)
+
+ def test_existing_repair_path_opens_overview_and_prefills_saved_machine(self):
+ window = self.build_dormant()
+ window._re_pair_peer(PEER)
+ self.assertEqual(window.page, "overview")
+ self.assertTrue(window.panel.open)
+ self.assertEqual(window.panel._address_text(), "192.0.2.30")
+
+ def test_dormant_ledger_and_rename_fit_the_narrow_page(self):
+ from mac_app.tests.design_offscreen import settle
+ import theme
+
+ theme.init_fonts()
+ window = self.build_dormant(label="Office studio PC")
+ window._machine_picked(PEER)
+ window._select_page("crossing")
+ window.window.setFrame_display_(((100000, 100000), (640, 900)), False)
+ settle(window.window)
+ window._begin_atlas_rename(PEER)
+ settle(window.window)
+ row = window.crossing_ledger.rows[PEER]
+ self.assertTrue(row.renaming)
+ self.assertFalse(row.name_field.isHidden())
+ self.assertGreater(row.name_field.frame().size.width, 0)
+ self.assertFalse(row.rename_hint.view.isHidden())
+ body = window.pages["crossing"].documentView().subviews()[0]
+ self.assertFalse(window.window.isVisible())
+ self.assertGreater(body.frame().size.width, 0)
+ self.assertLess(body.frame().size.width, window.pages["crossing"].frame().size.width)
+ self.assertLessEqual(row.name_field.frame().origin.x + row.name_field.frame().size.width,
+ row.cells["machine"].bounds().size.width)
+ for cell in row.cells.values():
+ self.assertLessEqual(cell.frame().origin.x + cell.frame().size.width,
+ window.crossing_ledger.bounds().size.width)
+
+ def test_repair_keeps_label_layout_zones_and_left_out_after_reloading(self):
+ self.build_dormant(label="Office", left_out=True, left_out_ways=["edge"])
+ settings = copy.deepcopy(self.store.current())
+ settings["layout"] = {settings["machine_id"]: {"x": 0, "y": 0, "w": 160, "h": 100},
+ PEER: {"x": 160, "y": 0, "w": 160, "h": 100}}
+ self.store.save_settings(settings)
+ old = copy.deepcopy(settings["peers"][0])
+ repaired = pairing.peer_entry(protocol.read_id(PEER), "Desk", "macos", 24820,
+ token(5), "192.0.2.20", 100)
+ self.store.add_peer(repaired, old)
+ saved = type(self.store)(self.store.path).current()
+ peer = saved["peers"][0]
+ self.assertEqual(peer["label"], "Office")
+ self.assertTrue(peer["left_out"])
+ self.assertNotIn("left_out_ways", peer)
+ self.assertEqual(peer["ways"], old["ways"])
+ self.assertEqual(saved["layout"], settings["layout"])
+ self.assertEqual(saved["zones"], settings["zones"])
+ self.assertNotIn("dormant", peer)
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/mac_app/tests/test_driven_mac.py b/mac_app/tests/test_driven_mac.py
index f72000f..250ea86 100644
--- a/mac_app/tests/test_driven_mac.py
+++ b/mac_app/tests/test_driven_mac.py
@@ -221,6 +221,20 @@ class WindowsOnlyKeyTests(InjectorCase):
flags = self.keys()[0][2]
self.assertEqual(flags, FakeQuartz.kCGEventFlagMaskCommand | FakeQuartz.kCGEventFlagMaskShift)
+ def test_search_and_spotlight_press_command_space(self):
+ command = FakeQuartz.kCGEventFlagMaskCommand
+ for name in ("search", "spotlight"):
+ self.quartz.posted.clear()
+ injector.inject_key(name, down=True)
+ injector.inject_key(name, down=False)
+ self.assertEqual(
+ self.keys(), [(0x37, True, command), (0x31, True, command), (0x31, False, command), (0x37, False, 0)], name
+ )
+
+ def test_dictation_presses_f5(self):
+ injector.inject_key("dictation", down=True)
+ self.assertEqual([code for code, _, _ in self.keys()], [0x60])
+
def test_menu_has_no_mac_key_and_is_logged_once(self):
with self.assertLogs("Beamer", level="WARNING") as logged:
injector.inject_key("menu", down=True)
@@ -240,7 +254,11 @@ class WindowsOnlyKeyTests(InjectorCase):
and name not in injector.WINDOWS_ONLY_KEY_CODES
and not injector.handles_key(name)
}
- self.assertEqual(unplaced, {"media_stop", "menu"})
+ # Windows keys with no Mac action are dropped on purpose (docs/special-keys-1.5.2.md).
+ self.assertEqual(unplaced, {
+ "media_stop", "menu", "media_select", "launch_app1", "launch_app2", "mail",
+ "browser_stop", "browser_home", "browser_refresh", "browser_search", "browser_favourites",
+ })
class ScrollRemainderTests(InjectorCase):
diff --git a/mac_app/tests/test_effect_fires.py b/mac_app/tests/test_effect_fires.py
index 0ff2b65..a99eadf 100644
--- a/mac_app/tests/test_effect_fires.py
+++ b/mac_app/tests/test_effect_fires.py
@@ -210,7 +210,7 @@ class HomeArrivalTest(unittest.TestCase):
class GestureOverlayOnReturnTest(unittest.TestCase):
- """Toby 06-10: after the shortcut a grey box sat round the pointer and went only after the
+ """A report, 06-10: after the shortcut a grey box sat round the pointer and went only after the
landing animation. The gesture panel takes clicks, so it has to go as input comes home."""
def test_input_coming_home_takes_the_gesture_panel_down_at_once(self):
diff --git a/mac_app/tests/test_frame_clock.py b/mac_app/tests/test_frame_clock.py
new file mode 100644
index 0000000..e0e39e9
--- /dev/null
+++ b/mac_app/tests/test_frame_clock.py
@@ -0,0 +1,51 @@
+import sys
+import unittest
+from datetime import datetime, timedelta
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+import AppKit
+import Quartz
+from unittest import mock
+
+from frame_clock import PREVIEW_MAX_RATE, FrameClock
+
+
+class FrameClockTests(unittest.TestCase):
+ def test_a_preview_clock_runs_at_sixty_at_most(self):
+ ranges = []
+ link = mock.Mock()
+ link.setPreferredFrameRateRange_.side_effect = ranges.append
+ screen = mock.Mock()
+ screen.maximumFramesPerSecond.return_value = 120
+ # A view in a window, as the previews give it: NSScreen itself cannot be patched under PyObjC.
+ view = mock.Mock()
+ view.window.return_value.screen.return_value = screen
+ view.displayLinkWithTarget_selector_.return_value = link
+ with mock.patch.object(Quartz, "CAFrameRateRangeMake", side_effect=lambda *args: args):
+ for max_rate, expected in ((None, (30, 120, 120)), (PREVIEW_MAX_RATE, (30, 60, 60))):
+ clock = FrameClock(view, lambda: None, max_rate)
+ clock.start()
+ clock.stop()
+ self.assertEqual(ranges[-1], expected)
+
+ def test_main_screen_clock_fires_in_the_common_run_loop_and_stops(self):
+ calls = []
+ clock = FrameClock(None, lambda: calls.append(1))
+ clock.start()
+ self.assertTrue(clock.is_alive())
+ run_loop = AppKit.NSRunLoop.mainRunLoop()
+ deadline = datetime.now() + timedelta(seconds=0.2)
+ while datetime.now() < deadline and len(calls) < 3:
+ run_loop.runUntilDate_(AppKit.NSDate.dateWithTimeIntervalSinceNow_(0.01))
+ self.assertGreaterEqual(len(calls), 3)
+ clock.stop()
+ self.assertFalse(clock.is_alive())
+ stopped_at = len(calls)
+ run_loop.runUntilDate_(AppKit.NSDate.dateWithTimeIntervalSinceNow_(0.05))
+ self.assertEqual(len(calls), stopped_at)
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/mac_app/tests/test_gestures.py b/mac_app/tests/test_gestures.py
index 4c5d126..e1a6606 100644
--- a/mac_app/tests/test_gestures.py
+++ b/mac_app/tests/test_gestures.py
@@ -187,6 +187,21 @@ class ReservedGestureTypeTests(unittest.TestCase):
self.assertEqual(translator.translate(GESTURE_TYPE, FakeNSEvent()), [])
self.assertEqual(translator.translate(SMART_MAGNIFY_TYPE, FakeNSEvent()), [])
+ def test_type_29_zoom_fields_translate_recorded_magnification_and_phase(self):
+ translator = GestureTranslator()
+ recorded_fields = {110: 8, 113: 0.06, 132: 2}
+
+ self.assertEqual(translator.translate_cg_gesture(recorded_fields), zoom_in_triple())
+ self.assertAlmostEqual(translator._magnify_accum, 0.01)
+
+ ended_fields = {110: 8, 113: 0.0, 132: 4}
+ self.assertEqual(translator.translate_cg_gesture(ended_fields), [])
+ self.assertEqual(translator._magnify_accum, 0.0)
+
+ def test_type_29_non_zoom_gestures_are_ignored(self):
+ translator = GestureTranslator()
+ self.assertEqual(translator.translate_cg_gesture({110: 6, 113: 0.5, 132: 2}), [])
+
class FakeDockFields:
def __init__(self, motion, progress, phase=DOCK_PHASE_ENDED, velocity=0.0, hid=DOCK_SWIPE_HID_TYPE):
diff --git a/mac_app/tests/test_idle_refresh.py b/mac_app/tests/test_idle_refresh.py
new file mode 100644
index 0000000..7ba3234
--- /dev/null
+++ b/mac_app/tests/test_idle_refresh.py
@@ -0,0 +1,94 @@
+import copy
+import json
+import tempfile
+import unittest
+from pathlib import Path
+from unittest import mock
+from types import SimpleNamespace
+
+import kvm_bridge_app as app
+import settings_store
+from mac_app.tests.test_window_geometry import offscreen_control_window
+
+
+class IdleRefreshTests(unittest.TestCase):
+ def setUp(self):
+ self.window = offscreen_control_window()
+ self.addCleanup(self.window.appearance_watch.stop)
+ for name in ('accessibility_granted', 'input_monitoring_granted'):
+ patch = mock.patch.object(app, name, return_value=True)
+ patch.start()
+ self.addCleanup(patch.stop)
+
+ def test_unchanged_tick_reads_no_settings_and_rebuilds_no_window(self):
+ self.window.refresh()
+ with mock.patch.object(self.window.settings_store, 'load_settings') as read, \
+ mock.patch.object(self.window, '_show_same') as same, \
+ mock.patch.object(self.window, '_show_arrangement') as arrangement, \
+ mock.patch.object(self.window.panel, '_build_rows') as rows:
+ self.window.refresh()
+ read.assert_not_called()
+ same.assert_not_called()
+ arrangement.assert_not_called()
+ rows.assert_not_called()
+
+ def test_mutated_settings_and_live_status_are_seen_next_tick(self):
+ self.window.refresh()
+ with mock.patch.object(self.window, '_show_arrangement', wraps=self.window._show_arrangement) as arrangement:
+ self.window.settings_store.current()['name'] = 'Changed remotely'
+ self.window.refresh()
+ arrangement.assert_called_once()
+ self.window.controller.input_error = 'Synthetic capture error'
+ self.window.refresh()
+ self.assertIn('Synthetic capture error', self.window.capture_status.text)
+
+ def test_unchanged_map_inputs_do_not_redraw_even_when_status_changes(self):
+ self.window.refresh()
+ with mock.patch.object(self.window.atlas_canvas, '_draw') as draw:
+ self.window.controller.input_error = 'Capture state changed'
+ self.window.refresh()
+ draw.assert_not_called()
+
+ def test_hidden_tray_tick_skips_window_and_keeps_capture_retry(self):
+ tray = SimpleNamespace(controller=self.window.controller, control_window=self.window,
+ windows_input=mock.Mock(), gesture_overlay=mock.Mock(),
+ measure_notch=mock.Mock(), set_menu_bar_symbol=mock.Mock(),
+ toggle_item=app._tray_item('toggle'), pause_item=app._tray_item('pause'),
+ _machine_items=mock.Mock(), _direction_items=mock.Mock(),
+ _refresh_tray_state=mock.Mock())
+ with mock.patch.object(self.window.window, 'isVisible', return_value=False), \
+ mock.patch.object(self.window, 'refresh') as refresh, \
+ mock.patch.object(self.window, 'retry_capture') as retry, \
+ mock.patch.object(self.window.settings_store, 'load_settings') as read:
+ app.TrayApp.refresh_status(tray, None)
+ refresh.assert_not_called()
+ read.assert_not_called()
+ retry.assert_called_once_with()
+
+ def test_unchanged_menu_glyph_is_not_rebuilt(self):
+ tray = SimpleNamespace(_symbol='local', _nsapp=None)
+ with mock.patch.object(app, 'menu_bar_glyph') as glyph:
+ app.TrayApp.set_menu_bar_symbol(tray, 'local')
+ glyph.assert_not_called()
+ app.TrayApp.set_menu_bar_symbol(tray, 'held')
+ app.TrayApp.set_menu_bar_symbol(tray, 'held')
+ glyph.assert_called_once_with('held')
+
+
+class CachedSettingsTests(unittest.TestCase):
+ def test_unchanged_load_does_not_read_but_atomic_replacement_does(self):
+ with tempfile.TemporaryDirectory() as directory:
+ path = Path(directory) / 'idle-data.json'
+ store = settings_store.SettingsStore(path)
+ store.save_settings(store._complete(store._fresh()))
+ store.load()
+ with mock.patch.object(store, '_read', wraps=store._read) as read:
+ store.load()
+ read.assert_not_called()
+ changed = copy.deepcopy(store.current())
+ changed['name'] = 'New remote name'
+ replacement = path.with_suffix('.replacement')
+ replacement.write_text(json.dumps(changed))
+ replacement.replace(path)
+ self.assertEqual(store.load_settings()['name'], 'New remote name')
+ read.assert_called_once()
diff --git a/mac_app/tests/test_input_injector_mac.py b/mac_app/tests/test_input_injector_mac.py
index 70c6d00..b0eec0b 100644
--- a/mac_app/tests/test_input_injector_mac.py
+++ b/mac_app/tests/test_input_injector_mac.py
@@ -14,6 +14,13 @@ from core.return_edge import Rect
class KeyPlanTests(unittest.TestCase):
+ def test_auxiliary_key_numbers_cover_volume_and_brightness(self):
+ self.assertEqual(injector.MEDIA_NX_KEYS["volume_up"], 0)
+ self.assertEqual(injector.MEDIA_NX_KEYS["volume_down"], 1)
+ self.assertEqual(injector.MEDIA_NX_KEYS["volume_mute"], 7)
+ self.assertEqual(injector.MEDIA_NX_KEYS["brightness_up"], 2)
+ self.assertEqual(injector.MEDIA_NX_KEYS["brightness_down"], 3)
+
def plan(self, name, down=True, mods=None):
return injector.plan_key_event(name, down, set() if mods is None else mods)
diff --git a/mac_app/tests/test_login_item.py b/mac_app/tests/test_login_item.py
new file mode 100644
index 0000000..b64c153
--- /dev/null
+++ b/mac_app/tests/test_login_item.py
@@ -0,0 +1,39 @@
+"""The macOS approval path for start at login."""
+
+import unittest
+from unittest.mock import Mock, patch
+from pathlib import Path
+
+import login_item
+
+
+class LoginItemTests(unittest.TestCase):
+ def test_requires_approval_has_a_clear_status(self):
+ self.assertEqual(login_item.status_text(login_item.REQUIRES_APPROVAL), "Requires approval")
+
+ def test_only_an_applications_bundle_is_eligible_for_login(self):
+ self.assertTrue(login_item.installed_in_applications("/Applications/Beamer.app"))
+ self.assertTrue(login_item.installed_in_applications("/Applications/Utilities/Beamer.app"))
+ self.assertTrue(login_item.installed_in_applications(str(Path.home() / "Applications" / "Beamer.app")))
+ self.assertFalse(login_item.installed_in_applications("/Downloads/Beamer.app"))
+ self.assertFalse(login_item.installed_in_applications("/AppTranslocation/Beamer.app"))
+
+ def test_a_moved_app_can_remove_but_not_add_its_login_item(self):
+ path = "/Downloads/Beamer.app"
+ self.assertFalse(login_item.can_toggle(login_item.NOT_REGISTERED, path))
+ self.assertTrue(login_item.can_toggle(login_item.ENABLED, path))
+
+ def test_non_default_launch_stays_in_the_menu_bar(self):
+ self.assertTrue(login_item.is_background_launch(False))
+ self.assertFalse(login_item.is_background_launch(True))
+ self.assertFalse(login_item.is_background_launch(None))
+
+ def test_opens_login_items_settings(self):
+ service = Mock()
+ with patch.object(login_item, "SMAppService", service):
+ login_item.open_system_settings()
+ service.openSystemSettingsLoginItems.assert_called_once_with()
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/mac_app/tests/test_mac_arrival_grace.py b/mac_app/tests/test_mac_arrival_grace.py
new file mode 100644
index 0000000..0f355ff
--- /dev/null
+++ b/mac_app/tests/test_mac_arrival_grace.py
@@ -0,0 +1,75 @@
+"""rc14, 10-10-2026: the rig's corner sent input home onto the end of the Mac's bottom edge, and the
+hand still moving left from that push crossed the Mac's left zone to the loan laptop 14 ms later."""
+
+import os
+import sys
+import unittest
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+
+from core import return_edge
+from crossing import CrossingEngine, Ways
+
+BOUNDS = (0, 0, 1728, 1117)
+
+
+def three_ways():
+ """The Mac as the owner's log had it: the rig below, the loan laptop on the left, at 360 px."""
+ return CrossingEngine(resistance_px=360, ways=[
+ Ways("rig", frozenset({"edge"}), "bottom", frozenset(return_edge.PARTS), "top_right"),
+ Ways("acg", frozenset({"edge"}), "left", frozenset(return_edge.PARTS), "top_right"),
+ ])
+
+
+def flick_left(machine, start, events=14, dx=-30.0, every=0.001):
+ """A 1 kHz mouse still going left: the OS holds the pointer at the left wall once it gets there."""
+ x, y = start
+ for index in range(events):
+ x = max(0.0, x + dx)
+ step = machine.feed(x, y, dx, -2.0, BOUNDS, 10.0 + index * every)
+ if step.crossed:
+ return step
+ return None
+
+
+class ArrivalGrace(unittest.TestCase):
+ def test_landing_at_the_end_of_an_edge_is_clear_of_the_edge_beside_it(self):
+ for offset in (0.0, 1.0):
+ x, y = CrossingEngine.arrival_point("bottom", offset, BOUNDS)
+ self.assertGreaterEqual(x, return_edge.LANDING_CLEAR_PX, offset)
+ self.assertLessEqual(x, BOUNDS[2] - 1 - return_edge.LANDING_CLEAR_PX, offset)
+
+ def test_the_push_that_brought_input_home_does_not_go_on_to_another_machine(self):
+ machine = three_ways()
+ machine.start_grace(10.0)
+ self.assertIsNone(flick_left(machine, CrossingEngine.arrival_point("bottom", 0.0, BOUNDS)))
+
+ def test_without_the_grace_the_same_flick_crosses(self):
+ self.assertEqual(flick_left(three_ways(), (0.0, 1112.0)).peer, "acg")
+
+ def test_a_push_after_the_grace_crosses(self):
+ machine = three_ways()
+ machine.start_grace(10.0)
+ self.assertIsNone(flick_left(machine, (0.0, 1112.0)))
+ step = None
+ for index in range(40):
+ step = machine.feed(0.0, 600.0, -30.0, 0.0, BOUNDS, 10.0 + return_edge.ARRIVAL_GRACE_SECONDS + index * 0.01)
+ if step.crossed:
+ break
+ self.assertTrue(step.crossed)
+ self.assertEqual(step.peer, "acg")
+
+ def test_moving_back_off_an_edge_ends_its_grace_early(self):
+ machine = three_ways()
+ machine.start_grace(10.0)
+ machine.feed(20.0, 600.0, return_edge.ARRIVAL_GRACE_PX + 1, 0.0, BOUNDS, 10.01)
+ step = None
+ for index in range(40):
+ step = machine.feed(0.0, 600.0, -30.0, 0.0, BOUNDS, 10.02 + index * 0.002)
+ if step.crossed:
+ break
+ self.assertTrue(step.crossed, "a deliberate push back out crosses inside the grace")
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/mac_app/tests/test_mac_links.py b/mac_app/tests/test_mac_links.py
index 897ee6f..e97e49e 100644
--- a/mac_app/tests/test_mac_links.py
+++ b/mac_app/tests/test_mac_links.py
@@ -43,6 +43,37 @@ class Base(unittest.TestCase):
return focuses[index]["data"]
+class AckStallRecoveryTests(Base):
+ def test_a_heartbeat_only_peer_stall_ends_the_visit_and_releases_the_cursor(self):
+ self.up()
+ self.assertTrue(self.controller.set_redirecting(True))
+
+ with self.assertLogs(self.controller.logger, level="WARNING") as said:
+ self.link.callbacks["state"](self.link, False, "Office PC stopped acknowledging input")
+
+ self.assertFalse(self.controller.redirecting)
+ self.assertFalse(self.controller.owner.away)
+ self.assertIn(True, FakeQuartz.associate_calls)
+ self.assertTrue(any("stopped acknowledging input" in line for line in said.output), said.output)
+
+ def test_a_peer_switch_is_logged_as_the_move_source(self):
+ self.up()
+ with self.controller.book.lock:
+ peers = self.controller.book.data["peers"]
+ peers.append({**peers[0], "id": protocol.id_text(OTHER_ID), "token": "second", "send": True})
+ self.controller._sync_links()
+ other = self.controller.links["second"]
+ other.up(self.controller, ident=OTHER_ID, name="Laptop", platform="macos")
+ self.assertTrue(self.controller.set_redirecting(True))
+ self.link.arrives(self.controller, protocol.accept_msg(1))
+
+ with self.assertLogs(self.controller.logger, level="INFO") as said:
+ self.link.arrives(self.controller, protocol.switch_v6(1, OTHER_ID))
+ other.arrives(self.controller, protocol.accept_msg(self.controller.owner.route))
+
+ self.assertTrue(any("move started by peer request" in line for line in said.output), said.output)
+
+
class HardwareHookTests(unittest.TestCase):
def controller(self, **kwargs):
return KVMController(
diff --git a/mac_app/tests/test_mac_loopback.py b/mac_app/tests/test_mac_loopback.py
index 3c3c135..a01cbb3 100644
--- a/mac_app/tests/test_mac_loopback.py
+++ b/mac_app/tests/test_mac_loopback.py
@@ -6,16 +6,25 @@ through the controller's event tap and the Mac's responder."""
import os
import sys
import unittest
+from unittest import mock
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
from bridge_fakes import FakeQuartz
-from core import protocol
+from core import protocol, return_edge
from two_machines import PC_TEXT, Duo, wait_for
A_KEYCODE, COMMAND_KEYCODE = 0x00, 0x37
+def setUpModule():
+ # These push home the moment input lands; the arrival grace is test_arrival_grace's subject,
+ # not theirs, as in test_way_home and core's loopback tests.
+ grace = mock.patch.object(return_edge, "ARRIVAL_GRACE_SECONDS", 0.0)
+ grace.start()
+ unittest.addModuleCleanup(grace.stop)
+
+
def key_event(down, keycode, character=None):
event = {FakeQuartz.kCGKeyboardEventKeycode: keycode}
if character is not None:
diff --git a/mac_app/tests/test_mac_three.py b/mac_app/tests/test_mac_three.py
index 59ab6df..fccf788 100644
--- a/mac_app/tests/test_mac_three.py
+++ b/mac_app/tests/test_mac_three.py
@@ -228,10 +228,13 @@ class TheLinkInArrangement(Three):
def test_a_machine_linked_in_is_told_whether_a_way_leads_to_it(self):
self.data["zones"][1]["off"] = True
self.input.server.caps_of = lambda _peer: frozenset()
- told = {name: [m["data"] for m in self.input._announce(ident) if m["type"] == protocol.MSG_ARRANGEMENT]
- for name, ident in (("bee", BEE), ("sea", SEA))}
- self.assertIs(told["bee"][0]["way_back"], True)
- self.assertIs(told["sea"][0]["way_back"], False)
+ sent = []
+ self.input.server.send = lambda peer, message: sent.append((peer, message)) or True
+ self.input._announce(BEE)
+ self.input._announce(SEA)
+ told = {peer: message["data"] for peer, message in sent if message["type"] == protocol.MSG_ARRANGEMENT}
+ self.assertIs(told[BEE]["way_back"], True)
+ self.assertIs(told[SEA]["way_back"], False)
def test_a_side_sent_over_its_link_says_whether_a_way_leads_there_and_who_set_it(self):
sent = []
diff --git a/mac_app/tests/test_mac_to_mac.py b/mac_app/tests/test_mac_to_mac.py
index 88c8289..b6eb6cb 100644
--- a/mac_app/tests/test_mac_to_mac.py
+++ b/mac_app/tests/test_mac_to_mac.py
@@ -17,13 +17,13 @@ sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspa
import config
import input_injector_mac
import windows_input
-from bridge import KVMController
+from bridge import KVMController, links_from_store
import bridge_fakes
from bridge_fakes import PAIRED_TOKEN, FakeClock, FakeQuartz, crossing_config, quiet_logger
from core import protocol
from core.return_edge import Rect
from core.tests.responder_harness import FakeDesktop, FakeInjector, entry
-from settings_store import SettingsStore
+from settings_store import SettingsStore, config_to_raw
from two_machines import free_port, wait_for
BOUNDS = (0, 0, 1728, 1117)
@@ -57,17 +57,19 @@ class _Mac:
settings["zones"] = [{"peer": other.text, "kind": "edge"}]
self.store.save_settings(settings)
cfg = crossing_config(PAIRED_TOKEN, edge=side, resistance_px=40)
- cfg.host, cfg.port, cfg.auth_token = "127.0.0.1", self.port, PAIRED_TOKEN
+ cfg.host, cfg.port, cfg.auth_token = "127.0.0.1", other.port, PAIRED_TOKEN
cfg.reconnect_interval_s = 0.05
cfg.key_map = key_map
# Right Option is Beamer's own shortcut by default and stays on the Mac; moved off the
# modifiers so every one of them is pressed through.
cfg.trigger_key = "f19"
+ cfg = self.store.save(config_to_raw(cfg))
self.cfg = cfg
self.clipboard = bridge_fakes.FakeClipboard(f"on {self.name}")
+ book, identity = links_from_store(self.store, "1.5.2")
self.controller = KVMController(
cfg, logger=quiet_logger(), quartz=FakeQuartz, clock=self.clock, desktop_bounds=lambda: BOUNDS,
- book=self.store.book(), clipboard=self.clipboard,
+ book=book, identity=identity, clipboard=self.clipboard,
)
self.controller.on_user_alert = lambda title, message: None
self.injector = FakeInjector()
diff --git a/mac_app/tests/test_mac_wire.py b/mac_app/tests/test_mac_wire.py
index 2565e60..15a463d 100644
--- a/mac_app/tests/test_mac_wire.py
+++ b/mac_app/tests/test_mac_wire.py
@@ -143,6 +143,8 @@ class TakingTheFarMachineTests(Wire):
# The take's own clipboard first, read on its own thread: a copy there before it lands is
# overwritten by it, as one made by input sent there could not be (input waits behind it).
self.assertTrue(wait_for(lambda: self.machine.clipboard.set_calls))
+ self.assertTrue(wait_for(lambda: self.machine.clipboard.change_stamp() > 1),
+ "the take's clipboard write never finished")
self.machine.clipboard.copy("copied there")
self.controller.set_redirecting(False)
self.assertTrue(wait_for(lambda: ("copied there", None) in self.clipboard.set_calls), self.clipboard.set_calls)
diff --git a/mac_app/tests/test_machines_panel.py b/mac_app/tests/test_machines_panel.py
index acc3644..41777b2 100644
--- a/mac_app/tests/test_machines_panel.py
+++ b/mac_app/tests/test_machines_panel.py
@@ -20,8 +20,9 @@ AppKit.NSApplication.sharedApplication()
import bridge # noqa: E402
import kvm_bridge_app # noqa: E402
import settings_store # noqa: E402
+import widgets # noqa: E402
from bridge_fakes import PAIRED_TOKEN # noqa: E402
-from core import feature_flags, pairing # noqa: E402
+from core import feature_flags, pairing, ways # noqa: E402
from fake_link import FakeLink # noqa: E402
from wake import WakingController # noqa: E402
@@ -92,6 +93,9 @@ def heard(name="Laptop", pair_id="abc", **extra):
class Base(unittest.TestCase):
def setUp(self):
+ capture = mock.patch.object(WakingController, "start_input_capture")
+ capture.start()
+ self.addCleanup(capture.stop)
self.directory = tempfile.TemporaryDirectory()
path = Path(self.directory.name) / "config.json"
raw = settings_store.config_to_raw(settings_store.editable_default_config())
@@ -111,6 +115,8 @@ class Base(unittest.TestCase):
self.panel.service = self.service
self.directions = []
self.window.direction_handler = lambda token, **change: self.directions.append((token, change))
+ self.left_out = []
+ self.window.left_out_handler = lambda token, enabled: self.left_out.append((token, enabled))
def tearDown(self):
self.window.appearance_watch.stop()
@@ -123,6 +129,16 @@ class Base(unittest.TestCase):
def rows(self):
return [view for view in self.panel.list.arrangedSubviews()]
+ def row_with_control(self, token, control_name):
+ for row in self.rows():
+ stack = [row]
+ while stack:
+ view = stack.pop()
+ if getattr(view, "focus_id", None) == (token, control_name):
+ return row
+ stack.extend(view.subviews())
+ raise AssertionError(f"no {control_name} control for {token}")
+
def texts(self, view):
found = []
if isinstance(view, AppKit.NSTextField):
@@ -133,6 +149,70 @@ class Base(unittest.TestCase):
class ListTests(Base):
+ def test_renaming_a_machine_saves_on_return_and_escape_cancels(self):
+ self.pair(FIRST, SECOND_TOKEN, "Studio")
+ self.panel.refresh()
+ name, button, _box, edit, note, delegate = self.panel._rename_views[SECOND_TOKEN]
+ button.press()
+ self.assertFalse(note.view.isHidden())
+ edit.setStringValue_(" Work Mac ")
+ delegate.control_textView_doCommandBySelector_(edit, None, "insertNewline:")
+ self.assertEqual(self.store.current()["peers"][1]["label"], "Work Mac")
+ self.assertIn("Work Mac", self.rows()[1].accessibilityLabel())
+
+ name, button, box, edit, _note, delegate = self.panel._rename_views[SECOND_TOKEN]
+ button.press()
+ edit.setStringValue_("Discard this")
+ delegate.control_textView_doCommandBySelector_(edit, None, "cancelOperation:")
+ self.assertEqual(self.store.current()["peers"][1]["label"], "Work Mac")
+ self.assertTrue(box.isHidden())
+ self.assertFalse(name.isHidden())
+
+ button.press()
+ self.assertEqual(edit.stringValue(), "Work Mac")
+
+ def test_desktop_row_offers_leave_out_and_names_the_shortcut_when_left_out(self):
+ self.pair(FIRST, SECOND_TOKEN, "Studio")
+ row = self.row_with_control(SECOND_TOKEN, "left_out")
+ controls = []
+ def collect(view):
+ if isinstance(view, widgets.Pressable):
+ controls.append(view)
+ for subview in view.subviews():
+ collect(subview)
+ collect(row)
+
+ self.window.left_out_handler = self._toggle_left_out
+ leave_out = next(control for control in controls if control.focus_id == (SECOND_TOKEN, "left_out"))
+ leave_out.press()
+ row = self.row_with_control(SECOND_TOKEN, "left_out")
+ self.assertIn("Left out of the layout. The shortcut and the menu still reach it.", self.texts(row))
+ controls = []
+ collect(row)
+ put_back = next(control for control in controls if control.focus_id == (SECOND_TOKEN, "left_out"))
+ self.assertEqual(put_back.accessibilityLabel(), f"Put back Studio ({FIRST[-4:]})")
+ put_back.press()
+ row = self.row_with_control(SECOND_TOKEN, "left_out")
+ self.assertNotIn("Left out of the layout. The shortcut and the menu still reach it.", self.texts(row))
+ self.assertIn(f"Leave out Studio ({FIRST[-4:]})", self.accessibility_labels(row))
+ self.assertEqual(self.left_out, [(SECOND_TOKEN, True), (SECOND_TOKEN, False)])
+
+ def _toggle_left_out(self, token, enabled):
+ self.left_out.append((token, enabled))
+ settings = self.store.current()
+ peer = next(item for item in settings["peers"] if item["token"] == token)
+ (ways.leave_out if enabled else ways.put_back)(settings, peer["id"])
+ self.store.save_settings(settings)
+ self.window.peers_changed()
+
+ def accessibility_labels(self, view):
+ labels = []
+ if isinstance(view, widgets.Pressable):
+ labels.append(view.accessibilityLabel())
+ for subview in view.subviews():
+ labels.extend(self.accessibility_labels(subview))
+ return labels
+
def test_the_migrated_machine_is_listed_by_its_name_and_where_it_is(self):
self.panel.refresh()
self.assertEqual(len(self.rows()), 1)
@@ -337,7 +417,9 @@ class ShowingACodeTests(Base):
@mock.patch.object(feature_flags, "PAIRING_QR_VISIBLE", True)
def test_the_code_is_shown_in_two_groups_with_its_address_and_a_qr(self):
- with mock.patch.object(kvm_bridge_app.machines_panel.pairing, "pairing_address", return_value="192.0.2.9"):
+ image = AppKit.NSImage.alloc().initWithSize_((180, 180))
+ with mock.patch.object(kvm_bridge_app.machines_panel.pairing, "pairing_address", return_value="192.0.2.9"), \
+ mock.patch.object(kvm_bridge_app.machines_panel.qr, "image", return_value=image) as render:
self.panel._toggle_sheet()
self.panel._show_code()
self.panel.refresh()
@@ -347,6 +429,7 @@ class ShowingACodeTests(Base):
self.assertIn("192.0.2.9", self.panel.code_address.text)
self.assertFalse(self.panel.qr_view.isHidden())
self.assertIsNotNone(self.panel.qr_view.image())
+ self.assertEqual(render.call_args.args[0], self.service.qr)
self.assertTrue(self.panel.show_button.view.isHidden())
@mock.patch.object(feature_flags, "PAIRING_QR_VISIBLE", True)
@@ -510,6 +593,17 @@ class EnteringACodeTests(Base):
self.assertEqual(self.said[-1], ("Paired with Laptop. Connecting…", "signal"))
self.assertEqual(len(self.controller.links), 2)
+ def test_pairing_success_uses_the_disambiguated_peer_label(self):
+ self.store.current()["peers"][0]["label"] = "Laptop"
+ self.store.add_peer(entry(FIRST, SECOND_TOKEN, "Laptop"))
+ self.window.peers_changed()
+ result = entry(THIRD, THIRD_TOKEN, "Laptop")
+ self.store.add_peer(result)
+ self.window.peers_changed()
+ self.panel._finished("Laptop", result)
+
+ self.assertEqual(self.said[-1], (f"Paired with Laptop ({THIRD[-4:]}). Connecting…", "signal"))
+
def test_a_typed_address_pairs_by_address_and_beats_a_chosen_machine(self):
self.service.result = entry(FIRST, SECOND_TOKEN, "Laptop")
self.store.add_peer(self.service.result)
@@ -610,7 +704,7 @@ class EnteringACodeTests(Base):
class CodeBoxCentringTests(Base):
- """beta.4 on Toby's Mac: each typed digit sat left of the middle of its box. Measured on the real
+ """beta.4 on a test Mac: each typed digit sat left of the middle of its box. Measured on the real
window's boxes, drawn offscreen at the 773-point width it had, never put on screen."""
def ink_offsets(self):
@@ -761,7 +855,6 @@ class TrayTests(Base):
tray._direction_items = lambda: None
kvm_bridge_app.TrayApp.refresh_status(tray, None)
self.assertNotIn("192.0.2", tray.toggle_item.title)
- self.assertNotIn("192.0.2", tray.status_item.title)
def test_a_pairing_this_mac_hosted_reaches_the_window_on_the_main_thread(self):
tray = self.tray()
diff --git a/mac_app/tests/test_map_ticks.py b/mac_app/tests/test_map_ticks.py
new file mode 100644
index 0000000..2a6d60f
--- /dev/null
+++ b/mac_app/tests/test_map_ticks.py
@@ -0,0 +1,386 @@
+"""The Crossing map's thirds breaks, shortcut-cycle badge, fit, seam and notch dash, on a standalone
+canvas with synthetic tiles (rc14: ticks hung inside the lower tile and the tick read as a caret)."""
+
+import sys
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[2]))
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+import AppKit
+import Quartz
+
+AppKit.NSApplication.sharedApplication()
+
+import diagram
+import theme
+from core import ways as core_ways
+from core.return_edge import Rect
+
+PARTS = ["start", "middle", "end"]
+OWN, LAPTOP, FEDORA, DESK = "0a" * 16, "1b" * 16, "2c" * 16, "3d" * 16
+LABELS = {OWN: "This Mac", LAPTOP: "Loan laptop with a long name", FEDORA: "fedora", DESK: "Desk-PC-Workstation"}
+TWO_WIDE = {"a": {"x": 0, "y": 0, "w": 1920, "h": 1080}, "b": {"x": 1920, "y": 0, "w": 1920, "h": 1080}}
+# Two displays meeting at a corner beside a side contact: under This Mac and off its bottom-right
+# corner, then This Mac's right-hand display off the bottom-right corner of a machine under its left one.
+DISPLAY_CORNERS = ({OWN: {"x": 0, "y": 0, "w": 160, "h": 90}, DESK: {"x": 0, "y": 90, "w": 320, "h": 90, "displays": TWO_WIDE}},
+ {OWN: {"x": 0, "y": 0, "w": 160, "h": 90, "displays": TWO_WIDE}, DESK: {"x": 0, "y": 90, "w": 80, "h": 90}})
+ROW = {OWN: {"x": 0, "y": 0, "w": 160, "h": 100},
+ LAPTOP: {"x": -160, "y": 0, "w": 160, "h": 100},
+ FEDORA: {"x": -320, "y": 0, "w": 160, "h": 100},
+ DESK: {"x": 0, "y": 100, "w": 160, "h": 100}}
+DISPLAYS = {"0": {"x": 0, "y": 0, "w": 2560, "h": 1440}, "1": {"x": 2560, "y": 0, "w": 1512, "h": 982}}
+# An external display with the shorter built-in to its right, top edges level, and a machine below
+# reaching under both: only the external's bottom edge touches it.
+WITH_DISPLAYS = {OWN: {"x": 0, "y": 0, "w": 226, "h": 80, "displays": DISPLAYS},
+ DESK: {"x": 60, "y": 80, "w": 113, "h": 70}}
+
+
+def peer_state(**changes):
+ return {"state": "edge", "crosses": True, "linked": True, "in_use": True, "platform": "Windows",
+ "picked_thirds": PARTS, "lit_thirds": PARTS, "edge_off": False, **changes}
+
+
+def canvas_for(tiles=ROW, size=(850, 260), desk=None, own=None):
+ canvas = diagram.AtlasCanvas.alloc().initWithFrame_(((0, 0), size)).setup()
+ states = {key: peer_state() for key in tiles if key != OWN}
+ states[OWN] = {"state": "this", "platform": "macOS", "machine_name": "Studio Mac", **(own or {})}
+ states[DESK] = peer_state(**(desk or {}))
+ canvas.show_layout(tiles, states, LABELS, OWN, DESK,
+ cycle={key: True for key in tiles if key != OWN}, cycle_enabled=True)
+ canvas._draw(False)
+ return canvas
+
+
+def rect_of(layer):
+ frame = layer.frame()
+ return frame.origin.x, frame.origin.y, frame.size.width, frame.size.height
+
+
+def intersects(one, two):
+ return (one[0] < two[0] + two[2] and two[0] < one[0] + one[2]
+ and one[1] < two[1] + two[3] and two[1] < one[1] + one[3])
+
+
+class MapTicks(unittest.TestCase):
+ def pieces(self, canvas, kind="seam"):
+ found = [segment for segment in canvas.seam_segments if segment["peer"] == DESK and segment["kind"] == kind]
+ return sorted(found, key=lambda segment: segment["start"][0])
+
+ def assert_breaks(self, canvas, wanted):
+ pieces = sorted(self.pieces(canvas, "seam") + self.pieces(canvas, "track"), key=lambda s: s["start"][0])
+ self.assertEqual(len(pieces), len(wanted) + 1)
+ for (before, after), point in zip(zip(pieces, pieces[1:]), wanted):
+ seen_end = before["end"][0] + before["width"] / 2
+ seen_start = after["start"][0] - after["width"] / 2
+ self.assertAlmostEqual((seen_end + seen_start) / 2, point, delta=0.01)
+ self.assertAlmostEqual(seen_start - seen_end, diagram.THIRD_GAP, delta=0.01)
+
+ def test_breaks_are_centred_on_the_thirds_of_the_shared_stretch(self):
+ canvas = canvas_for()
+ x, _y, width, _height = canvas._map()[0][OWN]
+ self.assert_breaks(canvas, [x + width / 3, x + 2 * width / 3])
+
+ def test_an_unlit_third_breaks_the_same_way_as_a_lit_one(self):
+ canvas = canvas_for(desk={"lit_thirds": ["start", "end"], "picked_thirds": ["start", "end"]})
+ x, _y, width, _height = canvas._map()[0][OWN]
+ self.assertEqual(len(self.pieces(canvas, "track")), 1)
+ self.assert_breaks(canvas, [x + width / 3, x + 2 * width / 3])
+
+ def test_partial_contact_breaks_at_this_macs_own_third_boundaries(self):
+ tiles = {OWN: ROW[OWN], DESK: {"x": 40, "y": 100, "w": 80, "h": 100}}
+ canvas = canvas_for(tiles)
+ x, _y, width, _height = canvas._map()[0][OWN]
+ self.assert_breaks(canvas, [x + width / 3, x + 2 * width / 3])
+ pieces = self.pieces(canvas)
+ scale = canvas._map()[1]
+ self.assertAlmostEqual(pieces[0]["start"][0], x + 40 * scale + 2)
+ self.assertAlmostEqual(pieces[-1]["end"][0], x + 120 * scale - 2)
+
+ def test_nothing_for_the_thirds_is_drawn_outside_the_seam_band(self):
+ for desk in ({}, {"lit_thirds": ["middle"], "picked_thirds": ["middle"]}):
+ with self.subTest(desk=desk):
+ canvas = canvas_for(desk=desk)
+ line = canvas._map()[0][OWN][1] + canvas._map()[0][OWN][3]
+ self.assertTrue(self.pieces(canvas))
+ for segment in self.pieces(canvas) + self.pieces(canvas, "track"):
+ for point in (segment["start"], segment["end"]):
+ self.assertLessEqual(abs(point[1] - line) + segment["width"] / 2, 2.0)
+ self.assertFalse(any(key[-1] == "divider" for key in canvas.third_layers))
+ for layer in canvas.third_layers.values():
+ box = Quartz.CGPathGetBoundingBox(layer.path())
+ self.assertLessEqual(abs(box.origin.y - line) + layer.lineWidth() / 2, 2.0)
+ self.assertEqual(box.size.height, 0)
+
+ def test_edge_off_draws_nothing_for_the_thirds(self):
+ canvas = canvas_for(desk={"crosses": False, "edge_off": True, "picked_thirds": [], "lit_thirds": []})
+ self.assertEqual(self.pieces(canvas) + self.pieces(canvas, "track"), [])
+ self.assertEqual(canvas.third_layers, {})
+ self.assertEqual(len(canvas._third_segments(canvas._map()[0])), 3)
+
+ def test_unselected_peer_seam_is_one_unbroken_line(self):
+ canvas = canvas_for()
+ laptop = [segment for segment in canvas.seam_segments if segment["peer"] == LAPTOP]
+ self.assertEqual(len(laptop), 1)
+ x, y, _width, height = canvas._map()[0][OWN]
+ self.assertEqual(laptop[0]["start"], (x, y + 2))
+ self.assertEqual(laptop[0]["end"], (x, y + height - 2))
+
+ def test_lit_seam_lies_on_the_shared_edge_and_spans_the_shared_stretch(self):
+ canvas = canvas_for()
+ frames = canvas._map()[0]
+ own, desk = frames[OWN], frames[DESK]
+ self.assertAlmostEqual(own[1] + own[3], desk[1], delta=0.5)
+ pieces = self.pieces(canvas)
+ for segment in pieces:
+ self.assertAlmostEqual(segment["start"][1], own[1] + own[3], delta=0.5)
+ self.assertAlmostEqual(segment["end"][1], desk[1], delta=0.5)
+ self.assertAlmostEqual(pieces[0]["start"][0], own[0] + 2)
+ self.assertAlmostEqual(pieces[-1]["end"][0], own[0] + own[2] - 2)
+
+ def test_badge_never_meets_the_name_at_any_tile_height(self):
+ for size, band in (((850, 260), "row"), ((260, 260), "small"), ((200, 260), "tiny")):
+ canvas = canvas_for(size=size)
+ frames = canvas._map()[0]
+ for key, frame in frames.items():
+ with self.subTest(band=band, peer=LABELS[key]):
+ {"row": lambda: self.assertGreaterEqual(frame[3], 56),
+ "small": lambda: self.assertTrue(44 <= frame[3] < 56),
+ "tiny": lambda: self.assertLess(frame[3], 44)}[band]()
+ title = rect_of(canvas.label_for_tile[key])
+ for value, wanted in zip(title, canvas._title_rect(key, frame)):
+ self.assertAlmostEqual(value, wanted)
+ if key == OWN:
+ self.assertTrue(canvas.cycle_for_tile[key].isHidden())
+ self.assertAlmostEqual(title[0], frame[0] + 8)
+ continue
+ box = rect_of(canvas.cycle_for_tile[key])
+ self.assertFalse(canvas.cycle_for_tile[key].isHidden())
+ for value, wanted in zip(box, canvas._cycle_box(frame)):
+ self.assertAlmostEqual(value, wanted)
+ self.assertEqual(box[2:], (16, 16))
+ self.assertAlmostEqual(box[0], frame[0] + frame[2] - 24)
+ self.assertFalse(intersects(box, title))
+ if band == "small":
+ self.assertGreaterEqual(title[2], frame[2] - 16 - 1e-9)
+ self.assertAlmostEqual(title[1], frame[1] + 4)
+ self.assertAlmostEqual(box[1], frame[1] + frame[3] - 20)
+ else:
+ self.assertAlmostEqual(box[1] + 8, title[1] + title[3] / 2)
+ if band == "tiny":
+ self.assertAlmostEqual(title[0] + title[2], box[0] - 6)
+
+ def test_a_name_that_fits_stays_centred_and_a_long_one_takes_the_room_left_of_the_badge(self):
+ canvas = canvas_for()
+ frames = canvas._map()[0]
+ short, long = rect_of(canvas.label_for_tile[FEDORA]), rect_of(canvas.label_for_tile[LAPTOP])
+ fedora, laptop = frames[FEDORA], frames[LAPTOP]
+ self.assertAlmostEqual(short[0], fedora[0] + 30)
+ self.assertAlmostEqual(short[0] - fedora[0], fedora[0] + fedora[2] - short[0] - short[2])
+ self.assertAlmostEqual(long[0], laptop[0] + 8)
+ self.assertAlmostEqual(long[0] + long[2], canvas._cycle_box(laptop)[0] - 6)
+
+ def test_cycle_hit_tooltip_and_accessibility_frame_share_the_box(self):
+ canvas = canvas_for()
+ frame = canvas._map()[0][DESK]
+ x, y, width, height = canvas._cycle_box(frame)
+ hit = canvas._cycle_hit_rect(frame)
+ self.assertEqual(hit, (x - 4, y - 4, 24, 24))
+ self.assertTrue(canvas._cycle_hit(DESK, AppKit.NSMakePoint(x + 8, y + 8)))
+ self.assertTrue(canvas._cycle_hit(DESK, AppKit.NSMakePoint(hit[0] + 0.5, hit[1] + 0.5)))
+ self.assertFalse(canvas._cycle_hit(DESK, AppKit.NSMakePoint(hit[0] - 1, y + 8)))
+ self.assertFalse(canvas._cycle_hit(OWN, AppKit.NSMakePoint(x + 8, y + 8)))
+ element = diagram.AtlasAccessibleElement.alloc().initWithCanvas_key_kind_(canvas, DESK, "cycle")
+ found = element.accessibilityFrame()
+ self.assertEqual((found.origin.x, found.origin.y, found.size.width, found.size.height), hit)
+
+ def test_cycle_hit_follows_the_badge_under_the_name(self):
+ canvas = canvas_for(size=(260, 260))
+ frame = canvas._map()[0][DESK]
+ x, y, _width, _height = canvas._cycle_box(frame)
+ self.assertEqual(canvas._cycle_hit_rect(frame), (x - 4, y - 4, 24, 24))
+ self.assertTrue(canvas._cycle_hit(DESK, AppKit.NSMakePoint(x + 8, y + 8)))
+ element = diagram.AtlasAccessibleElement.alloc().initWithCanvas_key_kind_(canvas, DESK, "cycle")
+ found = element.accessibilityFrame()
+ self.assertEqual((found.origin.x, found.origin.y, found.size.width, found.size.height),
+ canvas._cycle_hit_rect(frame))
+
+ def test_cycle_box_styles(self):
+ canvas = canvas_for()
+ layer = canvas.cycle_for_tile[DESK]
+ check = layer.sublayers()[0]
+ self.assertEqual(layer.cornerRadius(), 3)
+ self.assertEqual(layer.borderWidth(), 0)
+ self.assertTrue(Quartz.CGColorEqualToColor(layer.backgroundColor(), theme.cg("ink_2")))
+ self.assertFalse(check.isHidden())
+ self.assertTrue(Quartz.CGColorEqualToColor(check.strokeColor(), theme.cg("ground")))
+ self.assertAlmostEqual(check.lineWidth(), 1.8)
+ canvas.toggle_cycle(DESK)
+ self.assertEqual(layer.borderWidth(), 1)
+ self.assertTrue(Quartz.CGColorEqualToColor(layer.backgroundColor(), theme.cg("well")))
+ self.assertTrue(Quartz.CGColorEqualToColor(layer.borderColor(), theme.cg("edge")))
+ self.assertTrue(check.isHidden())
+
+ def test_check_glyph_is_a_tick_not_a_caret(self):
+ canvas = canvas_for()
+ bounds = canvas.bounds()
+ rep = AppKit.NSBitmapImageRep.alloc().initWithBitmapDataPlanes_pixelsWide_pixelsHigh_bitsPerSample_samplesPerPixel_hasAlpha_isPlanar_colorSpaceName_bytesPerRow_bitsPerPixel_(
+ None, int(bounds.size.width * 2), int(bounds.size.height * 2), 8, 4, True, False,
+ AppKit.NSDeviceRGBColorSpace, 0, 0)
+ rep.setSize_(bounds.size)
+ canvas.cacheDisplayInRect_toBitmapImageRep_(bounds, rep)
+ x, y, width, height = canvas._cycle_box(canvas._map()[0][DESK])
+ ground = theme.rgb(theme.T["ground"])
+ fill = theme.rgb(theme.T["ink_2"])
+ ink = []
+ for py in range(round((y + 2) * 2), round((y + height - 2) * 2)):
+ for px in range(round((x + 2) * 2), round((x + width - 2) * 2)):
+ colour = rep.colorAtX_y_(px, py).colorUsingColorSpace_(AppKit.NSColorSpace.deviceRGBColorSpace())
+ rgb = (colour.redComponent(), colour.greenComponent(), colour.blueComponent())
+ if sum((a - b) ** 2 for a, b in zip(rgb, ground)) < sum((a - b) ** 2 for a, b in zip(rgb, fill)):
+ ink.append((px / 2, py / 2))
+ self.assertGreater(len(ink), 10)
+ lowest = max(point[1] for point in ink)
+ bottom = [point[0] for point in ink if point[1] == lowest]
+ highest = min(point[1] for point in ink)
+ top = [point[0] for point in ink if point[1] == highest]
+ centre = x + width / 2
+ self.assertLess(sum(bottom) / len(bottom), centre)
+ self.assertGreater(sum(top) / len(top), centre)
+
+ def test_map_fits_and_centres_the_whole_arrangement(self):
+ for size in ((850, 260), (240, 260), (480, 260)):
+ with self.subTest(size=size):
+ canvas = canvas_for(size=size)
+ frames, scale = canvas._map()
+ left = min(frame[0] for frame in frames.values())
+ right = max(frame[0] + frame[2] for frame in frames.values())
+ top = min(frame[1] for frame in frames.values())
+ bottom = max(frame[1] + frame[3] for frame in frames.values())
+ self.assertAlmostEqual((left + right) / 2, size[0] / 2, delta=1)
+ self.assertAlmostEqual((top + bottom) / 2, size[1] / 2, delta=1)
+ room_w, room_h = size[0] - 2 * canvas.INSET, size[1] - 2 * canvas.INSET
+ self.assertTrue(abs(scale - 1.15) < 1e-9 or abs(right - left - room_w) <= 1
+ or abs(bottom - top - room_h) <= 1, (scale, right - left, bottom - top))
+ self.assertLessEqual(right - left, room_w + 1e-6)
+ self.assertLessEqual(bottom - top, room_h + 1e-6)
+
+ def test_notch_span_picks_the_top_display_that_holds_the_notch(self):
+ side_by_side = {"0": Rect(0, 0, 2560, 1440), "1": Rect(2560, 0, 1512, 982)}
+ self.assertEqual(diagram.notch_span((3216, 3416), side_by_side), ("1", 656 / 1512, 856 / 1512))
+ below = {"0": Rect(2000, -1440, 2560, 1440), "1": Rect(0, 0, 1512, 982)}
+ self.assertIsNone(diagram.notch_span((656, 856), below))
+ self.assertIsNone(diagram.notch_span(None, side_by_side))
+ self.assertIsNone(diagram.notch_span((3216, 3416), {}))
+ self.assertIsNone(diagram.notch_span((2500, 2700), side_by_side))
+
+ def test_notch_dash_sits_over_the_notch_on_the_built_in_display(self):
+ span = ("1", 656 / 1512, 856 / 1512)
+ tiles = {OWN: {"x": 0, "y": 0, "w": 226, "h": 80, "displays": DISPLAYS},
+ DESK: {"x": 60, "y": 80, "w": 113, "h": 70}}
+ canvas = canvas_for(tiles, desk={"notch_way": True}, own={"notch_span": span})
+ frame, scale = canvas._map()[0][OWN], canvas._map()[1]
+ screen = next(screen for screen in core_ways._display_frames(tiles[OWN]) if screen["display"] == "1")
+ left = frame[0] + screen["x"] * scale
+ box = Quartz.CGPathGetBoundingBox(canvas.mark_layers[(DESK, "notch")].path())
+ self.assertAlmostEqual(box.origin.x, left + span[1] * screen["w"] * scale, places=6)
+ self.assertAlmostEqual(box.origin.x + box.size.width, left + span[2] * screen["w"] * scale, places=6)
+ self.assertAlmostEqual(box.origin.y, frame[1] + screen["y"] * scale - 2)
+ self.assertAlmostEqual(box.size.height, 4)
+ self.assertGreater(box.origin.x, frame[0] + frame[2] / 2)
+
+ def test_notch_dash_falls_back_to_the_tile_top_centre(self):
+ for tiles, own in ((ROW, {"notch_span": ("1", 0.4, 0.6)}),
+ ({OWN: {"x": 0, "y": 0, "w": 226, "h": 80, "displays": DISPLAYS},
+ DESK: {"x": 60, "y": 80, "w": 113, "h": 70}}, {})):
+ with self.subTest(displays=bool(tiles[OWN].get("displays"))):
+ canvas = canvas_for(tiles, desk={"notch_way": True}, own=own)
+ x, y, width, _height = canvas._map()[0][OWN]
+ box = Quartz.CGPathGetBoundingBox(canvas.mark_layers[(DESK, "notch")].path())
+ self.assertEqual((box.origin.x, box.origin.y, box.size.width, box.size.height),
+ (x + width / 2 - 7, y - 2, 14, 4))
+
+ def external(self, canvas):
+ return next(screen for screen in core_ways._display_frames(WITH_DISPLAYS[OWN]) if screen["display"] == "0")
+
+ def test_with_displays_the_seam_runs_only_where_a_display_edge_touches_the_machine(self):
+ for desk in ({}, {"lit_thirds": ["start", "middle"], "picked_thirds": ["start", "middle"]}):
+ with self.subTest(desk=desk):
+ canvas = canvas_for(WITH_DISPLAYS, desk=desk)
+ frame, scale = canvas._map()[0][OWN], canvas._map()[1]
+ external = self.external(canvas)
+ bottom = frame[1] + (external["y"] + external["h"]) * scale
+ drawn = self.pieces(canvas) + self.pieces(canvas, "track")
+ self.assertTrue(drawn)
+ for segment in drawn:
+ self.assertAlmostEqual(segment["start"][1], bottom)
+ self.assertAlmostEqual(segment["end"][1], bottom)
+ self.assertGreaterEqual(segment["start"][0] - segment["width"] / 2, frame[0] + 60 * scale)
+ self.assertLessEqual(segment["end"][0] + segment["width"] / 2,
+ frame[0] + (external["x"] + external["w"]) * scale)
+
+ def test_with_displays_the_breaks_are_at_that_displays_thirds_inside_the_contact(self):
+ canvas = canvas_for(WITH_DISPLAYS)
+ frame, scale = canvas._map()[0][OWN], canvas._map()[1]
+ external = self.external(canvas)
+ self.assert_breaks(canvas, [frame[0] + (external["x"] + 2 * external["w"] / 3) * scale])
+ thirds = [(segment[1], segment[3][0], segment[4][0]) for segment in canvas._third_segments(canvas._map()[0])]
+ self.assertEqual([third for third, _start, _end in thirds], ["middle", "end"])
+ self.assertAlmostEqual(thirds[0][1], frame[0] + 60 * scale)
+ self.assertAlmostEqual(thirds[1][2], frame[0] + (external["x"] + external["w"]) * scale)
+ point = AppKit.NSMakePoint((thirds[1][1] + thirds[1][2]) / 2, frame[1] + 80 * scale + 4)
+ self.assertEqual(canvas._third_hit(point), (DESK, "end"))
+ self.assertEqual(canvas.view_stringForToolTip_point_userData_(canvas, 0, point, None),
+ "Right third: click to turn it off")
+
+ def test_titles_draw_above_their_tiles_displays(self):
+ tiles = {**WITH_DISPLAYS, DESK: {**WITH_DISPLAYS[DESK], "displays": {"9": {"x": 0, "y": 0, "w": 1920, "h": 1080}}}}
+ canvas = canvas_for(tiles)
+ root = list(canvas.layer().sublayers())
+ for key in (OWN, DESK):
+ with self.subTest(peer=LABELS[key]):
+ title = canvas.label_for_tile[key]
+ self.assertFalse(title.isHidden())
+ for layer in canvas.display_layers[key]:
+ self.assertGreater(root.index(title), root.index(layer))
+ self.assertGreater(title.zPosition(), layer.zPosition())
+ bounds = canvas.bounds()
+ rep = canvas.bitmapImageRepForCachingDisplayInRect_(bounds)
+ canvas.cacheDisplayInRect_toBitmapImageRep_(bounds, rep)
+ ratio = rep.pixelsWide() / bounds.size.width
+ for key in (OWN, DESK):
+ x, y, width, height = rect_of(canvas.label_for_tile[key])
+ bright = 0
+ for py in range(round(y * ratio), round((y + height) * ratio)):
+ for px in range(round(x * ratio), round((x + width) * ratio)):
+ colour = rep.colorAtX_y_(px, py).colorUsingColorSpace_(AppKit.NSColorSpace.deviceRGBColorSpace())
+ bright += colour.redComponent() > 0.5
+ with self.subTest(peer=LABELS[key]):
+ self.assertGreater(bright, 20)
+
+ def test_a_corner_where_two_displays_meet_beside_a_side_contact_is_not_drawn(self):
+ for tiles in DISPLAY_CORNERS:
+ for selected in (DESK, OWN):
+ with self.subTest(tiles=sorted(tiles[DESK]), selected=selected == DESK):
+ canvas = canvas_for(tiles)
+ canvas.selected = selected
+ canvas._draw(False)
+ box = Quartz.CGPathGetBoundingBox(canvas.contact_layers[(OWN, DESK, "signal")].path())
+ self.assertEqual(box.size.height, 0)
+ self.assertEqual({segment["side"] for segment in canvas.seam_segments}, {"bottom"})
+
+ def test_the_join_between_a_machines_displays_is_not_a_break(self):
+ tiles = {OWN: {"x": 0, "y": 0, "w": 160, "h": 90},
+ DESK: {"x": 0, "y": 90, "w": 160, "h": 90,
+ "displays": {"a": {"x": 0, "y": 0, "w": 1920, "h": 1080},
+ "b": {"x": 1920, "y": 0, "w": 1920, "h": 1080}}}}
+ for lit in (["start"], PARTS):
+ with self.subTest(lit=lit):
+ canvas = canvas_for(tiles, desk={"picked_thirds": lit, "lit_thirds": lit})
+ x, _y, width, _height = canvas._map()[0][OWN]
+ self.assert_breaks(canvas, [x + width / 3, x + 2 * width / 3])
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/mac_app/tests/test_notch_style_previews.py b/mac_app/tests/test_notch_style_previews.py
new file mode 100644
index 0000000..dd4a1d1
--- /dev/null
+++ b/mac_app/tests/test_notch_style_previews.py
@@ -0,0 +1,125 @@
+import logging
+import sys
+import types
+import unittest
+from pathlib import Path
+from unittest import mock
+
+import AppKit
+import Quartz
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+sys.path.insert(0, str(Path(__file__).resolve().parents[2]))
+
+import notch_beam
+import notch_island
+import previews
+
+AppKit.NSApplication.sharedApplication()
+
+
+def controller(after_ms=1200):
+ return types.SimpleNamespace(cfg=types.SimpleNamespace(crossing={
+ "notch_after_ms": after_ms,
+ "glow_colour": "signal",
+ }))
+
+
+def render(view, at):
+ width, height = 300, 150
+ rep = AppKit.NSBitmapImageRep.alloc().initWithBitmapDataPlanes_pixelsWide_pixelsHigh_bitsPerSample_samplesPerPixel_hasAlpha_isPlanar_colorSpaceName_bytesPerRow_bitsPerPixel_(
+ None, width, height, 8, 4, True, False, AppKit.NSCalibratedRGBColorSpace, width * 4, 32
+ )
+ context = AppKit.NSGraphicsContext.graphicsContextWithBitmapImageRep_(rep)
+ view.paint_frame(context.CGContext(), width, height, at, False)
+ return bytes(rep.bitmapData())
+
+
+def changed_bounds(first, second, width=300):
+ changed = [index // 4 for index in range(0, len(first), 4)
+ if first[index:index + 4] != second[index:index + 4]]
+ if not changed:
+ return None
+ xs = [pixel % width for pixel in changed]
+ ys = [pixel // width for pixel in changed]
+ return min(xs), min(ys), max(xs), max(ys)
+
+
+class HostedNotchCrossingPreviewTest(unittest.TestCase):
+ def preview(self, base):
+ return previews.notch_crossing_still(base, lambda: "signal", logging.getLogger("preview-test"),
+ controller(), (185.0, 32.0))
+
+ def test_outline_and_island_host_their_real_layer_trees_at_the_crossing_seam(self):
+ for base, expected in ((notch_beam.NotchBeam, notch_beam.NotchBeam),
+ (notch_island.NotchIsland, notch_island.NotchIsland)):
+ with self.subTest(style=expected.__name__):
+ view = self.preview(base)
+ self.assertIsInstance(view.renderer, expected)
+ self.assertIsInstance(view.stage, Quartz.CALayer)
+ self.assertAlmostEqual(view.still_at, 1.9)
+ self.assertGreater(view.stage.bounds().size.width, view.notch[0])
+
+ def test_reduced_motion_and_hover_intent_hold_the_same_canonical_still(self):
+ view = self.preview(notch_island.NotchIsland)
+ view.playing_since = 10.1
+ with mock.patch.object(previews.time, "monotonic", return_value=10.0), \
+ mock.patch.object(previews.effects_overlay, "reduce_motion", return_value=False):
+ self.assertEqual(view._time(), view.still_at)
+ with mock.patch.object(previews.time, "monotonic", return_value=10.8), \
+ mock.patch.object(previews.effects_overlay, "reduce_motion", return_value=True):
+ self.assertEqual(view._time(), view.still_at)
+ with mock.patch.object(previews.time, "monotonic", return_value=10.8), \
+ mock.patch.object(previews.effects_overlay, "reduce_motion", return_value=False):
+ self.assertAlmostEqual(view._time(), 0.7)
+
+ def test_real_outline_and_island_layer_trees_render_distinct_mid_crossing_bitmaps(self):
+ outline = self.preview(notch_beam.NotchBeam)
+ island = self.preview(notch_island.NotchIsland)
+ outline_image = render(outline, outline.still_at)
+ island_image = render(island, island.still_at)
+ self.assertGreater(len(outline_image), 100)
+ self.assertGreater(len(island_image), 100)
+ self.assertNotEqual(outline_image, island_image)
+
+ def test_canonical_bitmap_is_independent_of_the_previous_frame(self):
+ for base in (notch_beam.NotchBeam, notch_island.NotchIsland):
+ with self.subTest(style=base.__name__):
+ view = self.preview(base)
+ still = render(view, view.still_at)
+ render(view, 3.0)
+ self.assertEqual(render(view, view.still_at), still)
+
+ def test_layer_pixels_stay_around_the_notch_seam(self):
+ view = self.preview(notch_beam.NotchBeam)
+ view.stage.setHidden_(True)
+ without_marks = render(view, view.still_at)
+ view.stage.setHidden_(False)
+ with_marks = render(view, view.still_at)
+ bounds = changed_bounds(without_marks, with_marks)
+ self.assertIsNotNone(bounds)
+ left, top, right, bottom = bounds
+ self.assertGreaterEqual(left, 90)
+ self.assertLessEqual(right, 210)
+ self.assertGreaterEqual(top, 55)
+ self.assertLessEqual(bottom, 115)
+
+ def test_renderer_frame_uses_the_selected_notch_duration(self):
+ short = self.preview(notch_beam.NotchBeam)
+ long = previews.notch_crossing_still(notch_beam.NotchBeam, lambda: "signal",
+ logging.getLogger("preview-test"), controller(3000), (185.0, 32.0))
+ self.assertEqual(short.after(), 1.2)
+ self.assertEqual(long.after(), 3.0)
+ with mock.patch.object(notch_beam, "lap_finish", wraps=notch_beam.lap_finish) as finish:
+ crossed = (notch_beam.LAP * 0.3 + notch_beam.LAP
+ * (previews.effects._P_CROSS - previews.effects._P_PUSH)
+ / notch_beam.turn_seconds(1.0)) % notch_beam.LAP
+ short._set_renderer_frame(2.5, "signal", True)
+ finish.assert_called_with(crossed, 1.2)
+ finish.reset_mock()
+ long._set_renderer_frame(2.5, "signal", True)
+ finish.assert_called_with(crossed, 3.0)
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/mac_app/tests/test_notices_mac.py b/mac_app/tests/test_notices_mac.py
index 3d00d83..64b19b0 100644
--- a/mac_app/tests/test_notices_mac.py
+++ b/mac_app/tests/test_notices_mac.py
@@ -16,6 +16,7 @@ import rumps
import notices
from kvm_bridge_app import TrayApp, _set_tray_title, _tray_item
from core import locale
+from core import peerlist
class FakeContent:
@@ -157,12 +158,15 @@ class NoticesTest(unittest.TestCase):
class _FakeTrayApp:
_notify_user_main = TrayApp._notify_user_main
+ _drive_status = TrayApp._drive_status
def __init__(self):
self.logger = logging.getLogger("test-notices-tray")
self.controller = mock.Mock()
self.controller.cfg.hide_addresses = True
self.notices = mock.Mock()
+ self._refusal_notices = peerlist.RefusalThrottle()
+ self._refresh_tray_state = mock.Mock()
class TrayNoticeTest(unittest.TestCase):
@@ -182,6 +186,28 @@ class TrayNoticeTest(unittest.TestCase):
self.assertEqual(title, "Can't cross to Bee")
self.assertNotIn("192.0.2.30", body)
+ def test_repeated_refusals_update_the_tray_but_post_one_notice(self):
+ fake = _FakeTrayApp()
+ with mock.patch.object(rumps, "notification") as old, mock.patch("AppKit.NSBeep"):
+ fake._notify_user_main("Beamer", "Can't cross to Bee: it is driving Sea.")
+ fake._notify_user_main("Beamer", "Can't cross to Bee: it is driving Sea.")
+ old.assert_not_called()
+ self.assertEqual(fake.notices.post.call_count, 1)
+ self.assertEqual(fake._refresh_tray_state.call_count, 2)
+
+ def test_tray_state_names_the_current_input_owner(self):
+ fake = _FakeTrayApp()
+ fake.controller.redirecting = True
+ fake.controller.on_label = "Sea"
+ fake.controller.driver = None
+ self.assertEqual(fake._drive_status(), "Driving Sea")
+ fake.controller.redirecting = False
+ fake.controller.driver = object()
+ fake.controller.driver_label = "Bee"
+ self.assertEqual(fake._drive_status(), "Driven by Bee")
+ fake.controller.driver = None
+ self.assertEqual(fake._drive_status(), "Idle")
+
if __name__ == "__main__":
unittest.main()
diff --git a/mac_app/tests/test_pages.py b/mac_app/tests/test_pages.py
index a93ba0c..a5a5914 100644
--- a/mac_app/tests/test_pages.py
+++ b/mac_app/tests/test_pages.py
@@ -154,11 +154,12 @@ class CrossingPageRulesTests(unittest.TestCase):
def test_rows_follow_the_ways(self):
self.assertEqual(pages.crossing_rows(["shortcut"]),
- {"edge": True, "parts": False, "corner": False, "dragging": False,
+ {"edge": True, "parts": False, "corner": True, "dragging": True,
"resistance": False, "shortcut": True})
rows = pages.crossing_rows(["part"])
self.assertTrue(rows["edge"] and rows["parts"] and rows["resistance"])
- self.assertFalse(rows["shortcut"] or rows["corner"])
+ self.assertFalse(rows["shortcut"])
+ self.assertTrue(rows["corner"] and rows["dragging"])
self.assertTrue(pages.crossing_rows(["corner"])["edge"])
self.assertTrue(pages.crossing_rows(["notch"])["resistance"])
# Where the PC sits shows whatever the ways: the PC's edge facing this Mac always leads here.
diff --git a/mac_app/tests/test_pairing_pixels.py b/mac_app/tests/test_pairing_pixels.py
index 02f426b..d655959 100644
--- a/mac_app/tests/test_pairing_pixels.py
+++ b/mac_app/tests/test_pairing_pixels.py
@@ -96,7 +96,8 @@ class PairingPixelsTests(unittest.TestCase):
self.window.setReleasedWhenClosed_(False)
self.window.setAppearance_(theme.appearance_named(True))
owner = SimpleNamespace(window=self.window, _shown=lambda text: text)
- controller = SimpleNamespace(cfg=SimpleNamespace(hide_addresses=False))
+ controller = SimpleNamespace(cfg=SimpleNamespace(hide_addresses=False),
+ book=SimpleNamespace(peers=lambda: []))
self.panel = machines_panel.MachinesPanel(controller, mock.Mock(), mock.Mock(), owner)
self.panel.rows = lambda: []
self.panel.service = SimpleNamespace(code=None, machines=lambda: [], seconds_left=60, outcome=None,
diff --git a/mac_app/tests/test_part_edge_thirds.py b/mac_app/tests/test_part_edge_thirds.py
new file mode 100644
index 0000000..1d268b2
--- /dev/null
+++ b/mac_app/tests/test_part_edge_thirds.py
@@ -0,0 +1,239 @@
+"""Map third hit bands and ledger segments share the saved third choice."""
+
+import copy
+import itertools
+import sys
+from pathlib import Path
+from unittest import mock
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+import AppKit
+import Quartz
+
+AppKit.NSApplication.sharedApplication()
+
+import diagram
+import theme
+from core import return_edge, ways
+from test_crossing_page_machines import BEE, SEA, Page, press, token
+
+
+class PartEdgeThirds(Page):
+ def layout(self, side="right", scoped=False, second=False):
+ peers = [(BEE, token(100), "Bee", {"side": side})]
+ zones = [{"peer": BEE, "kind": "edge"}]
+ if scoped:
+ zones.append({"peer": BEE, "kind": "edge", "display": "main", "side": side,
+ "target_side": return_edge.OPPOSITE[side]})
+ if second:
+ peers.append((SEA, token(150), "Sea", {"side": "left"}))
+ zones.append({"peer": SEA, "kind": "edge"})
+ window = self.build(peers, zones)
+ own = self.store.current()["machine_id"]
+ x, y = {"right": (160, 0), "left": (-160, 0), "top": (0, -90), "bottom": (0, 90)}[side]
+ tiles = {own: {"x": 0, "y": 0, "w": 160, "h": 90},
+ BEE: {"x": x, "y": y, "w": 160, "h": 90}}
+ if scoped:
+ for tile in tiles.values():
+ tile["displays"] = {"main": {"x": 0, "y": 0, "w": 160, "h": 90}}
+ if second:
+ tiles[SEA] = {"x": -160, "y": 0, "w": 160, "h": 90}
+ window._atlas_layout_changed(tiles, BEE, snap=False)
+ self.pick(BEE)
+ canvas = window.atlas_canvas
+ canvas.setFrame_(((0, 0), (480, canvas.HEIGHT)))
+ canvas._draw(False)
+ return window
+
+ def row(self):
+ return self.window.crossing_ledger.rows[BEE]
+
+ def picked(self):
+ return [part for part, button in self.row().edge_glyph.hits.items()
+ if button.accessibilityValue() == "on"]
+
+ def pick_thirds(self, picked):
+ self.whole_edge()
+ for part in ways.PARTS:
+ if part not in picked:
+ press(self.row().edge_glyph.hits[part])
+
+ def whole_edge(self):
+ if self.picked():
+ press(self.row().edge_title)
+ press(self.row().edge_title)
+
+ def third_point(self, third, offset=0, peer=BEE):
+ canvas = self.window.atlas_canvas
+ own = canvas.tiles[canvas.own_id]
+ contact = ways._rect_contact(own, canvas.tiles[peer])
+ frames, scale = canvas._map()
+ frame = frames[canvas.own_id]
+ _third, side, low, high = next(stretch for stretch in ways.third_stretches(contact, own)
+ if stretch[0] == third)
+ if side in ("left", "right"):
+ return AppKit.NSMakePoint(frame[0] + (frame[2] if side == "right" else 0) + offset,
+ frame[1] + ((low + high) / 2 - own["y"]) * scale)
+ return AppKit.NSMakePoint(frame[0] + ((low + high) / 2 - own["x"]) * scale,
+ frame[1] + (frame[3] if side == "bottom" else 0) + offset)
+
+ def click_third(self, third, offset=0):
+ canvas = self.window.atlas_canvas
+ point = self.third_point(third, offset)
+ event = mock.Mock()
+ event.locationInWindow.return_value = point
+ event.clickCount.return_value = 1
+ event.modifierFlags.return_value = 0
+ with mock.patch.object(canvas, "window"), \
+ mock.patch.object(canvas, "convertPoint_fromView_", return_value=point), \
+ mock.patch.object(diagram.AppKit, "NSCursor"):
+ canvas.mouseDown_(event)
+ self.assertIsNone(canvas.dragging)
+ canvas.mouseUp_(event)
+
+ def test_all_seven_choices_round_trip_ledger_saved_intent_and_map(self):
+ window = self.layout()
+ row = self.row()
+ buttons = dict(row.edge_glyph.hits)
+ for count in (1, 2, 3):
+ for picked in itertools.combinations(ways.PARTS, count):
+ with self.subTest(picked=picked):
+ self.pick_thirds(picked)
+ saved = self.ways_of(BEE)
+ self.assertEqual(ways.picked_thirds(saved["methods"], saved["parts"]), list(picked))
+ window._load_ways()
+ window._reflect()
+ window.atlas_canvas._draw(False)
+ self.assertEqual(self.picked(), list(picked))
+ self.assertEqual(window.atlas_canvas.states[BEE]["picked_thirds"], list(picked))
+ self.assertIs(self.row(), row)
+ for part, button in buttons.items():
+ self.assertIs(row.edge_glyph.hits[part], button)
+
+ def test_map_clicks_each_third_on_each_side_and_ledger_follows(self):
+ for side in ways.EDGES:
+ self.layout(side)
+ for third in ways.PARTS:
+ with self.subTest(side=side, third=third):
+ self.whole_edge()
+ self.click_third(third, offset=4)
+ self.assertEqual(self.picked(), [part for part in ways.PARTS if part != third])
+ self.click_third(third, offset=-4)
+ self.assertEqual(self.picked(), list(ways.PARTS))
+
+ def test_last_third_off_then_map_reopens_only_the_clicked_third(self):
+ self.layout()
+ self.pick_thirds(["start"])
+ self.click_third("start")
+ self.assertEqual(self.picked(), [])
+ self.assertFalse(set(self.ways_of(BEE)["methods"]) & {"edge", "part"})
+ self.click_third("end")
+ self.assertEqual(self.picked(), ["end"])
+ self.assertEqual(self.ways_of(BEE)["parts"], ["end"])
+ self.whole_edge()
+ self.assertEqual(self.picked(), list(ways.PARTS))
+
+ def test_mouse_down_and_drag_wait_for_mouse_up_and_never_move_tiles(self):
+ window = self.layout()
+ canvas = window.atlas_canvas
+ before = copy.deepcopy(canvas.tiles)
+ point = self.third_point("middle")
+ event = mock.Mock()
+ event.locationInWindow.return_value = point
+ with mock.patch.object(canvas, "window"), \
+ mock.patch.object(canvas, "convertPoint_fromView_", return_value=point):
+ canvas.mouseDown_(event)
+ canvas.mouseDragged_(event)
+ self.assertIsNone(canvas.dragging)
+ self.assertEqual(canvas.tiles, before)
+ self.assertEqual(self.picked(), list(ways.PARTS))
+ canvas.mouseUp_(event)
+ self.assertEqual(self.picked(), ["start", "end"])
+ self.assertEqual(canvas.tiles, before)
+
+ def test_releasing_in_another_third_cancels(self):
+ self.layout()
+ canvas = self.window.atlas_canvas
+ with mock.patch.object(canvas, "window"), \
+ mock.patch.object(canvas, "convertPoint_fromView_", side_effect=[
+ self.third_point("start"), self.third_point("end")]):
+ canvas.mouseDown_(mock.Mock())
+ canvas.mouseUp_(mock.Mock())
+ self.assertEqual(self.picked(), list(ways.PARTS))
+ self.assertIsNone(canvas.third_pressed)
+
+ def test_tooltips_cursor_and_five_pixel_band(self):
+ self.layout()
+ canvas = self.window.atlas_canvas
+ self.assertEqual(canvas._third_tooltip(BEE, "start"), "Top third: click to turn it off")
+ self.pick_thirds(["start"])
+ self.assertEqual(canvas._third_tooltip(BEE, "start"), "Top third: click to turn it off")
+ self.assertEqual(canvas._third_tooltip(BEE, "end"), "Bottom third: click to turn it on")
+ point = self.third_point("end", 5)
+ self.assertEqual(canvas._third_hit(point), (BEE, "end"))
+ self.assertIsNone(canvas._third_hit(self.third_point("end", 5.1)))
+ with mock.patch.object(canvas, "convertPoint_fromView_", return_value=point), \
+ mock.patch.object(diagram.AppKit, "NSCursor") as cursor:
+ canvas.mouseMoved_(mock.Mock())
+ cursor.pointingHandCursor.return_value.set.assert_called_once()
+
+ def test_selected_tracks_breaks_and_other_peers_seam(self):
+ window = self.layout(second=True)
+ self.pick_thirds(["middle"])
+ canvas = window.atlas_canvas
+ canvas._draw(False)
+ self.assertEqual(set(canvas.third_layers), {(BEE, "start", "track"), (BEE, "end", "track")})
+ track = canvas.third_layers[(BEE, "start", "track")]
+ self.assertEqual(track.lineWidth(), 2)
+ self.assertAlmostEqual(track.opacity(), .3)
+ self.assertEqual(track.lineCap(), Quartz.kCALineCapRound)
+ self.assertTrue(Quartz.CGColorEqualToColor(track.strokeColor(), theme.cg("signal")))
+ x, y, _width, height = canvas._map()[0][canvas.own_id]
+ seam = [segment for segment in canvas.seam_segments if segment["peer"] == BEE]
+ self.assertEqual([segment["kind"] for segment in sorted(seam, key=lambda s: s["start"][1])],
+ ["track", "seam", "track"])
+ for segment in seam:
+ self.assertEqual(segment["start"][0], segment["end"][0])
+ ends = sorted(seam, key=lambda s: s["start"][1])
+ for before, after, point in zip(ends, ends[1:], (y + height / 3, y + 2 * height / 3)):
+ seen_end, seen_start = before["end"][1] + before["width"] / 2, after["start"][1] - after["width"] / 2
+ self.assertAlmostEqual((seen_end + seen_start) / 2, point)
+ self.assertAlmostEqual(seen_start - seen_end, diagram.THIRD_GAP)
+ self.assertIn((canvas.own_id, SEA, "signal"), canvas.contact_layers)
+ self.assertIsNone(canvas._third_hit(self.third_point("start", peer=SEA)))
+ self.pick(SEA)
+ canvas._draw(False)
+ self.assertFalse(any(key[0] == BEE for key in canvas.third_layers))
+
+ def test_picked_third_with_only_a_sliver_of_contact_is_not_lit(self):
+ window = self.layout()
+ window.windows_input.server.caps_of.return_value = ["layout"]
+ self.pick_thirds(["start", "middle"])
+ tiles = copy.deepcopy(self.store.current()["layout"])
+ tiles[BEE].update(y=25, h=40)
+ settings = self.store.current()
+ settings["layout"] = tiles
+ self.store.save_settings(settings)
+ window._show_arrangement()
+ canvas = window.atlas_canvas
+ canvas._draw(False)
+ self.assertEqual(canvas.states[BEE]["picked_thirds"], ["start", "middle"])
+ self.assertEqual(canvas.states[BEE]["lit_thirds"], ["middle"])
+ self.assertIn((BEE, "start", "track"), canvas.third_layers)
+
+ def test_edge_off_survives_layout_compile_and_text_restores_whole(self):
+ for scoped in (False, True):
+ with self.subTest(scoped=scoped):
+ window = self.layout(scoped=scoped)
+ self.pick_thirds(["start", "end"])
+ press(self.row().edge_title)
+ window._atlas_layout_changed(copy.deepcopy(self.store.current()["layout"]), BEE, snap=False)
+ self.assertFalse(set(self.ways_of(BEE)["methods"]) & {"edge", "part"})
+ self.assertEqual(self.picked(), [])
+ window.atlas_canvas._draw(False)
+ self.assertFalse(any(key[-1] == "track" for key in window.atlas_canvas.third_layers))
+ press(self.row().edge_title)
+ self.assertEqual(self.picked(), list(ways.PARTS))
+ self.assertEqual(self.ways_of(BEE)["methods"], ["edge"])
diff --git a/mac_app/tests/test_phone_ui.py b/mac_app/tests/test_phone_ui.py
index 0cb92c5..c695d30 100644
--- a/mac_app/tests/test_phone_ui.py
+++ b/mac_app/tests/test_phone_ui.py
@@ -13,6 +13,7 @@ sys.path.insert(0, str(Path(__file__).resolve().parent))
import kvm_bridge_app
import machines
import pages
+import ledger
from machines_panel import MachinesPanel
from core import protocol
from windows_input import WindowsInput
@@ -51,16 +52,19 @@ class PhoneUiTests(unittest.TestCase):
self.assertFalse(inbound.send_settings({"on": True}))
inbound.server.send.assert_not_called()
- def test_crossing_diagram_and_match_caps_exclude_phone(self):
+ def test_crossing_ledger_and_match_caps_exclude_phone(self):
window = SimpleNamespace(settings_store=SimpleNamespace(current=lambda: {"peers": self.peers, "zones": []}),
- edge_select=SimpleNamespace(value="right"), part_boxes={},
- corner_select=SimpleNamespace(value="top_right"), chosen_peer=self.desktop["id"],
- _shown=lambda text: text,
controller=SimpleNamespace(book=self.book, _peers_up={}), windows_input=mock.Mock())
window.windows_input.server.links.return_value = [protocol.read_id(self.phone["id"])]
window.windows_input.server.caps_of.return_value = ["settings", "design_sync"]
- found = kvm_bridge_app.ControlWindow._diagram_machines(window, ["edge"])
- self.assertEqual([m["key"] for m in found], [self.desktop["id"]])
+ rows = SimpleNamespace(rows={}, addSubview_=mock.Mock(), reflow=mock.Mock())
+ row = mock.Mock()
+ row.setup.return_value = row
+ with mock.patch.object(ledger, "Row") as constructor:
+ constructor.alloc.return_value.init.return_value = row
+ ledger.Ledger.refresh(rows, window.settings_store.current(), self.desktop["id"])
+ self.assertEqual(rows.order, [self.desktop["id"]])
+ row.refresh.assert_called_once_with(window.settings_store.current(), self.desktop, True)
self.assertEqual(kvm_bridge_app.ControlWindow._design_peer_caps(window), {})
def test_bulk_send_toggle_excludes_phone(self):
@@ -73,15 +77,17 @@ class PhoneUiTests(unittest.TestCase):
panel = SimpleNamespace(removing=None, wide=True, directions_open={row.token})
import widgets
in_use = widgets.Switch("In use")
+ left_out = widgets.label("Leave out")
disclosure = widgets.label("Directions")
remove = widgets.label("Remove")
- result = MachinesPanel._controls(panel, row, in_use, disclosure,
+ result = MachinesPanel._controls(panel, row, in_use, left_out, disclosure,
widgets.Switch("This Mac drives it"), widgets.Switch("It drives this Mac"), remove)
self.assertEqual(len(result.arrangedSubviews()), 1)
views = list(result.arrangedSubviews()[0].arrangedSubviews())
self.assertIn(in_use.view, views)
self.assertIn(remove, views)
self.assertNotIn(disclosure, views)
+ self.assertNotIn(left_out, views)
def test_phone_messages_cannot_set_same_or_match(self):
window = SimpleNamespace(controller=SimpleNamespace(book=self.book), _design_states={})
diff --git a/mac_app/tests/test_previews.py b/mac_app/tests/test_previews.py
index 1b43377..5e66842 100644
--- a/mac_app/tests/test_previews.py
+++ b/mac_app/tests/test_previews.py
@@ -9,6 +9,33 @@ import previews
class PreviewFrameTest(unittest.TestCase):
+ def test_page_clock_stays_stopped_until_a_tile_is_hovered(self):
+ import types
+
+ loop = previews.PreviewLoop(types.SimpleNamespace(cfg=types.SimpleNamespace(crossing={"notch_after_ms": 1200})),
+ host=object())
+ loop.start()
+ self.assertFalse(loop.clock.is_alive())
+
+ def test_effect_hover_holds_until_intent_then_starts_with_approach(self):
+ from types import SimpleNamespace
+ from unittest import mock
+
+ view = SimpleNamespace(playing_since=10.1)
+ with mock.patch.object(previews.time, "monotonic", return_value=10.0), \
+ mock.patch.object(previews.effects_overlay, "reduce_motion", return_value=False):
+ self.assertEqual(previews._played(view, 2.2), 2.2)
+ self.assertFalse(previews._live(view))
+ with mock.patch.object(previews.time, "monotonic", return_value=10.3), \
+ mock.patch.object(previews.effects_overlay, "reduce_motion", return_value=False):
+ self.assertAlmostEqual(previews._played(view, 2.2), 0.2)
+ self.assertAlmostEqual(previews._played(view, 2.2, switch=True), 2.4)
+ self.assertTrue(previews._live(view))
+ with mock.patch.object(previews.time, "monotonic", return_value=11.0), \
+ mock.patch.object(previews.effects_overlay, "reduce_motion", return_value=True):
+ self.assertEqual(previews._played(view, 2.2), 2.2)
+ self.assertFalse(previews._live(view))
+
def test_a_push_builds_goes_through_plays_and_rests(self):
self.assertEqual(previews.preview_frame(0.0, 1.2), (0.0, "push"))
self.assertLess(previews.preview_frame(0.5, 1.2)[0], previews.preview_frame(1.5, 1.2)[0])
@@ -60,6 +87,8 @@ class TileHoverTest(unittest.TestCase):
feed = mock.Mock(level=0.0)
renderer = mock.Mock(spec=["_draw", "_hide", "_tick", "timer"])
self.loop.add(feed, renderer, mock.Mock(), screen)
+ self.loop.clock.start = mock.Mock()
+ self.loop.clock.stop = mock.Mock()
self.loop.running = True
def tearDown(self):
@@ -83,6 +112,42 @@ class TileHoverTest(unittest.TestCase):
self.loop._tick()
self.assertEqual(self.playing(), [False, False])
+ def test_hover_starts_the_page_clock(self):
+ self.loop.hover(self.screens[1])
+ self.loop.clock.start.assert_called_once_with()
+
+ def test_hovered_offscreen_tile_does_not_keep_page_clock_running(self):
+ from unittest import mock
+ self.loop.hover(self.screens[0])
+ with mock.patch.object(previews, "on_screen", return_value=False):
+ self.loop._tick()
+ self.loop.clock.stop.assert_called()
+
+ def test_reduce_motion_suspends_renderer_and_page_clocks_then_resumes(self):
+ from unittest import mock
+ self.loop.hover(self.screens[0])
+ self.loop.hovered_at -= previews.HOVER_INTENT_S
+ self.loop._tick()
+ player = self.loop.players[0]
+ self.assertIsNotNone(player.started_at)
+ player.renderer.timer.stop = mock.Mock(wraps=player.renderer.timer.stop)
+ with mock.patch.object(previews.effects_overlay, 'reduce_motion', return_value=True):
+ self.loop.start()
+ self.assertIsNone(player.started_at)
+ player.renderer.timer.stop.assert_called_once_with()
+ self.loop.clock.stop.assert_called()
+ self.loop.clock.start.reset_mock()
+ self.loop.start()
+ self.loop.clock.start.assert_called_once_with()
+ self.loop._tick()
+ self.assertIsNotNone(player.started_at)
+
+ def test_hover_under_reduce_motion_leaves_the_page_clock_stopped(self):
+ from unittest import mock
+ with mock.patch.object(previews.effects_overlay, "reduce_motion", return_value=True):
+ self.loop.hover(self.screens[1])
+ self.loop.clock.start.assert_not_called()
+
def test_a_tile_plays_on_from_its_held_push(self):
self.loop.set_resting([self.screens[0]])
self.loop._tick()
diff --git a/mac_app/tests/test_same_on_both.py b/mac_app/tests/test_same_on_both.py
index 6b596fc..8c240c4 100644
--- a/mac_app/tests/test_same_on_both.py
+++ b/mac_app/tests/test_same_on_both.py
@@ -2,6 +2,7 @@
change here going out. Built as test_appearance builds it, never put on screen; the two links'
sends are recorded instead."""
+import copy
import json
import logging
import sys
@@ -35,11 +36,45 @@ def pc_message(on, set_at, by="", **values):
glow_style="beam", glow_colour="ocean", effect_length="long", shortcut_arrival=False,
shortcut_arrival_style="locator")
base.update(values)
- return settings_sync.message_data(on, set_at, base, by=by)
+ return settings_sync.message_data(on, set_at, base, by=by,
+ groups=settings_sync.ALL_GROUPS if on else [])
class SameOnBothTests(unittest.TestCase):
+ def test_idle_same_ticks_keep_one_native_follow_picker(self):
+ import gc
+ import objc
+ import weakref
+
+ owners = []
+ original = self.window.follow_select
+ for _ in range(200):
+ with objc.autorelease_pool():
+ self.window._show_same()
+ owners.append(weakref.ref(self.window.follow_select))
+ gc.collect()
+ self.assertIs(self.window.follow_select, original)
+ self.assertEqual(len({id(owner()) for owner in owners if owner() is not None}), 1)
+ self.assertEqual(len(self.window.follow_host.arrangedSubviews()), 1)
+
+ def test_follow_picker_recovers_when_a_peer_announces_design(self):
+ self.pair_sources(PEER)
+ self.window._design_peer_caps = lambda: {PEER: frozenset({"settings", "design_sync"})}
+ self.window._refresh_design_follow()
+ choice = self.window.follow_select
+ cell = next(cell for value, cell in choice.items if value == PEER)
+ self.assertFalse(cell.isEnabled())
+ self.window._design_states[PEER] = {"set_at": 100, "by": PEER,
+ "values": {"effect_length": "long"}}
+ self.window._refresh_design_follow()
+ self.assertIs(self.window.follow_select, choice)
+ self.assertTrue(cell.isEnabled())
+ self.assertEqual(cell.toolTip(), cell.title())
+
def setUp(self):
+ capture = mock.patch.object(WakingController, "start_input_capture")
+ capture.start()
+ self.addCleanup(capture.stop)
self.directory = tempfile.TemporaryDirectory()
self.addCleanup(self.directory.cleanup)
path = Path(self.directory.name) / "config.json"
@@ -68,10 +103,90 @@ class SameOnBothTests(unittest.TestCase):
"port": protocol.DEFAULT_PORT})
def test_off_by_default_with_each_page_its_own(self):
- self.assertFalse(self.window.same_switch.value)
+ self.assertFalse(self.window.same_checks["everything"].state())
+ self.assertEqual(set(self.window.same_checks), {"crossing", "design", "shortcut", "names", "everything"})
self.assertEqual(self.window.scope_labels["design"].text, pages.SCOPE["design"])
self.assertTrue(all(note.view.isHidden() for note in self.window.own_notes))
+ def test_everything_can_be_turned_off(self):
+ self.window._set_same_groups(settings_sync.ALL_GROUPS)
+ everything = self.window.same_checks["everything"]
+ everything.setState_(AppKit.NSControlStateValueOff)
+ self.window.sameGroupsChanged_(everything)
+
+ self.assertEqual(self.window.controller.cfg.same_groups, [])
+
+ def test_revert_restores_the_saved_values_and_announces_them(self):
+ self.pair_sources(PEER)
+ data = settings_sync.message_data(True, 100, {"resistance_px": 60}, by=PEER,
+ groups=["crossing"])
+ self.window.apply_same(data, peer=PEER)
+ self.assertTrue(settings_sync.snapshot_available(self.store.current().get("same_before_sync")))
+
+ self.window.revertSame_(None)
+
+ self.assertEqual(self.window.controller.cfg.crossing["resistance_px"], 120)
+ self.assertEqual(self.window.controller.cfg.same_groups, ["crossing"])
+ self.assertEqual(self.sent[-1]["crossing"]["resistance_px"], 120)
+
+ def test_revert_restores_shortcut_in_the_canonical_settings_field(self):
+ self.pair_sources(PEER)
+ data = settings_sync.message_data(True, 100, {"shortcut": False}, by=PEER,
+ groups=["shortcut"])
+ self.window.apply_same(data, peer=PEER)
+ self.assertFalse(self.store.current()["shortcut"])
+
+ self.window.revertSame_(None)
+
+ self.assertTrue(self.store.current()["shortcut"])
+
+ def test_revert_clears_a_first_remote_label_with_a_new_stamp(self):
+ self.pair_sources(PEER)
+ data = settings_sync.message_data(True, 100, by=PEER, groups=["names"], names={
+ PEER: {"label": "Named here", "set_at": 100, "by": PEER},
+ })
+ self.window.apply_same(data, peer=PEER)
+ entry = next(item for item in self.store.current()["peers"] if item["id"] == PEER)
+ self.assertEqual(entry["label"], "Named here")
+
+ self.window.revertSame_(None)
+
+ restored = next(item for item in self.store.current()["peers"] if item["id"] == PEER)
+ self.assertEqual(restored["label"], "")
+ self.assertGreater(restored["label_set_at"], 100)
+
+ def test_legacy_off_state_stays_off_when_announced_to_a_group_peer(self):
+ self.window.controller.cfg.same_groups = ["design"]
+ self.window.apply_same({"on": False, "set_at": 100, "by": PEER}, peer=None)
+
+ self.assertFalse(self.window.same_state()["on"])
+ self.assertEqual(self.window.same_state()["groups"], ["design"])
+
+ def test_revert_keeps_the_current_trigger_when_a_jump_chord_now_uses_it(self):
+ self.pair_sources(PEER)
+ raw = settings_store.config_to_raw(self.window.controller.cfg)
+ raw["trigger_key"] = "alt_r"
+ self.window.controller.apply_settings(self.store.save(raw))
+ original_groups = list(self.window.controller.cfg.same_groups)
+ data = settings_sync.message_data(True, 100, {"trigger_key": "f13"}, by=PEER,
+ groups=["shortcut"])
+ self.window.apply_same(data, peer=PEER)
+ settings = self.store.current()
+ settings["peers"][0]["jump_key"] = "alt+cmd+3"
+ self.store.save_settings(settings)
+
+ self.window.revertSame_(None)
+
+ self.assertEqual(self.window.controller.cfg.trigger_key, "f13")
+ self.assertEqual(self.window.controller.cfg.same_groups, ["shortcut"])
+
+ def test_older_settings_peer_without_layout_capability_shows_group_note(self):
+ self.window._design_peer_caps = lambda: {PEER: {"settings"}}
+
+ self.window._show_same()
+
+ self.assertFalse(self.window.same_old_note.view.isHidden())
+
def test_full_screen_hold_switch_names_this_macs_edges(self):
self.assertEqual(self.window.hold_box.words.text, "Hold this Mac's edges while an app on it is full screen")
def test_this_machines_design_state_is_sent_even_when_same_is_off(self):
@@ -147,6 +262,7 @@ class SameOnBothTests(unittest.TestCase):
self.pair_sources(HIGH)
raw = settings_store.config_to_raw(self.window.controller.cfg)
raw["same_on_both"] = True
+ raw["same_groups"] = list(settings_sync.ALL_GROUPS)
raw["same_set_at"] = 10
raw["same_by"] = PEER
raw["design_set_at"] = 20
@@ -171,6 +287,7 @@ class SameOnBothTests(unittest.TestCase):
self.pair_sources(PEER, HIGH)
raw = settings_store.config_to_raw(self.window.controller.cfg)
raw["same_on_both"] = True
+ raw["same_groups"] = list(settings_sync.ALL_GROUPS)
raw["same_set_at"] = 10
raw["same_by"] = HIGH
raw["design_follow_peer"] = PEER
@@ -191,7 +308,8 @@ class SameOnBothTests(unittest.TestCase):
def test_same_on_all_machines_takes_precedence_without_clearing_following(self):
self.pair_sources(PEER)
raw = settings_store.config_to_raw(self.window.controller.cfg)
- raw.update(design_follow_peer=PEER, same_on_both=True, same_set_at=100)
+ raw.update(design_follow_peer=PEER, same_on_both=True, same_set_at=100,
+ same_groups=list(settings_sync.ALL_GROUPS))
self.window.controller.apply_settings(self.store.save(raw))
received = settings_sync.message_data(
True, 101, settings_sync.mac_values(raw), by=PEER,
@@ -207,7 +325,8 @@ class SameOnBothTests(unittest.TestCase):
self.pair_sources(PEER)
raw = settings_store.config_to_raw(self.window.controller.cfg)
raw["design_follow_peer"] = PEER
- raw["crossing"].update(crossing)
+ # A preset set alone would lose to the held slider value when the store resolves them.
+ raw["crossing"].update(settings_sync._with_continuous(crossing))
self.window.controller.apply_settings(self.store.save(raw))
self.window._load_shared(raw)
self.window._refresh_design_follow()
@@ -228,9 +347,8 @@ class SameOnBothTests(unittest.TestCase):
def test_a_click_on_a_locked_control_changes_nothing_and_keeps_following(self):
self.follow(effect_length="long")
self.sent.clear()
- short = next(cell for value, cell, _words in self.window.length_select.cells if value == "short")
-
- short.press()
+ slider = self.window.length_select.slider
+ slider.keyDown_(mock.Mock(keyCode=lambda: 124))
self.window.landing_box.view.press()
self.assertEqual(self.window.length_select.value, "long")
@@ -279,6 +397,8 @@ class SameOnBothTests(unittest.TestCase):
self.assertEqual(self.window.follow_note.text, cell.toolTip())
def test_the_pcs_settings_arrive_and_this_macs_own_stay(self):
+ local_ways = {peer["id"]: (copy.deepcopy(peer.get("ways")), peer.get("jump_key"))
+ for peer in self.store.current()["peers"]}
self.window.apply_same(pc_message(True, 100))
cfg = self.window.controller.cfg
self.assertTrue(cfg.same_on_both)
@@ -288,9 +408,9 @@ class SameOnBothTests(unittest.TestCase):
self.assertEqual(self.store.load().crossing["glow_colour"], "ocean")
self.assertEqual(self.window.glow_style_select.value, "beam")
self.assertEqual(self.window.resistance_ruler.value, 60)
- self.assertTrue(self.window.same_switch.value)
- self.assertEqual(self.window.scope_labels["crossing"].text,
- "Resistance, drag protection and Shortcut stay in step. Ways and jump keys below are local; each side is shared with its paired machine.")
+ self.assertTrue(self.window.same_checks["crossing"].state())
+ self.assertEqual({peer["id"]: (peer.get("ways"), peer.get("jump_key"))
+ for peer in self.store.current()["peers"]}, local_ways)
def test_arriving_settings_leave_a_half_typed_address_and_the_pairing_card(self):
self.window.host_field.setStringValue_("192.0.2.99")
@@ -338,6 +458,39 @@ class SameOnBothTests(unittest.TestCase):
self.assertEqual(len(self.sent), 1)
self.assertEqual(self.sent[0]["design"]["effect_length"], "short")
+ def test_a_shared_change_here_stamps_only_that_value_and_sends_the_stamps(self):
+ self.window._set_same(True)
+ own = self.store.current()["machine_id"]
+ before = dict(self.window.controller.cfg.same_stamps)
+ self.assertEqual(set(before), set(settings_sync.STAMPED_KEYS), "the seed is stored when Same changes")
+ self.sent.clear()
+ self.window.length_select.value = "short"
+ self.window._apply_settings()
+ stamps = self.store.load().same_stamps
+ changed = {key for key in stamps if stamps[key] != before[key]}
+ self.assertEqual(changed, {"effect_length", "effect_pace"})
+ self.assertEqual(stamps["effect_length"][1], own)
+ self.assertGreater(stamps["effect_length"][0], max(stamp for stamp, _by in before.values()))
+ sent = self.sent[-1]
+ self.assertEqual(sent["stamps"]["effect_length"], stamps["effect_length"])
+ self.assertEqual(sent["stamps"]["glow_colour"], before["glow_colour"])
+ self.assertGreaterEqual(sent["set_at"], stamps["effect_length"][0])
+
+ def test_a_change_here_while_off_is_stamped_and_kept_over_an_older_group_value(self):
+ self.window.length_select.value = "short"
+ self.window._apply_settings()
+ stamp = self.window.controller.cfg.same_stamps["effect_length"]
+ self.assertEqual(stamp[1], self.store.current()["machine_id"])
+ self.sent.clear()
+ self.window.apply_same(pc_message(True, 100))
+ cfg = self.window.controller.cfg
+ self.assertTrue(cfg.same_on_both)
+ self.assertEqual(cfg.crossing["effect_length"], "short")
+ self.assertEqual(cfg.crossing["glow_style"], "beam")
+ self.assertEqual(cfg.same_stamps["effect_length"], stamp)
+ self.assertEqual(cfg.same_stamps["glow_style"], [100, ""])
+ self.assertEqual(self.sent[-1]["design"]["effect_length"], "short", "the newer value is answered")
+
def test_a_design_change_while_off_announces_its_local_design_state(self):
self.window.length_select.value = "short"
self.window._apply_settings()
@@ -358,13 +511,76 @@ class SameOnBothTests(unittest.TestCase):
still.setNeedsDisplay_.assert_called_once_with(True)
repaint.assert_called_once_with()
- def test_an_old_pc_turns_the_switch_off_and_says_why(self):
+ def test_an_old_pc_keeps_the_picker_enabled_and_shows_the_compatibility_note(self):
self.window._set_same(True)
bring_up(self.window.controller, caps=("clipboard",))
self.assertIs(self.window.controller.peer_settings, False)
self.window._show_same()
- self.assertFalse(self.window.same_switch.value)
- self.assertIn("too old", self.window.same_note.text)
+ self.assertTrue(self.window.same_checks["crossing"].state())
+ self.assertTrue(self.window.same_checks["crossing"].isEnabled())
+ self.assertFalse(self.window.same_old_note.view.isHidden())
+
+ def test_names_only_keeps_design_following_and_local_scope(self):
+ self.pair_sources(PEER)
+ local_resistance = self.window.controller.cfg.crossing["resistance_px"]
+ local_drag_guard = self.window.controller.cfg.crossing["block_while_dragging"]
+ raw = settings_store.config_to_raw(self.window.controller.cfg)
+ raw.update(same_on_both=True, same_groups=["names"], design_follow_peer=PEER)
+ self.window.controller.apply_settings(self.store.save(raw))
+ self.window._design_states[PEER] = {"set_at": 100, "by": PEER, "values": {"effect_length": "long"}}
+ self.window._apply_followed_design(force=True)
+ self.window._show_same()
+ self.assertEqual(self.window.controller.cfg.crossing["effect_length"], "long")
+ self.assertEqual(self.window.controller.cfg.crossing["resistance_px"], local_resistance)
+ self.assertEqual(self.window.controller.cfg.crossing["block_while_dragging"], local_drag_guard)
+ self.assertEqual(self.window.resistance_ruler.value, local_resistance)
+ self.assertEqual(self.window.scope_labels["design"].text, pages.SCOPE["design"])
+ self.assertIn("Names", self.window.same_note.text)
+
+ def test_revert_restores_this_machines_name_and_shares_it(self):
+ self.pair_sources(PEER)
+ own = self.window.own_id()
+ original = self.store.current()["name"]
+ data = settings_sync.message_data(True, 100, by=PEER, groups=["names"],
+ names={own: {"label": "Remote name", "set_at": 100, "by": PEER}})
+ self.window.apply_same(data, peer=PEER)
+ self.assertEqual(self.store.current()["name"], "Remote name")
+ self.window.revertSame_(None)
+ self.assertEqual(self.store.current()["name"], original)
+ self.assertTrue(self.window.controller.cfg.same_on_both)
+ self.assertEqual(self.sent[-1]["names"][own]["label"], original)
+
+ def test_stale_names_policy_cannot_rename_after_names_was_deselected(self):
+ self.pair_sources(PEER)
+ self.window.apply_same(settings_sync.message_data(True, 200, by=PEER, groups=["crossing"]), peer=PEER)
+ self.window.apply_same(settings_sync.message_data(True, 100, by=PEER, groups=["names"],
+ names={PEER: {"label": "Delayed", "set_at": 300, "by": PEER}}), peer=PEER)
+ entry = next(item for item in self.store.current()["peers"] if item["id"] == PEER)
+ self.assertNotEqual(entry.get("label"), "Delayed")
+
+ def test_a_remote_selection_that_drops_design_resumes_the_cached_leader(self):
+ self.pair_sources(PEER, HIGH)
+ raw = settings_store.config_to_raw(self.window.controller.cfg)
+ raw.update(same_on_both=True, same_groups=["design"], same_set_at=10,
+ design_follow_peer=PEER)
+ self.window.controller.apply_settings(self.store.save(raw))
+ self.window._design_states[PEER] = {"set_at": 100, "by": PEER, "values": {"effect_length": "long"}}
+ self.window._followed_version = (PEER, 100, PEER)
+ self.window.apply_same(settings_sync.message_data(True, 11, by=HIGH, groups=["names"]), peer=HIGH)
+ self.assertEqual(self.window.controller.cfg.crossing["effect_length"], "long")
+
+ def test_selection_only_revert_keeps_a_later_local_design_edit(self):
+ self.pair_sources(PEER)
+ raw = settings_store.config_to_raw(self.window.controller.cfg)
+ raw.update(same_on_both=True, same_groups=["crossing"], same_set_at=10)
+ self.window.controller.apply_settings(self.store.save(raw))
+ self.window.apply_same(settings_sync.message_data(True, 11, by=PEER, groups=["design"]), peer=PEER)
+ raw = settings_store.config_to_raw(self.window.controller.cfg)
+ raw["crossing"]["glow_colour"] = "ocean"
+ self.window.controller.apply_settings(self.store.save(raw))
+ self.window.revertSame_(None)
+ self.assertEqual(self.window.controller.cfg.same_groups, ["crossing"])
+ self.assertEqual(self.window.controller.cfg.crossing["glow_colour"], "ocean")
def test_a_peers_same_state_is_forwarded_with_this_macs_own_design_state(self):
self.pair_sources(PEER)
diff --git a/mac_app/tests/test_settings_behaviour.py b/mac_app/tests/test_settings_behaviour.py
index 634a486..7e918b2 100644
--- a/mac_app/tests/test_settings_behaviour.py
+++ b/mac_app/tests/test_settings_behaviour.py
@@ -1,10 +1,28 @@
"""Mac settings decisions with in-memory configuration and no AppKit window."""
+from unittest import mock
+
+from core.tests import settings_behaviour
from core.tests.settings_behaviour import SettingsBehaviourTests as _SettingsBehaviourTests
class MacSettingsBehaviourTests(_SettingsBehaviourTests):
platform = "mac"
+ def setUp(self):
+ super().setUp()
+ self.app._methods = lambda: [name for name, tile in self.app.method_boxes.items() if tile.value]
+
+ def test_shared_clash_note_stays_visible_when_shortcut_is_switched_off(self):
+ load_methods = settings_behaviour.load_methods
+
+ def load_reflect(path, class_name, names, namespace):
+ # The shared fixture's unrelated-UI stop moved to the map refresh in the Mac ledger.
+ self.app._show_arrangement = namespace["pages"].part_names
+ return load_methods(path, class_name, names, namespace)
+
+ with mock.patch.object(settings_behaviour, "load_methods", side_effect=load_reflect):
+ super().test_shared_clash_note_stays_visible_when_shortcut_is_switched_off()
+
del _SettingsBehaviourTests
diff --git a/mac_app/tests/test_settings_layout_acceptance.py b/mac_app/tests/test_settings_layout_acceptance.py
index faea9b4..b2f41cf 100644
--- a/mac_app/tests/test_settings_layout_acceptance.py
+++ b/mac_app/tests/test_settings_layout_acceptance.py
@@ -113,7 +113,7 @@ class SettingsLayoutAcceptanceTests(unittest.TestCase):
def test_window_minimum_and_resize_constraints_cannot_drive_native_frame(self):
control = self.control
- self.assertEqual(tuple(control.window.minSize()), (320, 300))
+ self.assertEqual(tuple(control.window.minSize()), (640, 540))
for key in control.pages:
control._select_page(key)
self.assertLess(control.page_width_constraints[key].priority(), 500)
@@ -148,16 +148,19 @@ class SettingsLayoutAcceptanceTests(unittest.TestCase):
heading = control.panel.pair_button.view.superview().arrangedSubviews()[0]
self.assertGreaterEqual(heading.bounds().size.width, heading.attributedStringValue().size().width)
- def test_shortcut_diagram_legend_layers_fit_the_narrow_column(self):
+ def test_atlas_canvas_tiles_fit_the_narrow_column(self):
control = self.control
control._select_page('crossing')
control.window.setFrame_display_(((100000, 100000), (320, 900)), False)
settle(control.window)
- diagram = control.arrangement_diagram
- for layer in (diagram.key, diagram.key_how):
- rect = layer.frame()
- self.assertLessEqual(rect.origin.x + rect.size.width, diagram.bounds().size.width)
- self.assertLessEqual(rect.origin.y + rect.size.height, diagram.bounds().size.height)
+ canvas = control.atlas_canvas
+ canvas.setFrame_(((0, 0), (canvas.superview().bounds().size.width, canvas.HEIGHT)))
+ frames, _scale = canvas._map()
+ for rect in frames.values():
+ self.assertGreaterEqual(rect[0], 0)
+ self.assertGreaterEqual(rect[1], 0)
+ self.assertLessEqual(rect[0] + rect[2], canvas.bounds().size.width)
+ self.assertLessEqual(rect[1] + rect[3], canvas.bounds().size.height)
def test_key_recorders_keep_their_titles_readable_in_the_narrow_column(self):
control = self.control
@@ -222,12 +225,13 @@ class SettingsLayoutAcceptanceTests(unittest.TestCase):
control.window.makeFirstResponder_(control.window)
control.window.selectNextKeyView_(None)
self.assertEqual(control.window.firstResponder(), control.sidebar.rows['design'][1])
- cell = control.length_select.cells[0][1]
- control.window.makeFirstResponder_(cell)
- self.assertFalse(cell.ring.isHidden())
+ slider = control.length_select.focusable_views[0]
+ self.assertTrue(slider.acceptsFirstResponder())
+ control.window.makeFirstResponder_(slider)
+ self.assertIs(control.window.firstResponder(), slider)
control.window.keyboard_navigation = False
control.window.refresh_input_focus()
- self.assertTrue(cell.ring.isHidden())
+ self.assertFalse(control.window.keyboard_navigation)
def test_length_size_stay_vertical_and_toggle_targets_remain_usable(self):
control = self.control
diff --git a/mac_app/tests/test_settings_polish.py b/mac_app/tests/test_settings_polish.py
index ba7fbfa..0fac0e5 100644
--- a/mac_app/tests/test_settings_polish.py
+++ b/mac_app/tests/test_settings_polish.py
@@ -1,5 +1,7 @@
"""Text, control grouping and preview geometry in unordered settings windows."""
+import copy
import unittest
+from types import SimpleNamespace
from mac_app.tests.design_offscreen import AppKit, kvm_bridge_app, offscreen_control_window, settle
from mac_app.tests.test_settings_layout_acceptance import frame_in, walk
@@ -21,6 +23,14 @@ class SettingsPolishTests(unittest.TestCase):
theme.init_fonts()
cls.control = offscreen_control_window()
+ def _add_machine_row(self):
+ state = SimpleNamespace(key="linked", word="Connected", led="signal", blink=False,
+ tone="signal", detail="")
+ row = SimpleNamespace(label="Windows PC", state=state, token="synthetic", platform="Windows",
+ address="192.0.2.20", in_use=True, drives=True, driven=True,
+ phone=False, left_out=False)
+ self.control.panel._build_rows([row])
+
def test_all_segment_labels_fit_one_line_in_both_appearances(self):
control = self.control
for dark in (False, True):
@@ -40,6 +50,10 @@ class SettingsPolishTests(unittest.TestCase):
with self.subTest(page=page, width=width, label=words.text, dark=dark):
text = words.view.attributedStringValue()
self.assertGreaterEqual(words.view.bounds().size.width + .5, text.size().width)
+ if not selector.enabled:
+ # A dimmed picker (Corner while Corner is off) drops the ink fill
+ # on purpose; the contrast bar is for live choices only.
+ continue
foreground = text.attribute_atIndex_effectiveRange_(AppKit.NSForegroundColorAttributeName, 0, None)[0]
a, b = sorted((luminance(foreground), luminance(theme.colour('ink'))))
self.assertGreaterEqual((b + .05) / (a + .05), 4.5)
@@ -82,6 +96,7 @@ class SettingsPolishTests(unittest.TestCase):
def test_overview_machine_controls_form_one_group_at_the_right_edge(self):
control = self.control
+ self._add_machine_row()
control._select_page('overview')
control.window.setFrame_display_(((100000, 100000), (900, 900)), False)
settle(control.window)
@@ -89,27 +104,39 @@ class SettingsPolishTests(unittest.TestCase):
controls = [v for v in walk(row) if isinstance(v, widgets.Pressable) and v.accessibilityLabel()]
in_use = next(v for v in controls if v.accessibilityLabel() == 'In use')
directions = next(v for v in controls if str(v.accessibilityLabel()).startswith('Show directions'))
+ left_out = next(v for v in controls if str(v.accessibilityLabel()).startswith('Leave out '))
remove = next(v for v in controls if str(v.accessibilityLabel()).startswith('Remove '))
- a, b, c = (frame_in(v, row) for v in (in_use, directions, remove))
+ a, b, c, d = (frame_in(v, row) for v in (in_use, left_out, directions, remove))
self.assertAlmostEqual(b.origin.x - a.origin.x - a.size.width, 12, delta=1)
self.assertAlmostEqual(c.origin.x - b.origin.x - b.size.width, 12, delta=1)
- self.assertAlmostEqual(c.origin.x + c.size.width, row.bounds().size.width - 12, delta=1)
+ self.assertAlmostEqual(d.origin.x - c.origin.x - c.size.width, 12, delta=1)
+ self.assertAlmostEqual(d.origin.x + d.size.width, row.bounds().size.width - 12, delta=1)
def test_machine_names_fit_both_crossing_drawings_at_minimum_width(self):
control = self.control
+ self._add_machine_row()
control._select_page('crossing')
- control.window.setFrame_display_(((100000, 100000), (320, 900)), False)
- settle(control.window)
- diagram = control.arrangement_diagram
- for layer in (diagram.this_label, *[label for _screen, label in diagram.screens.values()],
- control.push_strip.this_label, control.push_strip.other_label):
- with self.subTest(name=layer.string()):
- self.assertEqual(layer.truncationMode(), kvm_bridge_app.Quartz.kCATruncationNone)
- text = AppKit.NSAttributedString.alloc().initWithString_attributes_(str(layer.string()), {
- AppKit.NSFontAttributeName: layer.font()})
- size = text.boundingRectWithSize_options_((layer.bounds().size.width, 10000), AppKit.NSStringDrawingUsesLineFragmentOrigin).size
- self.assertGreaterEqual(layer.bounds().size.height + 1, size.height)
- self.assertGreaterEqual(control.push_strip.fill.bounds().size.width, 0)
+ for width in (320, 640, 900, 1440, 1920):
+ control.window.setFrame_display_(((100000, 100000), (width, 900)), False)
+ settle(control.window)
+ control.push_strip.set_other_name("Alex’s Windows gaming machine")
+ canvas = control.atlas_canvas
+ own = control.settings_store.current()["machine_id"]
+ canvas.show_layout(
+ {own: {"x": 0, "y": 0, "w": 160, "h": 100},
+ "synthetic": {"x": 160, "y": 0, "w": 160, "h": 100}},
+ {}, {own: "This Mac", "synthetic": "Alex’s Windows gaming machine"}, own, "synthetic")
+ title = canvas.label_for_tile["synthetic"]
+ with self.subTest(width=width):
+ self.assertEqual(title.string(), "Alex’s Windows gaming machine")
+ self.assertGreater(title.frame().size.width, 0)
+ label = control.push_strip.peer_label_text(width)
+ attributes = {AppKit.NSFontAttributeName: theme.font(theme.TYPE['eyebrow'], 600),
+ AppKit.NSKernAttributeName: 1.45}
+ ink = AppKit.NSString.stringWithString_(label).sizeWithAttributes_(attributes).width
+ with self.subTest(width=width, label=label):
+ self.assertLessEqual(ink, width / 2 - 16)
+ self.assertGreaterEqual(control.push_strip.bounds().size.height, 72)
def test_narrow_resistance_push_always_moves_towards_the_other_machine(self):
control = self.control
@@ -117,8 +144,19 @@ class SettingsPolishTests(unittest.TestCase):
control.window.setFrame_display_(((100000, 100000), (320, 900)), False)
settle(control.window)
strip = control.push_strip
- strip.show(1)
- self.assertGreaterEqual(strip.pointer.position().x, strip.edge.frame().origin.x)
+ configured = strip.value
+ strip.set_pressure(500)
+ from core.resistance_strip import resistance_x
+ self.assertEqual(resistance_x(strip.bounds().size.width, strip._pressure),
+ resistance_x(strip.bounds().size.width, 500))
+ self.assertEqual(strip.value, configured)
+
+ def test_decay_refresh_keeps_the_active_edge_in_its_accessible_description(self):
+ strip = self.control.push_strip
+ strip.set_pressure(60, "top")
+ strip.set_pressure(30)
+ self.assertEqual(strip._active_edge, "top")
+ self.assertIn("top edge", strip._accessibility_description)
def test_narrow_machine_card_preserves_its_name_and_address(self):
control = self.control
@@ -136,21 +174,33 @@ class SettingsPolishTests(unittest.TestCase):
self.assertTrue(label.cell().wraps())
self.assertGreaterEqual(label.bounds().size.height + 1, height)
- def test_crossing_headers_wrap_complete_machine_names(self):
+ def test_crossing_ledger_elides_machine_names_with_complete_tooltips(self):
control = self.control
control._select_page('crossing')
- for width in (320, 640, 900, 1440, 1920):
- control.window.setFrame_display_(((100000, 100000), (width, 900)), False)
- for heading, text in ((control.ways_heading, 'Ways from this screen to Alex’s Windows gaming machine'),
- (control.jump_heading, 'Jump to Alex’s Windows gaming machine')):
- previous = heading.stringValue()
- heading.setStringValue_(text)
+ previous = control.settings_store._cache
+ settings = copy.deepcopy(previous)
+ peer = '0123456789abcdef0123456789abcdef'
+ text = 'Alex’s Windows gaming machine with two monitors'
+ settings['peers'] = [{'id': peer, 'name': text, 'token': 'synthetic-render-only',
+ 'platform': 'windows', 'port': 24820, 'in_use': True,
+ 'send': True, 'recv': True, 'side': 'right'}]
+ control.settings_store._cache = settings
+ try:
+ control.crossing_ledger.refresh(settings, peer)
+ for width in (640, 900, 1440, 1920):
+ control.window.setFrame_display_(((100000, 100000), (width, 900)), False)
settle(control.window)
- available = heading.cell().drawingRectForBounds_(heading.bounds()).size.width
- size = heading.attributedStringValue().boundingRectWithSize_options_((available, 10000), AppKit.NSStringDrawingUsesLineFragmentOrigin).size
- with self.subTest(width=width, heading=text):
- self.assertGreaterEqual(heading.bounds().size.height + 1, size.height)
- heading.setStringValue_(previous)
+ control.crossing_ledger.reflow()
+ row = control.crossing_ledger.rows[peer]
+ with self.subTest(width=width):
+ self.assertEqual(row.name.view.stringValue(), text)
+ self.assertEqual(row.name.view.toolTip(), text)
+ self.assertEqual(row.name.view.accessibilityLabel(), text)
+ self.assertEqual(row.name.view.lineBreakMode(), AppKit.NSLineBreakByTruncatingTail)
+ self.assertTrue(AppKit.NSContainsRect(row.cells['machine'].bounds(), row.name.view.frame()))
+ finally:
+ control.settings_store._cache = previous
+ control.crossing_ledger.refresh(previous, control.chosen_peer)
def test_preview_captions_fit_without_overlapping_the_picture_or_each_other(self):
control = self.control
@@ -226,6 +276,7 @@ class SettingsPolishTests(unittest.TestCase):
row = control.panel.list.arrangedSubviews()[0]
controls = [v for v in walk(row) if isinstance(v, widgets.Pressable) and v.accessibilityLabel()]
chosen = [next(v for v in controls if v.accessibilityLabel() == 'In use'),
+ next(v for v in controls if str(v.accessibilityLabel()).startswith('Leave out ')),
next(v for v in controls if str(v.accessibilityLabel()).startswith('Show directions')),
next(v for v in controls if str(v.accessibilityLabel()).startswith('Remove '))]
frames = [frame_in(v, row) for v in chosen]
@@ -240,14 +291,22 @@ class SettingsPolishTests(unittest.TestCase):
control._select_page('crossing')
control.window.setFrame_display_(((100000, 100000), (320, 900)), False)
settle(control.window)
- diagram = control.arrangement_diagram
- machines = [dict(control._diagram_machines(['edge'])[0], label='Alex’s Windows gaming machine')]
- diagram.show(machines, 'F12', False, 'Synthetic long machine', shortcut=False)
- control.push_strip.show(1, 'Alex’s Windows gaming machine')
+ canvas = control.atlas_canvas
+ own = control.settings_store.current()["machine_id"]
+ canvas.show_layout(
+ {own: {"x": 0, "y": 0, "w": 160, "h": 100},
+ "synthetic": {"x": 160, "y": 0, "w": 160, "h": 100}},
+ {}, {own: "This Mac", "synthetic": "Alex’s Windows gaming machine"}, own, "synthetic")
+ control.push_strip.set_other_name('Alex’s Windows gaming machine')
settle(control.window)
- for screen, label in diagram.screens.values():
- self.assertTrue(AppKit.NSContainsRect(screen.frame(), label.frame()))
- self.assertTrue(AppKit.NSContainsRect(control.push_strip.bounds(), control.push_strip.other_label.frame()))
+ self.assertEqual(canvas.label_for_tile["synthetic"].string(), 'Alex’s Windows gaming machine')
+ self.assertGreater(canvas.label_for_tile["synthetic"].frame().size.width, 0)
+ peer_label = control.push_strip.peer_label_text()
+ attributes = {AppKit.NSFontAttributeName: theme.font(theme.TYPE['eyebrow'], 600),
+ AppKit.NSKernAttributeName: 1.45}
+ width = AppKit.NSString.stringWithString_(peer_label).sizeWithAttributes_(attributes).width
+ self.assertLessEqual(width, control.push_strip.bounds().size.width / 2 - 16)
+ self.assertTrue(peer_label.endswith('…'))
if __name__ == '__main__':
diff --git a/mac_app/tests/test_settings_sync_link.py b/mac_app/tests/test_settings_sync_link.py
index 2a13ea8..af0d8fe 100644
--- a/mac_app/tests/test_settings_sync_link.py
+++ b/mac_app/tests/test_settings_sync_link.py
@@ -163,6 +163,9 @@ class Rig:
"auth_token": PAIRED_TOKEN, "pc_name": "PC"})
settings = self.store.current()
settings["peers"][0].update(id=protocol.id_text(PC_ID), from_1_4=False)
+ for zone in settings["zones"]:
+ if zone.get("peer") == "":
+ zone["peer"] = protocol.id_text(PC_ID)
if side is not None:
settings["peers"][0].update(side=side[0], side_set_at=side[1], side_by=self.mac_id_text)
self.store.save_settings(settings)
diff --git a/mac_app/tests/test_settings_v6.py b/mac_app/tests/test_settings_v6.py
index e571861..9bbae42 100644
--- a/mac_app/tests/test_settings_v6.py
+++ b/mac_app/tests/test_settings_v6.py
@@ -370,13 +370,17 @@ class ReimportTests(Base):
self.write_settings(settings)
before = self.path.read_bytes()
self.store.load()
- self.assertEqual(self.path.read_bytes(), before)
+ self.assertEqual(self.settings()["peers"][0]["token"], TOKEN)
+ self.assertTrue(self.settings()["peers"][1]["ways"]["edge"])
+ migrated = self.path.read_bytes()
+ self.store.load()
+ self.assertEqual(self.path.read_bytes(), migrated)
raw = legacy_1_4_3()
raw["auth_token"] = OTHER_TOKEN
self.write_legacy(raw)
self.store.load()
peers = self.settings()["peers"]
- self.assertEqual(peers[1], added)
+ self.assertEqual({key: peers[1][key] for key in added}, added)
self.assertEqual(peers[0]["token"], OTHER_TOKEN)
def test_a_migrated_peer_the_user_removed_stays_removed_while_config_is_unchanged(self):
@@ -455,6 +459,20 @@ class SavingTests(Base):
self.assertEqual(self.path.read_bytes(), before)
+ def test_each_shared_values_stamp_is_saved_and_a_malformed_one_is_dropped(self):
+ stamps = {"glow_colour": [500, PEER_ID], "trigger_key": [400, ""]}
+ self.store.save(config_to_raw(replace(self.cfg, same_stamps=stamps)))
+ self.assertEqual(self.settings()["same_stamps"], stamps)
+ self.assertEqual(self.store.load().same_stamps, stamps)
+ settings = self.settings()
+ settings["same_stamps"] = {"glow_colour": [500, PEER_ID], "trigger_key": ["x", PEER_ID],
+ "glow_style": [5, "not an id"], "not_shared": [5, PEER_ID]}
+ self.write_settings(settings)
+ self.assertEqual(SettingsStore(self.path).load().same_stamps, {"glow_colour": [500, PEER_ID]})
+ settings["same_stamps"] = "junk"
+ self.write_settings(settings)
+ self.assertEqual(SettingsStore(self.path).load().same_stamps, {})
+
def test_saving_keeps_the_machine_id_and_the_id_of_the_peer_and_writes_privately(self):
settings = self.settings()
settings["peers"][0].update(id=PEER_ID, linked=True)
@@ -491,7 +509,7 @@ class SavingTests(Base):
raw["crossing"]["arrangement_set_at"] = 1790000500
cfg = self.store.save(raw)
after = self.settings()
- self.assertEqual(after["peers"][1], added)
+ self.assertEqual({key: after["peers"][1][key] for key in added}, added)
first = after["peers"][0]
self.assertEqual((first["host"], first["name"], first["send"]), ("192.0.2.99", "Renamed", False))
# The side is written by set_ways and arrangement only: a flat view read before another
@@ -534,10 +552,10 @@ class SavingTests(Base):
self.assertEqual(self.settings()["peers"][0]["side_by"], SECOND_ID)
self.assertFalse(self.store.set_ways(PEER_ID, side="left", methods=["edge"], parts=["middle"], corner="top_right"))
self.assertEqual(self.settings()["peers"][0]["side_by"], SECOND_ID)
- self.assertTrue(self.store.set_ways(PEER_ID, side="top", methods=["edge"], parts=["middle"], corner="top_right"))
+ self.assertFalse(self.store.set_ways(PEER_ID, side="top", methods=["edge"], parts=["middle"], corner="top_right"))
first = self.settings()["peers"][0]
- self.assertEqual((first["side"], first["side_by"]), ("top", self.settings()["machine_id"]))
- self.assertGreater(first["side_set_at"], 1790000000)
+ self.assertEqual((first["side"], first["side_by"]), ("left", SECOND_ID))
+ self.assertEqual(first["side_set_at"], 1790000000)
def test_an_arrangement_from_the_peer_is_stamped_with_the_peers_id_not_this_machines(self):
self.with_id()
@@ -594,7 +612,7 @@ class SavingTests(Base):
self.assertFalse(self.settings()["shortcut"])
self.store.set_ways(PEER_ID, side="left", methods=["part", "notch"], parts=["middle"], corner="top_right")
zones = {zone["kind"]: zone for zone in self.settings()["zones"]}
- self.assertTrue(zones["edge"]["off"])
+ self.assertNotIn("edge", zones)
self.assertNotIn("off", zones["part"])
self.assertEqual(zones["part"]["parts"], ["middle"])
self.assertNotIn("off", zones["notch"])
@@ -609,7 +627,7 @@ class SavingTests(Base):
corner = [z for z in self.settings()["zones"] if z["kind"] == "corner"][0]
self.assertEqual((corner["corner"], corner["edge"]), ("bottom_left", "left"))
- def test_ways_that_would_clash_with_another_machines_are_refused_with_both_named_and_nothing_written(self):
+ def test_editing_ways_saves_intent_without_moving_the_picture_or_writing_off_flags(self):
settings = self.with_id()
second = {**copy.deepcopy(settings["peers"][0]), "id": SECOND_ID, "side": "right", "name": "Second"}
second["token"] = second["token"][::-1]
@@ -620,11 +638,11 @@ class SavingTests(Base):
# On the same side as Second, with no way in yet: turning its edge on would cover Second's.
self.store.set_ways(PEER_ID, side="right", methods=[], parts=["middle"], corner="top_right")
before = self.settings()
- with self.assertRaises(SettingsError) as raised:
- self.store.set_ways(PEER_ID, side="right", methods=["edge"], parts=["middle"], corner="top_right")
- self.assertIn("Second", str(raised.exception))
- self.assertIn("right edge of this Mac", str(raised.exception))
- self.assertEqual(self.settings(), before)
+ self.store.set_ways(PEER_ID, side="right", methods=["edge"], parts=["middle"], corner="top_right")
+ after = self.settings()
+ self.assertTrue(after["peers"][0]["ways"]["edge"])
+ self.assertEqual(after["layout"], before["layout"])
+ self.assertFalse(any(zone.get("off") for zone in after["zones"]))
def second_machine(self, side, zones=None):
settings = self.with_id()
@@ -641,17 +659,22 @@ class SavingTests(Base):
self.second_machine("right")
self.assertIn({"peer": SECOND_ID, "kind": "edge"}, self.store.current()["zones"])
- def test_one_whose_side_is_taken_gets_its_edge_off_and_the_settings_still_read(self):
+ def test_loading_a_taken_side_keeps_edge_intent_without_off_flags_or_a_share_offer(self):
self.second_machine("left")
- self.assertIn({"peer": SECOND_ID, "kind": "edge", "off": True}, self.store.current()["zones"])
- self.assertIn("Second has no way in", ways.blocked_sentence(self.store.current(), SECOND_ID, "this Mac"))
+ second = self.store.current()["peers"][1]
+ self.assertTrue(second["ways"]["edge"])
+ self.assertFalse(any(zone.get("off") for zone in self.store.current()["zones"]))
+ self.assertIsNone(ways.share_offer(self.store.current(), SECOND_ID))
- def test_moving_a_machine_onto_a_taken_side_keeps_the_side_and_turns_its_way_there_off(self):
+ def test_a_side_argument_cannot_move_the_picture_or_disable_edge_intent(self):
self.second_machine("right", [{"peer": SECOND_ID, "kind": "edge"}])
- self.assertTrue(self.store.set_ways(SECOND_ID, side="left", methods=["edge"], parts=["middle"], corner="top_right"))
+ self.store.load()
+ before = copy.deepcopy(self.store.current()["layout"])
+ self.assertFalse(self.store.set_ways(SECOND_ID, side="left", methods=["edge"], parts=["middle"], corner="top_right"))
second = next(entry for entry in self.settings()["peers"] if entry["id"] == SECOND_ID)
- self.assertEqual(second["side"], "left")
- self.assertIn({"peer": SECOND_ID, "kind": "edge", "off": True}, self.settings()["zones"])
+ self.assertEqual(second["side"], "right")
+ self.assertEqual(self.settings()["layout"], before)
+ self.assertTrue(second["ways"]["edge"])
def test_ways_for_a_machine_no_longer_paired_are_refused(self):
with self.assertRaises(SettingsError):
@@ -733,7 +756,7 @@ class PairedAndRemovedTests(Base):
after = self.settings()
self.assertEqual([peer["id"] for peer in after["peers"]], [PEER_ID])
# Only the new machine's own edge, which every machine paired starts with.
- self.assertEqual(after["zones"], [{"peer": PEER_ID, "kind": "edge"}])
+ self.assertEqual(after["zones"], [{"peer": PEER_ID, "kind": "edge", "side": "right"}])
self.assertEqual(self.store.load().auth_token, OTHER_TOKEN)
def test_a_pairing_that_cannot_be_written_raises_and_changes_nothing(self):
@@ -755,7 +778,7 @@ class PairedAndRemovedTests(Base):
self.store.add_peer(self.entry(SECOND_ID, OTHER_TOKEN))
self.store.remove_peer(TOKEN)
self.assertEqual(self.store.load().auth_token, OTHER_TOKEN)
- self.assertEqual(self.settings()["zones"], [{"peer": SECOND_ID, "kind": "edge"}])
+ self.assertEqual(self.settings()["zones"], [{"peer": SECOND_ID, "kind": "edge", "side": "right"}])
def test_removing_the_only_machine_leaves_this_one_unpaired_and_it_stays_so(self):
self.store.remove_peer(TOKEN)
@@ -1035,15 +1058,36 @@ class OverlapTests(Base):
self.write_legacy(legacy_1_4_3())
self.store.load()
- def refused(self, change):
+ def compiled(self, change):
settings = self.settings()
change(settings)
+ if settings["peers"][0]["id"] == "":
+ settings["peers"][0]["id"] = PEER_ID
+ settings["zones"] = [{**zone, "peer": PEER_ID} if zone["peer"] == "" else zone
+ for zone in settings["zones"]]
+ settings["layout"] = {}
+ for peer in settings["peers"]:
+ peer.pop("ways", None)
self.write_settings(settings)
- with self.assertRaises(SettingsError):
- SettingsStore(self.path).load()
-
- def test_the_edge_and_its_thirds_in_use_together_are_refused(self):
- self.refused(lambda s: s["zones"][1].pop("off"))
+ self.store = SettingsStore(self.path)
+ self.store.load()
+ saved = self.store.current()
+ self.assertFalse(any(zone.get("off") or zone.get("aside") for zone in saved["zones"]))
+ return saved
+
+ def test_legacy_whole_edge_wins_over_thirds_kept_on_an_off_part_zone(self):
+ saved = self.compiled(lambda s: None)
+ self.assertEqual(saved["peers"][0]["ways"]["thirds"], list(ways.PARTS))
+ self.assertEqual([zone["kind"] for zone in saved["zones"]].count("edge"), 1)
+ self.assertNotIn("part", [zone["kind"] for zone in saved["zones"]])
+
+ def test_legacy_edge_and_thirds_both_on_cross_by_the_whole_edge(self):
+ # 1.4.x let both be on and the edge covered the thirds (WIRE.md section 8), as rc12's reader
+ # said too, so what crossed before still crosses: the whole edge, as on the PC.
+ saved = self.compiled(lambda s: s["zones"][1].pop("off"))
+ self.assertEqual(saved["peers"][0]["ways"]["thirds"], list(ways.PARTS))
+ self.assertEqual([zone["kind"] for zone in saved["zones"]].count("edge"), 1)
+ self.assertNotIn("part", [zone["kind"] for zone in saved["zones"]])
def test_the_edge_and_the_notch_stay_together_as_1_4_x_let_them(self):
settings = self.settings()
@@ -1051,43 +1095,48 @@ class OverlapTests(Base):
self.write_settings(settings)
self.assertIn("notch", SettingsStore(self.path).load().crossing["methods"])
- def test_two_part_zones_sharing_a_third_are_refused_and_disjoint_ones_are_not(self):
+ def test_overlapping_and_disjoint_legacy_part_zones_union_their_thirds(self):
def two_parts(s, second):
s["zones"][0]["off"] = True
s["zones"][1].pop("off")
s["zones"].append({"peer": "", "kind": "part", "parts": second})
- self.refused(lambda s: two_parts(s, ["end", "middle"]))
+ saved = self.compiled(lambda s: two_parts(s, ["end", "middle"]))
+ self.assertEqual(saved["peers"][0]["ways"]["thirds"], list(ways.PARTS))
self.path.unlink()
self.write_legacy(legacy_1_4_3())
self.store.load()
- settings = self.settings()
- two_parts(settings, ["middle"])
- self.write_settings(settings)
- SettingsStore(self.path).load()
+ saved = self.compiled(lambda s: two_parts(s, ["middle"]))
+ self.assertEqual(saved["peers"][0]["ways"]["thirds"], list(ways.PARTS))
- def test_two_peers_whose_edges_face_the_same_side_cannot_both_have_the_edge_zone_on(self):
+ def test_same_side_peers_keep_edge_intent_without_a_clash(self):
def second_peer(s):
s["peers"][0]["id"] = PEER_ID
s["zones"] = [{**z, "peer": PEER_ID} for z in s["zones"]]
s["peers"].append({**s["peers"][0], "id": SECOND_ID, "token": OTHER_TOKEN, "from_1_4": False})
s["zones"].append({"peer": SECOND_ID, "kind": "edge"})
- self.refused(second_peer)
+ saved = self.compiled(second_peer)
+ self.assertTrue(all(peer["ways"]["edge"] for peer in saved["peers"]))
+ self.assertIsNone(ways.clash(saved, "this Mac"))
- def test_a_corner_inside_the_edge_is_fine_and_two_of_one_corner_are_not(self):
+ def test_duplicate_legacy_corner_zones_compile_to_one_corner(self):
settings = self.settings()
settings["zones"][2]["corner"] = "top_left"
settings["zones"][2]["edge"] = "left"
self.write_settings(settings)
SettingsStore(self.path).load()
- self.refused(lambda s: s["zones"].append({"peer": "", "kind": "corner", "corner": "top_left", "edge": "left"}))
+ saved = self.compiled(lambda s: s["zones"].append(
+ {"peer": "", "kind": "corner", "corner": "top_left", "edge": "left"}))
+ self.assertEqual([zone["kind"] for zone in saved["zones"]].count("corner"), 1)
- def test_ways_with_the_edge_and_the_thirds_on_write_the_thirds_off(self):
- self.store.set_ways("", side="left", methods=["edge", "part"], parts=["middle"], corner="top_right")
+ def test_editing_edge_and_thirds_compiles_a_whole_edge_without_a_part_zone(self):
+ self.compiled(lambda _s: None)
+ self.store.set_ways(PEER_ID, side="left", methods=["edge", "part"], parts=["middle"], corner="top_right")
self.assertEqual(self.store.load().crossing["methods"], ["shortcut", "edge"])
zones = {z["kind"]: z for z in self.settings()["zones"]}
- self.assertTrue(zones["part"]["off"])
+ self.assertNotIn("part", zones)
+ self.assertEqual(self.store.current()["peers"][0]["ways"]["thirds"], list(ways.PARTS))
- def test_two_machines_on_one_notch_are_refused(self):
+ def test_two_machines_keep_notch_intent_while_the_picture_compiles_one_notch(self):
def two_notches(s):
s["peers"][0]["id"] = PEER_ID
s["zones"] = [{**z, "peer": PEER_ID} for z in s["zones"]]
@@ -1096,7 +1145,9 @@ class OverlapTests(Base):
second["token"] = second["token"][::-1]
s["peers"].append(second)
s["zones"].append({"peer": SECOND_ID, "kind": "notch"})
- self.refused(two_notches)
+ saved = self.compiled(two_notches)
+ self.assertTrue(all(peer["ways"]["notch"] for peer in saved["peers"]))
+ self.assertEqual([zone["kind"] for zone in saved["zones"]].count("notch"), 1)
if __name__ == "__main__":
diff --git a/mac_app/tests/test_shortcut_home_chain.py b/mac_app/tests/test_shortcut_home_chain.py
new file mode 100644
index 0000000..3724cd0
--- /dev/null
+++ b/mac_app/tests/test_shortcut_home_chain.py
@@ -0,0 +1,256 @@
+"""The owner's rc14 log, 10-10-2026: home -> Loan laptop (edge) -> Desk PC (peer switch) -> Loan laptop
+(peer switch), then a double tap of right Command on the Mac's own keyboard did nothing, and logged
+nothing. Rebuilt with the real owner and the real `switch`/`accept` handling, links faked."""
+
+import logging
+import os
+import sys
+import unittest
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+
+from bridge import KVMController
+from core import protocol
+from bridge_fakes import PAIRED_TOKEN, FakeClipboard, FakeClock, FakeQuartz, crossing_config, quiet_logger, settle
+from fake_link import OTHER_ID, PEER_ID, FakeLink
+
+FEDORA_ID = bytes(range(81, 97))
+CMD_R = 0x36
+DOWN = FakeQuartz.kCGEventFlagMaskCommand | 0x0010 | 0x0100 # command, right-command device bit, non-coalesced
+UP = 0x0100
+
+
+class Chain(unittest.TestCase):
+ style = "double_tap"
+
+ def setUp(self):
+ FakeQuartz.reset_cursor_spies()
+ self.clock = FakeClock()
+ cfg = crossing_config(PAIRED_TOKEN, methods=["edge", "shortcut"], shortcut_goes_to="last")
+ cfg.trigger_key = "cmd_r"
+ cfg.trigger_style = self.style
+ cfg.double_tap_ms = 300
+ self.controller = KVMController(
+ cfg, logger=quiet_logger(), quartz=FakeQuartz, clock=self.clock, clipboard=FakeClipboard("x"),
+ link_factory=FakeLink, desktop_bounds=lambda: (0, 0, 1920, 1080))
+ self.addCleanup(self.controller.stop_event.set)
+ c = self.controller
+ self.own = protocol.id_text(c.identity()["id"])
+ with c.book.lock:
+ peers = c.book.data["peers"]
+ peers.append({**peers[0], "id": protocol.id_text(OTHER_ID), "token": "acg", "send": True})
+ peers.append({**peers[0], "id": protocol.id_text(FEDORA_ID), "token": "fedora", "send": True})
+ c._sync_links()
+ self.win = c._primary_link
+ self.acg = c.links["acg"]
+ self.fed = c.links["fedora"]
+ self.win.up(c, ident=PEER_ID, name="Desk PC", platform="windows")
+ self.acg.up(c, ident=OTHER_ID, name="Loan laptop", platform="windows")
+ self.fed.up(c, ident=FEDORA_ID, name="fedora", platform="linux")
+
+ def tap(self, event_type, event):
+ return self.controller._event_tap_callback(None, event_type, event, None)
+
+ def key(self, down, injected=False):
+ event = {FakeQuartz.kCGKeyboardEventKeycode: CMD_R, "flags": DOWN if down else UP}
+ return event
+
+ def chain_to_acg(self):
+ c = self.controller
+ # 1. the tap's engine crosses at the right edge to Loan laptop
+ self.assertTrue(c.set_redirecting(True, edge="left", offset=0.5, peer=protocol.id_text(OTHER_ID), reason="edge"))
+ self.acg.arrives(c, protocol.accept_msg(c.owner.route))
+ # 2. Loan laptop switches to Desk PC
+ self.acg.arrives(c, protocol.switch_v6(c.owner.route, PEER_ID, "left", 0.5))
+ self.win.arrives(c, protocol.accept_msg(c.owner.route))
+ self.assertEqual(c.owner.on, protocol.id_text(PEER_ID))
+ # 3. Desk PC switches back to Loan laptop
+ self.win.arrives(c, protocol.switch_v6(c.owner.route, OTHER_ID, "left", 0.5))
+ self.acg.arrives(c, protocol.accept_msg(c.owner.route))
+ self.assertEqual(c.owner.on, protocol.id_text(OTHER_ID))
+ self.assertTrue(c.redirecting)
+
+ def double_tap(self, gap=0.1):
+ results = []
+ for step in range(2):
+ results.append(self.tap(FakeQuartz.kCGEventFlagsChanged, self.key(True)))
+ self.clock.value += 0.05
+ results.append(self.tap(FakeQuartz.kCGEventFlagsChanged, self.key(False)))
+ self.clock.value += gap
+ return results
+
+ def assertHome(self):
+ settle(self.controller)
+ c = self.controller
+ self.assertFalse(c.redirecting)
+ self.assertIsNone(c.owner.on)
+
+
+class DoubleTapChainTests(Chain):
+ def _use_next_cycle(self):
+ self.controller.cfg.crossing["shortcut_goes_to"] = "next"
+ order = [protocol.id_text(OTHER_ID), protocol.id_text(FEDORA_ID)]
+ self.controller._shortcut_cycle = lambda: order
+ self.controller._ready = lambda _ident: True
+
+ def test_next_target_after_a_local_move(self):
+ self._use_next_cycle()
+ c = self.controller
+ self.assertTrue(c.set_redirecting(True, peer=protocol.id_text(OTHER_ID)))
+ self.acg.arrives(c, protocol.accept_msg(c.owner.route))
+
+ self.assertEqual(c.owner.on, protocol.id_text(OTHER_ID))
+ self.assertEqual(c._cycle_target(), protocol.id_text(FEDORA_ID))
+
+ def test_next_target_after_a_peer_requested_move(self):
+ self._use_next_cycle()
+ c = self.controller
+ self.assertTrue(c.set_redirecting(True, peer=protocol.id_text(PEER_ID)))
+ self.win.arrives(c, protocol.accept_msg(c.owner.route))
+ self.win.arrives(c, protocol.switch_v6(c.owner.route, OTHER_ID, "left", 0.5))
+ self.acg.arrives(c, protocol.accept_msg(c.owner.route))
+
+ self.assertEqual(c.owner.on, protocol.id_text(OTHER_ID))
+ self.assertEqual(c._cycle_target(), protocol.id_text(FEDORA_ID))
+
+ def test_baseline_input_is_home_and_double_tap_goes_away(self):
+ self.double_tap()
+ self.assertTrue(self.controller.redirecting)
+
+ def test_double_tap_brings_input_home_after_the_log_sequence(self):
+ self.chain_to_acg()
+ with self.assertLogs(self.controller.logger, level="INFO") as said:
+ results = self.double_tap()
+ self.assertHome()
+ self.assertTrue(any("input returned to this Mac" in line for line in said.output), said.output)
+ self.assertEqual(results, [results[0], None, None, None] if results[0] is not None else [None] * 4)
+
+ def test_double_tap_while_receiving_too(self):
+ self.chain_to_acg()
+ self.controller.receiving = True
+ self.controller.send_peer_home = lambda: True
+ self.double_tap()
+ self.assertHome()
+
+ def test_redirecting_true_but_owner_home(self):
+ self.chain_to_acg()
+ self.controller.owner.on = None
+ self.controller.redirecting = True
+ self.double_tap()
+ settle(self.controller)
+ self.assertFalse(self.controller.redirecting)
+
+ def test_owner_on_but_redirecting_false_moves_on_rather_than_home_but_logs(self):
+ # Not reachable by the log's sequence (redirecting was logged True). A redirecting=False /
+ # owner.on=ACG disagreement reads the double tap as "go away", and logs it.
+ self.chain_to_acg()
+ self.controller.redirecting = False
+ with self.assertLogs(self.controller.logger, level="INFO") as said:
+ self.double_tap()
+ settle(self.controller)
+ self.assertTrue(any("move applied" in line for line in said.output), said.output)
+
+ def test_the_switch_chain_racing_the_double_tap_always_ends_home(self):
+ import threading
+ lost = 0
+ for _ in range(300):
+ self.setUp()
+ c = self.controller
+ c.set_redirecting(True, edge="left", offset=0.5, peer=protocol.id_text(OTHER_ID), reason="edge")
+ self.acg.arrives(c, protocol.accept_msg(c.owner.route))
+ self.acg.arrives(c, protocol.switch_v6(c.owner.route, PEER_ID, "left", 0.5))
+ self.win.arrives(c, protocol.accept_msg(c.owner.route))
+ route = c.owner.route
+
+ def step_3():
+ self.win.arrives(c, protocol.switch_v6(route, OTHER_ID, "left", 0.5))
+ self.acg.arrives(c, protocol.accept_msg(route + 1))
+
+ worker = threading.Thread(target=step_3, daemon=True)
+ worker.start()
+ self.double_tap()
+ worker.join(2)
+ settle(c)
+ self.assertEqual(c.redirecting, c.owner.away)
+ lost += c.redirecting
+ self.assertEqual(lost, 0)
+
+ def test_a_synced_settings_without_the_shortcut_method_swallows_it_silently(self):
+ self.chain_to_acg()
+ cfg = crossing_config(PAIRED_TOKEN, methods=["edge"])
+ cfg.trigger_key = "cmd_r"
+ cfg.trigger_style = "double_tap"
+ self.controller.apply_settings(cfg)
+ with self.assertLogs(self.controller.logger, level="DEBUG") as said:
+ self.controller.logger.debug("sentinel")
+ results = self.double_tap()
+ self.assertEqual(len(said.output), 1)
+ self.assertTrue(self.controller.redirecting)
+ self.assertEqual(results, [None] * 4)
+
+ def test_double_tap_arriving_while_step_3_is_mid_flight(self):
+ c = self.controller
+ c.set_redirecting(True, edge="left", offset=0.5, peer=protocol.id_text(OTHER_ID), reason="edge")
+ self.acg.arrives(c, protocol.accept_msg(c.owner.route))
+ self.acg.arrives(c, protocol.switch_v6(c.owner.route, PEER_ID, "left", 0.5))
+ self.win.arrives(c, protocol.accept_msg(c.owner.route))
+ # Desk PC's switch is in: Loan laptop asked, its accept not yet back
+ self.win.arrives(c, protocol.switch_v6(c.owner.route, OTHER_ID, "left", 0.5))
+ self.assertIsNotNone(c.owner._wait)
+ self.double_tap()
+ settle(c)
+ self.assertFalse(c.redirecting)
+ self.assertIsNone(c.owner.on)
+ # the late accept must not take input back
+ self.acg.arrives(c, protocol.accept_msg(c.owner.route))
+ self.assertFalse(c.redirecting)
+
+ def test_double_tap_with_a_stale_modifier_bookkeeping(self):
+ self.chain_to_acg()
+ self.controller.translator.modifier_down.add(CMD_R)
+ self.double_tap()
+ self.assertHome()
+
+ def test_double_tap_after_a_pause_since_the_last_move(self):
+ self.chain_to_acg()
+ self.clock.value += 30
+ self.double_tap()
+ self.assertHome()
+
+ def test_second_press_slower_than_the_threshold_does_nothing(self):
+ self.chain_to_acg()
+ self.double_tap(gap=0.5)
+ self.assertTrue(self.controller.redirecting)
+
+
+class HoldChainTests(Chain):
+ style = "hold"
+
+ def test_hold_from_the_chain_comes_home_on_release(self):
+ self.chain_to_acg()
+ down = self.tap(FakeQuartz.kCGEventFlagsChanged, self.key(True))
+ self.assertIsNone(down)
+ # hold: key down from redirecting asks for a take of the hold target
+ settle(self.controller)
+ self.tap(FakeQuartz.kCGEventFlagsChanged, self.key(False))
+ settle(self.controller)
+ self.assertFalse(self.controller.redirecting)
+ self.assertIsNone(self.controller.owner.on)
+
+
+class ArrivalHomeGrace(Chain):
+ """The same chain ending as rc14's did at 19:50:51: a switch home at the Mac's bottom edge."""
+
+ def test_a_switch_home_at_an_edge_starts_the_grace_and_a_rebuild_keeps_it(self):
+ self.chain_to_acg()
+ c = self.controller
+ self.acg.arrives(c, protocol.switch_v6(c.owner.route, bytes(c.identity()["id"]), "bottom", 0.0))
+ settle(c)
+ self.assertFalse(c.redirecting)
+ self.assertIsNotNone(c.crossing._grace_at, "no grace after landing home")
+ c.zones_changed()
+ self.assertIsNotNone(c.crossing._grace_at, "a rebuilt engine dropped the grace")
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/mac_app/tests/test_sidebar_response.py b/mac_app/tests/test_sidebar_response.py
new file mode 100644
index 0000000..bba93b8
--- /dev/null
+++ b/mac_app/tests/test_sidebar_response.py
@@ -0,0 +1,181 @@
+"""The persistent sidebar reports only a fresh response time for its connected peer."""
+
+import sys
+import unittest
+from pathlib import Path
+from threading import RLock
+from types import SimpleNamespace
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+import AppKit
+import bridge
+import kvm_bridge_app
+import widgets
+from core import protocol
+
+
+class SidebarResponseTests(unittest.TestCase):
+ @classmethod
+ def setUpClass(cls):
+ AppKit.NSApplication.sharedApplication()
+
+ def test_response_time_has_pending_fresh_and_disconnected_states(self):
+ sidebar = widgets.Sidebar([("home", "Home", "")], lambda _key: None)
+ self.assertTrue(sidebar.response_time.view.isHidden())
+
+ sidebar.set_link(type("State", (), {"led": "signal", "blink": False, "word": "Connected", "tone": "ink"})(),
+ "Windows PC", response_time_ms=None, connected=True)
+ self.assertEqual(sidebar.response_time.text, "Response time: —")
+ self.assertEqual(sidebar.header.accessibilityLabel(), "Connected, Windows PC, Response time: no fresh measurement")
+
+ sidebar.set_link(type("State", (), {"led": "signal", "blink": False, "word": "Connected", "tone": "ink"})(),
+ "Windows PC", response_time_ms=24, connected=True)
+ self.assertEqual(sidebar.response_time.text, "Response time: 24 ms")
+ self.assertEqual(sidebar.header.accessibilityLabel(), "Connected, Windows PC, Response time: 24 ms")
+
+ sidebar.set_link(type("State", (), {"led": "ink_3", "blink": False, "word": "Disconnected", "tone": "ink_3"})(),
+ "Windows PC", response_time_ms=24, connected=False)
+ self.assertEqual(sidebar.response_time.text, "")
+ self.assertTrue(sidebar.response_time.view.isHidden())
+
+ def test_mac_identity_advertises_ping_response_measurements(self):
+ self.assertIn("ping_rtt", bridge.CAPABILITIES)
+
+ def test_compact_sidebar_keeps_the_response_value_and_unit_visible(self):
+ sidebar = widgets.Sidebar([("home", "Home", "")], lambda _key: None)
+ state = SimpleNamespace(led="signal", blink=False, word="Connected", tone="ink")
+ sidebar.set_link(state, "Windows PC", response_time_ms=3000, connected=True)
+ sidebar.set_collapsed(True)
+ sidebar.view.widthAnchor().constraintEqualToConstant_(56).setActive_(True)
+ sidebar.view.setFrameSize_(AppKit.NSMakeSize(56, 500))
+ sidebar.view.layoutSubtreeIfNeeded()
+ view = sidebar.response_rail.view
+ self.assertFalse(view.isHiddenOrHasHiddenAncestor())
+ self.assertEqual(sidebar.response_rail.text, "3000 ms")
+ self.assertGreaterEqual(view.frame().size.width, view.cell().cellSize().width)
+ bounds = view.convertRect_toView_(view.bounds(), sidebar.view)
+ text_width = view.attributedStringValue().size().width
+ text_left = bounds.origin.x + (bounds.size.width - text_width) / 2
+ self.assertGreaterEqual(text_left, 0)
+ self.assertLessEqual(text_left + text_width, 56)
+ sidebar.set_link(state, "Windows PC", connected=False)
+ self.assertTrue(view.isHidden())
+
+ def test_full_response_value_wraps_inside_supported_sidebar_widths(self):
+ sidebar = widgets.Sidebar([("home", "Home", "")], lambda _key: None)
+ sidebar.set_collapsed(False)
+ sidebar.set_link(type("State", (), {"led": "signal", "blink": False, "word": "Connected", "tone": "ink"})(),
+ "Windows PC", response_time_ms=3000, connected=True)
+ for width in (150, 180):
+ sidebar.view.setFrameSize_(AppKit.NSMakeSize(width, 500))
+ sidebar.view.layoutSubtreeIfNeeded()
+ self.assertEqual(sidebar.response_time.text, "Response time: 3000 ms")
+ self.assertTrue(sidebar.response_time.wrap)
+ response_view = sidebar.response_time.view
+ bounds = response_view.frame().size
+ self.assertGreater(bounds.width, 0)
+ needed = response_view.cell().cellSizeForBounds_(AppKit.NSMakeRect(0, 0, bounds.width, 500)).height
+ self.assertGreaterEqual(bounds.height, needed)
+
+ def test_active_peer_wins_and_outgoing_sample_is_preferred(self):
+ outgoing_peer, incoming_peer = protocol.id_text(b"o" * 16), b"i" * 16
+ outgoing_link = SimpleNamespace(live=lambda: True, response_time_ms=18)
+ controller = SimpleNamespace(
+ owner=SimpleNamespace(on=outgoing_peer), _owner_lock=RLock(), _peers_up={outgoing_peer: outgoing_link},
+ _link_of=lambda peer: outgoing_link if peer == outgoing_peer else None,
+ _status_link=lambda: None,
+ _label=lambda wanted: "Outgoing" if wanted({"id": outgoing_peer}) else "Incoming",
+ )
+ server = SimpleNamespace(owner=incoming_peer, links=lambda: {incoming_peer},
+ response_time_ms=lambda _peer: 31)
+ window = SimpleNamespace(controller=controller, windows_input=SimpleNamespace(server=server))
+
+ self.assertEqual(kvm_bridge_app.ControlWindow._header_response_time(window), ("Outgoing", 18, True))
+
+ def test_receive_only_peer_uses_its_incoming_measurement(self):
+ incoming_peer = b"i" * 16
+ controller = SimpleNamespace(
+ owner=SimpleNamespace(on=None), _owner_lock=RLock(), _peers_up={}, _link_of=lambda _peer: None,
+ _status_link=lambda: None, _label=lambda _wanted: "Incoming",
+ )
+ server = SimpleNamespace(owner=incoming_peer, links=lambda: {incoming_peer},
+ response_time_ms=lambda peer: 42 if peer == incoming_peer else None)
+ window = SimpleNamespace(controller=controller, windows_input=SimpleNamespace(server=server))
+
+ self.assertEqual(kvm_bridge_app.ControlWindow._header_response_time(window), ("Incoming", 42, True))
+
+ def test_incoming_measurement_fills_a_stale_outgoing_sample_for_the_same_peer(self):
+ ident = b"p" * 16
+ peer = protocol.id_text(ident)
+ outgoing = SimpleNamespace(live=lambda: True, response_time_ms=None)
+ controller = SimpleNamespace(
+ owner=SimpleNamespace(on=peer), _owner_lock=RLock(), _peers_up={peer: outgoing},
+ _link_of=lambda candidate: outgoing if candidate == peer else None,
+ _status_link=lambda: outgoing,
+ _label=lambda wanted: "Windows PC" if wanted({"id": peer}) else None,
+ )
+ server = SimpleNamespace(owner=ident, links=lambda: {ident},
+ response_time_ms=lambda candidate: 37 if candidate == ident else None)
+ window = SimpleNamespace(controller=controller, windows_input=SimpleNamespace(server=server))
+
+ self.assertEqual(kvm_bridge_app.ControlWindow._header_response_time(window), ("Windows PC", 37, True))
+
+ def test_idle_text_outgoing_link_matches_bytes_incoming_measurement(self):
+ ident = b"p" * 16
+ peer = protocol.id_text(ident)
+ outgoing = SimpleNamespace(peer_id=peer, live=lambda: True, response_time_ms=None)
+ controller = SimpleNamespace(
+ owner=SimpleNamespace(on=None), _owner_lock=RLock(), _peers_up={peer: outgoing},
+ _link_of=lambda candidate: outgoing if candidate == peer else None,
+ _status_link=lambda: outgoing,
+ _label=lambda wanted: "Windows PC" if wanted({"id": peer}) else None,
+ )
+ server = SimpleNamespace(owner=None, links=lambda: {ident},
+ response_time_ms=lambda candidate: 37 if candidate == ident else None)
+ window = SimpleNamespace(controller=controller, windows_input=SimpleNamespace(server=server))
+
+ self.assertEqual(kvm_bridge_app.ControlWindow._header_response_time(window), ("Windows PC", 37, True))
+
+ def test_idle_status_link_uses_its_string_peer_id(self):
+ peer = protocol.id_text(b"o" * 16)
+ link = SimpleNamespace(peer_id=peer, live=lambda: True, response_time_ms=27)
+ controller = SimpleNamespace(
+ owner=SimpleNamespace(on=None), _owner_lock=RLock(), _peers_up={peer: link},
+ _link_of=lambda candidate: link if candidate == peer else None,
+ _status_link=lambda: link,
+ _label=lambda wanted: "Windows PC" if wanted({"id": peer}) else None,
+ )
+ window = SimpleNamespace(controller=controller, windows_input=None)
+
+ self.assertEqual(kvm_bridge_app.ControlWindow._header_response_time(window), ("Windows PC", 27, True))
+
+ def test_stale_status_link_falls_back_to_a_live_peer(self):
+ stale_peer, live_peer = protocol.id_text(b"s" * 16), protocol.id_text(b"l" * 16)
+ stale = SimpleNamespace(peer_id=stale_peer, live=lambda: False)
+ live = SimpleNamespace(peer_id=live_peer, live=lambda: True, response_time_ms=34)
+ controller = SimpleNamespace(
+ owner=SimpleNamespace(on=None), _owner_lock=RLock(), _peers_up={live_peer: live},
+ _link_of=lambda peer: live if peer == live_peer else None,
+ _status_link=lambda: stale,
+ _label=lambda wanted: "Live PC" if wanted({"id": live_peer}) else None,
+ )
+ window = SimpleNamespace(controller=controller, windows_input=None)
+
+ self.assertEqual(kvm_bridge_app.ControlWindow._header_response_time(window), ("Live PC", 34, True))
+
+ def test_stale_status_link_without_other_live_peer_is_disconnected(self):
+ stale_peer = protocol.id_text(b"s" * 16)
+ stale = SimpleNamespace(peer_id=stale_peer, live=lambda: False)
+ controller = SimpleNamespace(
+ owner=SimpleNamespace(on=None), _owner_lock=RLock(), _peers_up={},
+ _link_of=lambda _peer: None, _status_link=lambda: stale,
+ _label=lambda _wanted: None,
+ )
+ window = SimpleNamespace(controller=controller, windows_input=None)
+
+ self.assertEqual(kvm_bridge_app.ControlWindow._header_response_time(window), ("—", None, False))
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/mac_app/tests/test_single_instance.py b/mac_app/tests/test_single_instance.py
new file mode 100644
index 0000000..d28290a
--- /dev/null
+++ b/mac_app/tests/test_single_instance.py
@@ -0,0 +1,26 @@
+import threading
+import unittest
+from pathlib import Path
+from tempfile import TemporaryDirectory
+
+from instance_signal import InstanceSignalServer, request_running_instance
+
+
+class SingleInstanceTests(unittest.TestCase):
+ def test_second_launch_signals_the_running_instance(self):
+ with TemporaryDirectory(dir=Path(__file__).resolve().parents[1]) as directory:
+ path = Path(directory) / "s"
+ activated = threading.Event()
+ server = InstanceSignalServer(path, activated.set)
+ thread = threading.Thread(target=server.serve_forever, daemon=True)
+ thread.start()
+ try:
+ self.assertTrue(request_running_instance(path, timeout=1))
+ self.assertTrue(activated.wait(1))
+ finally:
+ server.close()
+ thread.join(timeout=1)
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/mac_app/tests/test_titlebar_events.py b/mac_app/tests/test_titlebar_events.py
index d544c70..31c731a 100644
--- a/mac_app/tests/test_titlebar_events.py
+++ b/mac_app/tests/test_titlebar_events.py
@@ -2,7 +2,7 @@ import unittest
from unittest import mock
from mac_app.tests.test_window_geometry import offscreen_control_window, kvm_bridge_app
-from mac_app.tests.test_window_resize import settle
+from mac_app.tests.design_offscreen import settle
AppKit = kvm_bridge_app.AppKit
@@ -77,7 +77,7 @@ class TitlebarEventTests(unittest.TestCase):
point = (80, content_height - 30)
hit = window.contentView().superview().hitTest_(point)
print(f"{region} double-click hit={type(hit).__name__}, point={point}", flush=True)
- # No default is changed on Toby's Mac.
+ # No default is changed on the test Mac.
with mock.patch.object(kvm_bridge_app, "titlebar_action", return_value="fill"):
double_click(window, point)
print(f"{region} frame={window.frame()}", flush=True)
diff --git a/mac_app/tests/test_wake.py b/mac_app/tests/test_wake.py
index 1f0db2b..e6870e8 100644
--- a/mac_app/tests/test_wake.py
+++ b/mac_app/tests/test_wake.py
@@ -110,6 +110,15 @@ class WakingControllerTests(unittest.TestCase):
if thread.name == "wake":
thread.join(timeout=5)
+ def test_redirecting_for_an_edge_forwards_display_and_side(self):
+ with unittest.mock.patch.object(self.controller, "_awake", return_value=True), \
+ unittest.mock.patch.object(wake.KVMController, "set_redirecting", return_value=True) as base:
+ self.controller.set_redirecting(True, edge="right", offset=0.5, peer=PEER, reason="edge",
+ display="0", side="right")
+ base.assert_called_once_with(
+ True, "right", 0.5, came_home=True, peer=PEER, reason="edge", display="0", side="right"
+ )
+
def test_a_pc_that_answered_and_refused_is_not_woken(self):
for kind in REFUSED_KINDS:
with self.subTest(kind=kind):
diff --git a/mac_app/tests/test_way_home.py b/mac_app/tests/test_way_home.py
index 3dec684..1545915 100644
--- a/mac_app/tests/test_way_home.py
+++ b/mac_app/tests/test_way_home.py
@@ -17,7 +17,7 @@ sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspa
import settings_store
from bridge import KVMController
from bridge_fakes import PAIRED_TOKEN, FakeClipboard, FakeQuartz, quiet_logger
-from core import protocol, receiver, return_edge
+from core import protocol, receiver, return_edge, ways
from core.tests import responder_harness as harness
from windows_input import WindowsInput
@@ -145,6 +145,11 @@ class ChangesReachTheArmedZonesTests(unittest.TestCase):
"""A real responder with a peer driving this Mac: the zones armed for it follow the settings."""
def setUp(self):
+ # These tests push the moment input lands; the arrival grace is test_arrival_grace's
+ # subject, not theirs.
+ grace = mock.patch.object(return_edge, "ARRIVAL_GRACE_SECONDS", 0.0)
+ grace.start()
+ self.addCleanup(grace.stop)
folder = Path(tempfile.mkdtemp())
self.store = settings_store.SettingsStore(folder / "settings.json")
cfg = self.store.load()
@@ -187,6 +192,11 @@ class ChangesReachTheArmedZonesTests(unittest.TestCase):
settings = self.store.current()
settings["peers"][0].update(id=PEER_TEXT, side="right", send=False, from_1_4=False)
settings["zones"] = zones(methods, parts, corner)
+ settings["peers"][0]["ways"] = {
+ "edge": bool(set(methods) & {"edge", "part"}),
+ "thirds": list(ways.PARTS) if "edge" in methods else list(parts),
+ "corner": "corner" in methods, "corner_at": corner, "notch": "notch" in methods,
+ }
self.store.save_settings(settings)
def armed(self):
diff --git a/mac_app/tests/test_wheel_lines.py b/mac_app/tests/test_wheel_lines.py
new file mode 100644
index 0000000..cb6d595
--- /dev/null
+++ b/mac_app/tests/test_wheel_lines.py
@@ -0,0 +1,74 @@
+import os
+import sys
+import types
+import unittest
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+
+import input_injector_mac as injector
+from core import protocol, receiver
+
+
+class FakeQuartz:
+ kCGEventSourceUserData = 42
+ kCGScrollEventUnitLine = 1
+ kCGScrollEventUnitPixel = 0
+ kCGHIDEventTap = 0
+
+ def __init__(self):
+ self.posted = []
+
+ def CGEventCreateScrollWheelEvent(self, source, unit, count, wheel_y, wheel_x):
+ return types.SimpleNamespace(unit=unit, wheel_y=wheel_y, wheel_x=wheel_x)
+
+ def CGEventSetIntegerValueField(self, event, field, value):
+ pass
+
+ def CGEventSetFlags(self, event, flags):
+ event.flags = flags
+
+ def CGEventPost(self, tap, event):
+ self.posted.append(event)
+
+
+class WheelLinesTests(unittest.TestCase):
+ def setUp(self):
+ self.quartz = FakeQuartz()
+ self._saved_quartz = injector.Quartz
+ injector.Quartz = self.quartz
+ injector.release_all()
+ injector.reset_scroll_remainders()
+ self.responder = receiver.LinkResponder.__new__(receiver.LinkResponder)
+ self.responder._injector = injector
+ self.responder.input_scale = None
+ self.link = receiver._Link(None, None, b"p", b"k", "host", "PC", [], b"o", [], True, "windows")
+
+ def tearDown(self):
+ injector.release_all()
+ injector.reset_scroll_remainders()
+ injector.Quartz = self._saved_quartz
+
+ def scroll(self, dy=1, dx=0, mode="line"):
+ self.responder._inject_locked(self.link, {
+ "type": protocol.MSG_SCROLL, "dy": dy, "dx": dx, "mode": mode,
+ })
+ return self.quartz.posted[-1]
+
+ def test_pc_line_notch_posts_three_lines_and_mac_notch_posts_one(self):
+ self.assertEqual(self.scroll().wheel_y, 3)
+ self.link.peer_platform = "macos"
+ self.assertEqual(self.scroll().wheel_y, 1)
+ self.link.peer_platform = "ios"
+ self.assertEqual(self.scroll().wheel_y, 1)
+
+ def test_scroll_speed_multiplier_applies_to_pc_line_notches(self):
+ self.responder.input_scale = receiver.InputScale(scroll=2.0)
+ self.assertEqual(self.scroll().wheel_y, 6)
+
+ def test_pixel_mode_keeps_its_pixel_amount_for_a_pc(self):
+ event = self.scroll(dy=2, mode="pixel")
+ self.assertEqual((event.unit, event.wheel_y), (FakeQuartz.kCGScrollEventUnitPixel, 2))
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/mac_app/tests/test_widgets.py b/mac_app/tests/test_widgets.py
index 9b851af..03858b1 100644
--- a/mac_app/tests/test_widgets.py
+++ b/mac_app/tests/test_widgets.py
@@ -17,6 +17,68 @@ import widgets
class WidthTests(unittest.TestCase):
+ def test_idle_design_lock_does_not_redraw_unchanged_choices(self):
+ import objc
+
+ for choice in (widgets.ChoiceTiles([("one", "One", "Detail", widgets.box())]),
+ widgets.Swatches([("one", "One", ["#112233", "#445566"])])):
+ choice.value = "one"
+ with mock.patch.object(choice.ring, "show", wraps=choice.ring.show) as show:
+ for _ in range(500):
+ with objc.autorelease_pool():
+ choice.set_enabled(True)
+ self.assertEqual(show.call_count, 0)
+ choice.set_enabled(False)
+ self.assertEqual(show.call_count, 1)
+ choice.set_enabled(False)
+ self.assertEqual(show.call_count, 1)
+ choice.set_enabled(True)
+ self.assertEqual(show.call_count, 2)
+
+ def test_menu_choices_update_without_replacing_the_popup(self):
+ choice = widgets.MenuChoice([("", "None"), ("peer", "Peer")])
+ popup = choice.popup
+ item = choice.items[1][1]
+ choice.value = "peer"
+ choice.set_choices([("", "None"), ("peer", "Peer")])
+ self.assertEqual(choice.items[1][1], item)
+ choice.set_choices([("", "None"), ("peer", "Renamed"), ("other", "Other")])
+ self.assertIs(choice.popup, popup)
+ self.assertEqual(choice.value, "peer")
+ self.assertEqual(choice.popup.titleOfSelectedItem(), "Renamed")
+ choice.set_choices([("", "None")])
+ self.assertEqual(choice.value, "")
+
+ def test_replaced_menu_choices_release_their_native_targets(self):
+ import objc
+
+ host = widgets.stack()
+ owners = []
+ for _ in range(500):
+ with objc.autorelease_pool():
+ for view in host.arrangedSubviews():
+ host.removeArrangedSubview_(view)
+ view.removeFromSuperview()
+ choice = widgets.MenuChoice([("", "None"), ("peer", "Peer")])
+ owners.append(weakref.ref(choice))
+ widgets.add(host, choice.view, full_width=False)
+ gc.collect()
+ self.assertEqual(sum(owner() is not None for owner in owners), 1)
+
+ def test_menu_choice_action_still_reaches_its_live_owner(self):
+ calls = []
+ choice = widgets.MenuChoice([("", "None"), ("peer", "Peer")], calls.append)
+ choice.value = "peer"
+ choice.target.fire_(choice.popup)
+ self.assertEqual(calls, ["peer"])
+ target = choice.target
+ owner = weakref.ref(choice)
+ del choice
+ gc.collect()
+ self.assertIsNone(owner())
+ target.fire_(None)
+ self.assertEqual(calls, ["peer"])
+
def test_figure_renders_its_unit_once(self):
figure = widgets.Figure('120', theme.TYPE['numeral'], 'px')
self.assertEqual(figure.view.attributedStringValue().string(), '120 px')
diff --git a/mac_app/tests/test_window_geometry.py b/mac_app/tests/test_window_geometry.py
index 7f2f9cb..e63ddbd 100644
--- a/mac_app/tests/test_window_geometry.py
+++ b/mac_app/tests/test_window_geometry.py
@@ -24,16 +24,21 @@ def offscreen_control_window():
store.lock = threading.RLock()
store._handed_token = token
store._cache = store._complete({**store._fresh(), "peers": []})
+ store.save = mock.Mock(return_value=cfg)
logger = logging.getLogger("test-window-geometry")
from wake import WakingController
controller = WakingController(cfg, logger=logger)
+ controller.start_input_capture = lambda: None
with mock.patch.object(kvm_bridge_app, "accessibility_granted", return_value=True), mock.patch.object(
kvm_bridge_app, "input_monitoring_granted", return_value=True
):
- return kvm_bridge_app.ControlWindow.alloc().initWithController_settingsStore_logger_(
+ window = kvm_bridge_app.ControlWindow.alloc().initWithController_settingsStore_logger_(
controller, store, logger
)
+ # Layout previews have no backing path, so the debounced save must stay inert.
+ window._apply_settings = lambda: None
+ return window
class WindowGeometryTests(unittest.TestCase):
@@ -63,7 +68,8 @@ class WindowGeometryTests(unittest.TestCase):
window = offscreen_control_window()
# The window takes its largest size from every constraint above WindowSizeStayPut (500),
# so one page's rigid row or reading-width note used to cap it at 773 to 837 pt.
- screen_width = AppKit.NSScreen.mainScreen().visibleFrame().size.width
+ screen = AppKit.NSScreen.mainScreen()
+ screen_width = screen.visibleFrame().size.width if screen else 1728
window.window.setFrame_display_(((100000, 100000), (screen_width, 900)), False)
from Foundation import NSDate, NSRunLoop
@@ -99,25 +105,31 @@ class WindowGeometryTests(unittest.TestCase):
right = page.frame().size.width - left - body.frame().size.width
self.assertAlmostEqual(left, right, delta=1)
- def test_crossing_pair_flips_without_reparenting_at_wide_and_narrow_sizes(self):
- AppKit = kvm_bridge_app.AppKit
- window = offscreen_control_window()
- window._select_page("crossing")
- horizontal = AppKit.NSUserInterfaceLayoutOrientationHorizontal
- vertical = AppKit.NSUserInterfaceLayoutOrientationVertical
-
- for width, height in ((1366, 900), (1920, 900), (2560, 900), (1440, 3440)):
- with self.subTest(window=(width, height)):
- pair = self._assert_side_by_side_layout(window, "ways_pair", width, height, horizontal)
- self.assertEqual(pair.needed(), 632)
- self.assertEqual(pair.gap, 24)
- self.assertEqual(pair.view.spacing(), 24)
- self.assertGreaterEqual(pair.first.frame().size.width, 254)
- self.assertGreaterEqual(pair.second.frame().size.width, 354)
-
- with self.subTest(window=(700, 900)):
- pair = self._assert_side_by_side_layout(window, "ways_pair", 700, 900, vertical)
- self.assertLess(pair.bounds().size.width, pair.needed())
+ def test_ledger_uses_blocks_under_620_and_columns_above(self):
+ from mac_app.tests.test_crossing_page_machines import Page, BEE, token
+ fixture = Page()
+ fixture.setUp()
+ try:
+ window = fixture.build([(BEE, token(100), "Bee", {"side": "left"})],
+ [{"peer": BEE, "kind": "edge"}])
+ window._select_page("crossing")
+ for width in (640, 900, 1366, 1920):
+ window.window.setFrame_display_(((100000, 100000), (width, 900)), False)
+ window.window.contentView().layoutSubtreeIfNeeded()
+ ledger = window.crossing_ledger
+ ledger.reflow()
+ row = ledger.rows[BEE]
+ narrow = ledger.bounds().size.width < 620
+ self.assertEqual(ledger.headers[0].view.isHidden(), narrow)
+ machine, edge = row.cells["machine"].frame(), row.cells["edge"].frame()
+ self.assertGreater(edge.origin.y, machine.origin.y) if narrow else self.assertEqual(
+ edge.origin.y, machine.origin.y)
+ for cell in row.cells.values():
+ self.assertLessEqual(cell.frame().origin.x + cell.frame().size.width,
+ ledger.bounds().size.width + 1)
+ self.assertFalse(window.pages["crossing"].hasHorizontalScroller())
+ finally:
+ fixture.doCleanups()
def test_design_controls_lead_full_width_responsive_tile_groups(self):
window = offscreen_control_window()
@@ -211,9 +223,9 @@ class WindowGeometryTests(unittest.TestCase):
from Foundation import NSDate, NSRunLoop
window = offscreen_control_window()
- state = SimpleNamespace(word="Connected", led="signal", blink=False, tone="signal", detail="")
+ state = SimpleNamespace(key="connected", word="Connected", led="signal", blink=False, tone="signal", detail="")
row = SimpleNamespace(label="Windows PC", state=state, token="t1", platform="Windows", address="192.0.2.20",
- in_use=True, drives=True, driven=True, phone=False)
+ in_use=True, drives=True, driven=True, phone=False, left_out=False)
window.panel.removing = "t1"
window.panel._build_rows([row])
window.window.setFrame_display_(((100000, 100000), (1728, 900)), False)
diff --git a/mac_app/tests/test_window_resize.py b/mac_app/tests/test_window_resize.py
index 04a7e91..20e8bba 100644
--- a/mac_app/tests/test_window_resize.py
+++ b/mac_app/tests/test_window_resize.py
@@ -1,7 +1,7 @@
import unittest
from unittest import mock
-from mac_app.tests.test_window_geometry import offscreen_control_window, kvm_bridge_app
+from mac_app.tests.design_offscreen import offscreen_control_window, kvm_bridge_app, settle
AppKit = kvm_bridge_app.AppKit
widgets = kvm_bridge_app.widgets
@@ -26,13 +26,6 @@ def measured_stack(vertical=True, spacing=10.0):
return view
-def settle(window):
- from Foundation import NSDate, NSRunLoop
- window.contentView().layoutSubtreeIfNeeded()
- NSRunLoop.currentRunLoop().runUntilDate_(NSDate.dateWithTimeIntervalSinceNow_(0.01))
- window.contentView().layoutSubtreeIfNeeded()
-
-
class WindowResizeTests(unittest.TestCase):
def test_page_breakpoint_jitter_keeps_the_current_typography(self):
control = offscreen_control_window()
@@ -81,7 +74,7 @@ class WindowResizeTests(unittest.TestCase):
control = offscreen_control_window()
control._select_page("crossing")
window = control.window
- previous = control.ways_pair.orientation()
+ previous = tuple(pair.orientation() for pair in control.side_by_side)
flips = 0
ambiguous = 0
MeasuredStack.passes = 0
@@ -89,12 +82,12 @@ class WindowResizeTests(unittest.TestCase):
for index, width in enumerate(widths):
window.setFrame_display_(((100000 + index, 100000 + index), (width, 800)), False)
settle(window)
- orientation = control.ways_pair.orientation()
+ orientation = tuple(pair.orientation() for pair in control.side_by_side)
flips += orientation != previous
previous = orientation
self.assertAlmostEqual(window.frame().size.width, width, delta=1)
views = (control.pages["crossing"].documentView().subviews()[0],
- control.ways_pair.view, control.ways_pair.first, control.ways_pair.second)
+ *(view for pair in control.side_by_side for view in (pair.view, pair.first, pair.second)))
ambiguous += sum(view.hasAmbiguousLayout() for view in views)
resize_passes = MeasuredStack.passes
MeasuredStack.passes = 0
diff --git a/mac_app/tests/two_machines.py b/mac_app/tests/two_machines.py
index 890b5cb..afd89c5 100644
--- a/mac_app/tests/two_machines.py
+++ b/mac_app/tests/two_machines.py
@@ -28,14 +28,14 @@ from unittest import mock
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
import windows_input
-from bridge import KVMController
+from bridge import KVMController, links_from_store
import bridge_fakes
from bridge_fakes import PAIRED_TOKEN, FakeClock, FakeQuartz, crossing_config, quiet_logger
from core import protocol
from core.return_edge import OPPOSITE
from core.return_edge import Rect
from core.tests.responder_harness import HERE, FakeDesktop, FakeInjector, Initiator, Machine, entry
-from settings_store import SettingsStore
+from settings_store import SettingsStore, config_to_raw
MAC_BOUNDS = (0, 0, 1728, 1117)
PC_MONITORS = [Rect(0, 0, 1920, 1080)]
@@ -100,17 +100,23 @@ class Duo:
self.pc_injector = self.pc_responder.injector
settings = copy.deepcopy(self.store.current())
+ settings["port"] = self.mac_port
settings["peers"] = [entry(HERE, "PC", platform="windows", token=PAIRED_TOKEN, host="127.0.0.1",
port=self.pc_responder.port, side=self.side, side_set_at=side_stamp, side_by=side_by,
allow_drive=allow_drive)]
settings["zones"] = self._named(mac_zones if mac_zones is not None else self._zones_from(cfg.crossing))
self.store.save_settings(settings)
+ cfg.port = self.pc_responder.port
+ cfg.allow_windows_to_drive = allow_drive
+ cfg = self.store.save(config_to_raw(cfg))
# The one pasteboard the controller and the Mac's responder share, as on a real Mac.
self.clipboard = bridge_fakes.FakeClipboard("on the Mac")
+ # Config's port belongs to the peer; the identity advertises this Mac's stored listener.
+ book, identity = links_from_store(self.store, "1.5.2")
self.mac = KVMController(
cfg, logger=quiet_logger(), quartz=FakeQuartz, clock=self.clock, desktop_bounds=lambda: self.mac_bounds,
- book=self.store.book(), socket_factory=socket_factory, clipboard=self.clipboard,
+ book=book, socket_factory=socket_factory, clipboard=self.clipboard, identity=identity,
)
self.mac.on_crossing = lambda kind, step: self.feedback.append((kind, step))
self.mac.on_user_alert = lambda title, message: self.alerts.append(message)
diff --git a/mac_app/wake.py b/mac_app/wake.py
index 0856fd1..d619765 100644
--- a/mac_app/wake.py
+++ b/mac_app/wake.py
@@ -92,7 +92,8 @@ class WakingController(KVMController):
peer = self._in_question()
return bool(self._wake_address(peer)[0]) and not self._awake(peer)
- def set_redirecting(self, value, edge=None, offset=None, came_home=True, peer=None):
+ def set_redirecting(self, value, edge=None, offset=None, came_home=True, peer=None, reason=None,
+ display=None, side=None):
target = peer or self._shortcut_peer()
# From home, or on from the machine input is on to another (a menu naming it): one asleep is woken.
leaving = not self.redirecting or (peer is not None and peer != self.owner.on)
@@ -100,7 +101,8 @@ class WakingController(KVMController):
and not self._refused(target)):
self.wake(target)
return False
- return super().set_redirecting(value, edge, offset, came_home=came_home, peer=peer)
+ return super().set_redirecting(value, edge, offset, came_home=came_home, peer=peer, reason=reason,
+ display=display, side=side)
def _refused(self, peer=None) -> bool:
"""A machine that answered and refused -- the pairing, or the protocol version -- is awake,
diff --git a/mac_app/widgets.py b/mac_app/widgets.py
index c4e4ea9..0ac5cb3 100644
--- a/mac_app/widgets.py
+++ b/mac_app/widgets.py
@@ -541,9 +541,11 @@ class Pressable(AppKit.NSView):
ring = None
ring_owner = None
selection_mark = None
+ selection_check = None
tile_content = None
ring_inset = -3.0
pointer_cursor = False
+ selection_size = 16
@objc.python_method
def set_tile_state(self, selected=None, hovered=None):
@@ -566,21 +568,36 @@ class Pressable(AppKit.NSView):
@objc.python_method
def add_selection_mark(self):
mark = Quartz.CAShapeLayer.layer()
- path = Quartz.CGPathCreateMutable()
- Quartz.CGPathMoveToPoint(path, None, 1, 6)
- Quartz.CGPathAddLineToPoint(path, None, 4, 3)
- Quartz.CGPathAddLineToPoint(path, None, 10, 10)
- mark.setPath_(path)
- mark.setFillColor_(None)
- mark.setLineWidth_(2)
+ mark.setPath_(Quartz.CGPathCreateWithEllipseInRect(((0, 0), (self.selection_size, self.selection_size)), None))
mark.setHidden_(True)
self.layer().addSublayer_(mark)
self.selection_mark = mark
+ check = Quartz.CAShapeLayer.layer()
+ path = Quartz.CGPathCreateMutable()
+ # The tile's layer is unflipped: y runs up, so the tick's foot is its lowest y.
+ Quartz.CGPathMoveToPoint(path, None, 3.5, 8)
+ Quartz.CGPathAddLineToPoint(path, None, 6.5, 5.5)
+ Quartz.CGPathAddLineToPoint(path, None, 12.5, 12)
+ check.setPath_(path)
+ check.setFillColor_(None)
+ check.setLineWidth_(2)
+ check.setLineCap_(Quartz.kCALineCapRound)
+ check.setLineJoin_(Quartz.kCALineJoinRound)
+ check.setHidden_(True)
+ self.layer().addSublayer_(check)
+ self.selection_check = check
@objc.python_method
def show_selection_mark(self, selected):
self.selection_mark.setHidden_(not selected)
- theme.tint(self.selection_mark, stroke='signal')
+ self.selection_check.setHidden_(not selected)
+ if selected:
+ # The preview and captions are subviews added after the mark, so their layers sit
+ # above it; zPosition would lift it on screen but not in renderInContext.
+ self.layer().addSublayer_(self.selection_mark)
+ self.layer().addSublayer_(self.selection_check)
+ theme.tint(self.selection_mark, fill='signal')
+ theme.tint(self.selection_check, stroke='ground')
self.setNeedsLayout_(True)
def acceptsFirstResponder(self):
@@ -634,14 +651,28 @@ class Pressable(AppKit.NSView):
objc.super(Pressable, self).layout()
content = getattr(self, 'tile_content', None)
if content is not None:
- content.arrange(self.bounds().size)
+ if hasattr(content, "preview"):
+ content.arrange(self.bounds().size, selected=not self.selection_mark.isHidden())
+ else:
+ content.arrange(self.bounds().size)
ring = getattr(self, "ring", None)
if ring is not None:
inset = getattr(self, "ring_inset", -3.0)
ring.setFrame_(AppKit.NSInsetRect(self.bounds(), inset, inset))
mark = getattr(self, 'selection_mark', None)
if mark is not None and not mark.isHidden():
- mark.setFrame_(((self.bounds().size.width - 18, self.bounds().size.height - 18), (12, 12)))
+ content = getattr(self, 'tile_content', None)
+ if content is not None and hasattr(content, "preview"):
+ name_frame = content.name.view.frame()
+ frame = ((8, name_frame.origin.y + (name_frame.size.height - self.selection_size) / 2),
+ (self.selection_size, self.selection_size))
+ else:
+ frame = ((self.bounds().size.width - 24, self.bounds().size.height - 24),
+ (self.selection_size, self.selection_size))
+ mark.setFrame_(frame)
+ self.selection_check.setFrame_(frame)
+ elif getattr(self, 'tile_content', None) is not None and hasattr(self.tile_content, "preview"):
+ self.tile_content.arrange(self.bounds().size, selected=False)
owner = getattr(self, "ring_owner", None)
if owner is not None:
owner.follow(self)
@@ -914,7 +945,9 @@ class FieldRow:
self.stacked = None
if caption is not None and not control.accessibilityLabel():
control.setAccessibilityLabel_(caption)
- selector = getattr(control, 'segmented_owner', None)
+ # Looked up once: a missing attribute on an AppKit view is a slow selector search, and a
+ # slider has none, so asking on every layout pass cost each live-resize frame 2 ms.
+ self.selector = selector = getattr(control, 'segmented_owner', None)
if selector is not None:
selector.set_cap({'Length': 240, 'Size': 240, 'This window': 252,
'Ticks at': 360, 'Style for': 240, 'Show at': 264}.get(caption, selector.cap))
@@ -922,9 +955,8 @@ class FieldRow:
def arrange(self, width):
stacked = self.caption is None or width < 528
- selector = getattr(self.control, 'segmented_owner', None)
- if selector is not None:
- selector.set_available_width(max(0, width - (0 if stacked else 196)))
+ if self.selector is not None:
+ self.selector.set_available_width(max(0, width - (0 if stacked else 196)))
if stacked == self.stacked:
return
self.stacked = stacked
@@ -1249,7 +1281,7 @@ class Segmented:
class MenuChoice:
"""Native menu keeps full machine names available without growing the column."""
def __init__(self, choices, on_change=None):
- self.choices = list(choices)
+ self.choices = []
self.on_change = on_change
self.view = box()
self.popup = _autolayout(AppKit.NSPopUpButton.alloc().initWithFrame_pullsDown_(((0, 0), (0, 0)), False))
@@ -1260,12 +1292,17 @@ class MenuChoice:
# Native popup frames extend beyond their alignment rect by seven points.
pin(self.popup, self.view, (0, 4, 0, 4))
self.items = []
- for value, title in choices:
- self.popup.addItemWithTitle_(title)
- item = self.popup.lastItem()
- item.setToolTip_(title)
- self.items.append((value, item))
- self.target = _Target.alloc().initWithCallback_(self._changed)
+ self.set_choices(choices)
+ # PyObjC's target holds Python attributes outside the cyclic GC graph. A bound method
+ # here keeps this picker, its popup and its target alive after removal from the stack.
+ owner = weakref.ref(self)
+
+ def changed(sender):
+ choice = owner()
+ if choice is not None:
+ choice._changed(sender)
+
+ self.target = _Target.alloc().initWithCallback_(changed)
self.popup.setTarget_(self.target)
self.popup.setAction_('fire:')
self.view.widthAnchor().constraintLessThanOrEqualToConstant_(320).setActive_(True)
@@ -1276,6 +1313,21 @@ class MenuChoice:
squeeze(self.view)
squeeze(self.popup)
+ def set_choices(self, choices):
+ choices = list(choices)
+ if choices == self.choices:
+ return
+ value = self.value if self.choices else ""
+ self.popup.removeAllItems()
+ self.choices = choices
+ self.items = []
+ for value_key, title in choices:
+ self.popup.addItemWithTitle_(title)
+ item = self.popup.lastItem()
+ item.setToolTip_(title)
+ self.items.append((value_key, item))
+ self.value = value
+
@property
def value(self):
return self.choices[self.popup.indexOfSelectedItem()][0]
@@ -1636,13 +1688,22 @@ class JumpKeyRecorder:
HINT = "Click, then press a key combination"
- def __init__(self, value="", on_change=None, on_arm=None):
+ def __init__(self, value="", on_change=None, on_arm=None, compact=False):
self.value = value or ""
self.on_change = on_change
self.on_arm = on_arm
self.monitor = None
+ self.compact = compact
self.view = pressable(self._clicked, "edge", radius=theme.RADIUS["keycap"])
self.view.setAccessibilityLabel_("Jump straight here key, " + self._title())
+ if compact:
+ self.key = Label("", theme.TYPE["small"], ink="ink_2", wrap=True)
+ self.hint = Label(self.HINT, theme.TYPE["small"], ink="ink_3", wrap=True)
+ for label in (self.key, self.hint):
+ label.view.setTranslatesAutoresizingMaskIntoConstraints_(True)
+ self.view.addSubview_(label.view)
+ self._show_title()
+ return
face = box("ground", radius=theme.RADIUS["keycap"] - 1)
self.view.addSubview_(face)
pin(face, self.view, (1, 1, 3, 1))
@@ -1658,6 +1719,15 @@ class JumpKeyRecorder:
def _show_title(self, ink=None):
has_value = bool(self.value)
+ if self.compact:
+ symbols = {"ctrl": "⌃", "alt": "⌥", "shift": "⇧", "cmd": "⌘"}
+ parts = self.value.split("+")
+ title = "".join(symbols.get(part, part) for part in parts[:-1]) + " " + key_title(parts[-1])
+ self.key.set(title.strip() if has_value else "Set a key", size=theme.TYPE["small"] if has_value else 12.5,
+ ink=ink or ("ink" if has_value else "ink_2"), mono=has_value)
+ self.hint.view.setHidden_(True)
+ paint(self.view, "well" if has_value else None, "edge" if has_value else None, radius=4)
+ return
self.key.set(
self._title(),
size=theme.TYPE["keycap"] if has_value else theme.TYPE["body"],
@@ -1683,6 +1753,9 @@ class JumpKeyRecorder:
self.key.set("Press a key combination…", size=theme.TYPE["body"], ink="signal", mono=False)
self.hint.set("Click again to cancel")
paint(self.view, "signal")
+ if self.compact:
+ self.hint.view.setHidden_(False)
+ paint(self.view, "well", "signal", radius=4)
self.monitor = AppKit.NSEvent.addLocalMonitorForEventsMatchingMask_handler_(
AppKit.NSEventMaskKeyDown | AppKit.NSEventMaskFlagsChanged, self._recorded
)
@@ -1693,6 +1766,11 @@ class JumpKeyRecorder:
if event.type() != AppKit.NSEventTypeKeyDown:
return event
flags = int(event.modifierFlags())
+ if int(event.keyCode()) == 53 and not flags & (
+ AppKit.NSEventModifierFlagControl | AppKit.NSEventModifierFlagOption |
+ AppKit.NSEventModifierFlagShift | AppKit.NSEventModifierFlagCommand):
+ self._stop()
+ return None
modifiers = []
for name, flag in (("ctrl", AppKit.NSEventModifierFlagControl), ("alt", AppKit.NSEventModifierFlagOption),
("shift", AppKit.NSEventModifierFlagShift), ("cmd", AppKit.NSEventModifierFlagCommand)):
@@ -1713,14 +1791,33 @@ class JumpKeyRecorder:
self._stop()
def _stop(self):
+ was_armed = self.monitor is not None
if self.monitor is not None:
AppKit.NSEvent.removeMonitor_(self.monitor)
self.monitor = None
- if self.on_arm is not None:
- self.on_arm(False)
self._show_title()
self.hint.set(self.HINT)
- paint(self.view, "edge")
+ if not self.compact:
+ paint(self.view, "edge")
+ if was_armed and self.on_arm is not None:
+ self.on_arm(False)
+
+ def arrange_compact(self, available):
+ padding = 6 if self.value or self.monitor is not None else 0
+ text = self.key.view.attributedStringValue()
+ width = min(available, math.ceil(text.size().width) + 2 * padding + 4)
+ if self.monitor is not None:
+ width = available
+ text_width = max(1, width - 2 * padding)
+ options = AppKit.NSStringDrawingUsesLineFragmentOrigin | AppKit.NSStringDrawingUsesFontLeading
+ height = max(24, math.ceil(text.boundingRectWithSize_options_((text_width, 1000), options).size.height) + 8)
+ self.key.view.setFrame_(((padding, 3), (text_width, height - 6)))
+ if self.monitor is not None:
+ hint_height = math.ceil(self.hint.view.attributedStringValue().boundingRectWithSize_options_(
+ (text_width, 1000), options).size.height) + 4
+ self.hint.view.setFrame_(((padding, height), (text_width, hint_height)))
+ height += hint_height + 6
+ return width, height
class IgnoredRecorder:
@@ -1963,11 +2060,14 @@ class Sidebar:
])
self.word = Label("", theme.SIDEBAR_WORD, 700, wrap=True)
self.peer = Label("", theme.TYPE["small"], mono=True, ink="ink_3")
+ self.response_time = Label("", theme.TYPE["small"], ink="ink_3", wrap=True)
+ self.response_time.view.setHidden_(True)
squeeze(self.peer.view)
words = stack(spacing=3)
self.link_words = words
add(words, self.word.view)
add(words, self.peer.view)
+ add(words, self.response_time.view)
line = stack(vertical=False, spacing=5)
line.setAlignment_(AppKit.NSLayoutAttributeTop)
line.addArrangedSubview_(slot)
@@ -1975,6 +2075,10 @@ class Sidebar:
link.addSubview_(line)
pin(line, link, (18, 12, 18, 14))
add(column, link)
+ self.response_rail = Label("", theme.TYPE["small"], ink="ink_3", align=AppKit.NSTextAlignmentCenter)
+ self.response_rail.view.setHidden_(True)
+ add(column, self.response_rail.view)
+ column.setCustomSpacing_afterView_(6, self.response_rail.view)
rule = add(column, hairline())
column.setCustomSpacing_afterView_(12, rule)
@@ -2089,6 +2193,7 @@ class Sidebar:
return
self.collapsed = collapsed
self.link_words.setHidden_(collapsed)
+ self.response_rail.view.setHidden_(not collapsed or not getattr(self, "_response_connected", False))
for (_name, _row, _icon, words, _bar, dot), inset, width, dot_inset in zip(
self.rows.values(), self.row_insets, self.row_widths, self.dot_insets):
words.view.setHidden_(collapsed)
@@ -2114,12 +2219,24 @@ class Sidebar:
self.select(key)
self.on_select(key)
- def set_link(self, state, peer):
+ def set_link(self, state, peer, response_time_ms=None, connected=False):
+ self._response_connected = connected
self.led.set(state.led, state.blink)
self.word.set(state.word, ink=state.tone)
self.peer.set(peer)
- self.header.setAccessibilityLabel_(f'{state.word}, {peer}')
- self.header.setToolTip_(f'{state.word}, {peer}')
+ if connected:
+ response = f"Response time: {response_time_ms} ms" if response_time_ms is not None else "Response time: —"
+ spoken_response = response if response_time_ms is not None else "Response time: no fresh measurement"
+ else:
+ response = spoken_response = ""
+ self.response_time.set(response)
+ self.response_time.view.setHidden_(not connected)
+ self.response_rail.set(f"{response_time_ms} ms" if response_time_ms is not None else "—")
+ self.response_rail.view.setAccessibilityLabel_(spoken_response)
+ self.response_rail.view.setHidden_(not connected or not getattr(self, "collapsed", False))
+ description = ", ".join(part for part in (state.word, peer, spoken_response) if part)
+ self.header.setAccessibilityLabel_(description)
+ self.header.setToolTip_(description)
def set_dots(self, marks):
for page, (name, row, _icon, _words, _bar, dot) in self.rows.items():
@@ -2211,9 +2328,12 @@ class Ring:
class ChoiceGrid:
"""Each family wraps within its own equal-width grid; partial rows keep that width."""
- def __init__(self, view, cells, owner, swatches=False):
+ def __init__(self, view, cells, owner, swatches=False, keep_columns=False):
self.view, self.cells, self.owner = view, cells, owner
self.swatches = swatches
+ # A style group shorter than a row keeps its family's tile width, so a lone Aperture is
+ # the size of the tiles above and below it rather than the whole row.
+ self.keep_columns = keep_columns
self.columns = None
self.last_width = None
self.height = view.heightAnchor().constraintEqualToConstant_(0)
@@ -2224,7 +2344,8 @@ class ChoiceGrid:
def arrange(self, width):
column = width + 32
count = (5 if column >= 600 else 3 if column >= 400 else 2) if self.swatches else (3 if column >= 600 else 2 if column >= 400 else 1)
- count = min(count, len(self.cells))
+ if not self.keep_columns:
+ count = min(count, len(self.cells))
if width == self.last_width:
return
self.last_width = width
@@ -2243,6 +2364,7 @@ class ChoiceGrid:
class _TileContent:
"""Keep preview geometry out of the page's constraint engine during live resize."""
+ CHECK_ROOM = 22
def __init__(self, preview, name, detail):
self.preview, self.name, self.detail = preview, name, detail
self.last_size = None
@@ -2252,20 +2374,23 @@ class _TileContent:
if c.firstItem() == preview and c.secondItem() in (None, preview)
])
- def arrange(self, size):
+ def arrange(self, size, selected=False):
dimensions = (size.width, size.height)
caption = tuple((label.text, label.size, label.weight) for label in (self.name, self.detail))
- if (dimensions, caption) == self.last_size:
+ if (dimensions, caption, selected) == self.last_size:
return
- self.last_size = (dimensions, caption)
+ self.last_size = (dimensions, caption, selected)
width, height = dimensions
text_width = max(1, width - 16)
+ # The name always leaves room for the check it shows while chosen, so choosing a tile
+ # moves its name and nothing else.
+ name_width = max(1, text_width - self.CHECK_ROOM)
key = (text_width, caption)
heights = self.measurements.get(key)
if heights is None:
heights = [math.ceil(label.view.attributedStringValue().boundingRectWithSize_options_(
- (text_width, 1000), AppKit.NSStringDrawingUsesLineFragmentOrigin).size.height)
- for label in (self.name, self.detail)]
+ (room, 1000), AppKit.NSStringDrawingUsesLineFragmentOrigin).size.height)
+ for label, room in ((self.name, name_width), (self.detail, text_width))]
if len(self.measurements) >= 64:
self.measurements.clear()
self.measurements[key] = heights
@@ -2275,8 +2400,8 @@ class _TileContent:
self.preview.setFrame_(((width / 2 - preview_width / 2, height - 8 - preview_height),
(preview_width, preview_height)))
self.preview.setNeedsLayout_(True)
- self.name.view.setFrame_(((8, height - 14 - preview_height - name_height),
- (text_width, name_height)))
+ self.name.view.setFrame_(((8 + (self.CHECK_ROOM if selected else 0), height - 14 - preview_height - name_height),
+ (name_width, name_height)))
self.detail.view.setFrame_(((8, height - 18 - preview_height - name_height - detail_height),
(text_width, detail_height)))
self.name.view.setNeedsDisplay_(True)
@@ -2304,7 +2429,8 @@ class _SwatchContent:
class ChoiceTiles:
"""A row or stack of preview cards. Style families use the full-width stacked form."""
- def __init__(self, choices, on_change=None, columns=None, tile_width=None, vertical=False, responsive=False, aspect=True):
+ def __init__(self, choices, on_change=None, columns=None, tile_width=None, vertical=False, responsive=False, aspect=True,
+ keep_columns=False):
self.on_change = on_change
self._value = None
self.enabled = True
@@ -2395,7 +2521,7 @@ class ChoiceTiles:
self.ring = None if vertical else Ring(self.view, theme.RADIUS["segment"])
self.ring_shared = False
if responsive:
- self.grid = ChoiceGrid(self.view, [tile for _, tile, _ in self.tiles], self)
+ self.grid = ChoiceGrid(self.view, [tile for _, tile, _ in self.tiles], self, keep_columns=keep_columns)
self.view.owner = self.grid
self.grid.arrange(640)
@@ -2420,12 +2546,21 @@ class ChoiceTiles:
self.ring.show(chosen_tile, self.enabled)
def set_enabled(self, enabled):
+ if enabled == self.enabled:
+ return
self.enabled = enabled
self.view.setAlphaValue_(1.0 if enabled else 0.45)
for _value, tile, _name in self.tiles:
tile.enabled = enabled
self.value = self._value
+ def set_detail(self, value, detail):
+ for candidate, tile, _name in self.tiles:
+ if candidate == value:
+ tile.tile_content.detail.set(detail)
+ tile.setNeedsLayout_(True)
+ return
+
def _choose(self, value):
if value == self._value:
return
@@ -2524,6 +2659,8 @@ class Swatches:
self.ring.show(chosen_chip, self.enabled)
def set_enabled(self, enabled):
+ if enabled == self.enabled:
+ return
self.enabled = enabled
self.view.setAlphaValue_(1.0 if enabled else 0.45)
for _value, cell, _chip, _name in self.cells:
@@ -2581,6 +2718,12 @@ class Linked:
for row in self.rows:
row.set_enabled(enabled)
+ def set_detail(self, value, detail):
+ for row in self.rows:
+ if value in row.values:
+ row.set_detail(value, detail)
+ return
+
def _chosen(self, value):
self.value = value
if self.on_change is not None:
diff --git a/mac_app/windows_input.py b/mac_app/windows_input.py
index 8d1bcdb..71d9aed 100644
--- a/mac_app/windows_input.py
+++ b/mac_app/windows_input.py
@@ -24,6 +24,7 @@ import no_unlock
from core import protocol
from core import peerlist
from core import receiver
+from core import settings_sync
from core.receiver import LinkResponder, ServerState
LOGGER = logging.getLogger("Beamer")
@@ -92,6 +93,7 @@ class WindowsInput:
return any("settings" in caps for caps in known) if known else None
def sync(self, cfg) -> None:
+ self._controller.crossing_displays_changed()
speeds = (cfg.pointer_speed, cfg.scroll_speed, cfg.reverse_scroll)
if self.server.input_scale is None or speeds != self._speeds:
self._speeds = speeds
@@ -161,7 +163,7 @@ class WindowsInput:
caps = self.server.caps_of(peer)
if protocol.id_text(peer) == source or caps is None or "settings" not in caps or self._outbound_up(peer):
continue
- sent = self.server.send(peer, protocol.settings_msg(data)) or sent
+ sent = self.server.send(peer, protocol.settings_msg(settings_sync.for_capabilities(data, caps))) or sent
return sent
def _announce(self, peer: bytes):
@@ -175,17 +177,19 @@ class WindowsInput:
if entry is None:
return []
messages = []
- if entry.get("port") != 0 and entry.get("side") in crossing.EDGES:
- by = protocol.read_id(entry.get("side_by")) or bytes(self._controller.identity()["id"])
- messages.append(protocol.arrangement_v6(entry["side"], entry.get("side_set_at", 0), by,
- way_back=self._controller.way_back(text),
- way_back_by=protocol.read_id(self._controller.way_back_by(text))))
- caps = self.server.caps_of(peer) or frozenset()
- if entry.get("port") != 0 and "settings" in caps:
- messages += [m for m in self._controller.announce() if m.get("type") == protocol.MSG_SETTINGS]
if entry.get("send") is True:
- ids = [protocol.read_id(item.get("id")) for item in self._controller.book.peers() if item.get("id") != text]
- messages.append(protocol.paired_msg([ident for ident in ids if ident is not None][:protocol.MAX_PEERS]))
+ ids = [protocol.read_id(ident) for ident in peerlist.paired_ids(
+ self._controller.book.peers(), exclude=text)]
+ messages.append(protocol.paired_msg(ids))
+ for message in messages:
+ self.server.send(peer, message)
+ messages = []
+ if entry.get("port") != 0:
+ self._controller.crossing_link_up(text)
+ caps = self.server.caps_of(peer) or frozenset()
+ if entry.get("port") != 0 and "settings" in caps and "layout" not in caps:
+ messages += [dict(m, data=settings_sync.for_capabilities(m.get("data", {}), caps))
+ for m in self._controller.announce() if m.get("type") == protocol.MSG_SETTINGS]
return messages
def _on_arrangement(self, peer, read) -> None:
diff --git a/scripts/ui_audit/mac_menu_actions.py b/scripts/ui_audit/mac_menu_actions.py
index 23759fa..d3036dc 100644
--- a/scripts/ui_audit/mac_menu_actions.py
+++ b/scripts/ui_audit/mac_menu_actions.py
@@ -103,7 +103,7 @@ def main():
(AppKit.NSApp, tray.control_window.window, tray.control_window.host_field))
actions.append({"state": count, "title": str(parent.title()) + "/" + str(item.title()),
"selector": selector, "result": "selector-present" if supported else "responder-chain-only",
- "note": "Native Edit/Hide/Close/Minimise effects are not invoked on Toby's desktop."})
+ "note": "Native Edit/Hide/Close/Minimise effects are not invoked on the desktop it runs on."})
path = ROOT / "renders/mac/menu-actions.json"
path.write_text(json.dumps(actions, indent=2))
print(json.dumps({"menu_actions": len(actions), "exceptions": sum(row["result"] == "exception" for row in actions),
diff --git a/scripts/ui_audit/qt_audit.py b/scripts/ui_audit/qt_audit.py
index 71a4969..93bf86b 100644
--- a/scripts/ui_audit/qt_audit.py
+++ b/scripts/ui_audit/qt_audit.py
@@ -346,11 +346,12 @@ def main():
kvm.hardware_win.hardware_address_towards = lambda *_: ""
kvm.autostart_win.is_enabled = lambda: False
kvm.autostart_win.installed_exe = lambda: str(settings_path.parent / "Beamer-audit.exe")
+ kvm.autostart_win.can_run_for_current_user = lambda: True
kvm.platform_parts.injector.stop = lambda: None
theme.watch_system = lambda *_: None
motion.fade_from = lambda *_args, **_kw: None
motion.snapshot = lambda *_: None
- motion.set_shown = lambda w, shown: w.setVisible(shown)
+ motion.set_shown = lambda w, shown, **_options: w.setVisible(shown)
motion.should_animate = lambda *_: False
effects_log = []
kvm.autostart_win.set_enabled = lambda *a: effects_log.append(["autostart", bool(a[0])])
@@ -554,13 +555,6 @@ def main():
screen_is_offscreen=True, menu_items=menu_items, flags=menu_flags))
if state == "five-shared-edge":
window._select_page("crossing")
- for part, button in window.share_tiles.items():
- if window.share_module.isVisibleTo(window):
- button.click()
- capture(window, f"share-{part}", size, state)
- if window.share_module.isVisibleTo(window) and window.share_button.isEnabled():
- window.share_button.click()
- capture(window, "share-apply", size, state)
if state == "none":
window._select_page("connection")
original_save = kvm.app_config.write_settings
diff --git a/tokens.py b/tokens.py
index a1ecd5b..a5aa2a1 100644
--- a/tokens.py
+++ b/tokens.py
@@ -27,6 +27,7 @@ PALETTE = {
"signal": "#5fd4f4",
"signal_dim": "#1f4a55",
"amber": "#f2b544",
+ "resistance_flash": "#b77a00",
"fault": "#ff7a66",
"off": "#4a4b44",
}
@@ -53,6 +54,7 @@ PALETTE_LIGHT = {
"signal": "#006a88",
"signal_dim": "#bfe0ea",
"amber": "#8f5c00",
+ "resistance_flash": "#b55f00",
"fault": "#b53522",
"off": "#aeada3",
}
diff --git a/tools/beam_live_offscreen.py b/tools/beam_live_offscreen.py
index 7573141..7b09d6a 100644
--- a/tools/beam_live_offscreen.py
+++ b/tools/beam_live_offscreen.py
@@ -60,7 +60,8 @@ def live_glow(edge, size, *, pressure=1.0, corner=None, third=False, style="beam
width, height = 1728.0, 1117.0
controller = SimpleNamespace(
cfg=SimpleNamespace(crossing=dict(crossing.DEFAULT_CROSSING, glow_style=style,
- glow_colour="signal", effect_size=size)),
+ glow_colour="signal", effect_size=size,
+ effect_size_fraction=effects.design_values(size=size)[1])),
crossing_pressure_now=lambda: pressure,
_current_desktop_bounds=lambda: (0.0, 0.0, width, height),
)
diff --git a/tools/phone_vectors.json b/tools/phone_vectors.json
index 7fc0513..0fb1901 100644
--- a/tools/phone_vectors.json
+++ b/tools/phone_vectors.json
@@ -1929,14 +1929,23 @@
"alt",
"alt_r",
"backspace",
+ "brightness_down",
+ "brightness_up",
"browser_back",
+ "browser_favourites",
"browser_forward",
+ "browser_home",
+ "browser_refresh",
+ "browser_search",
+ "browser_stop",
+ "calculator",
"caps_lock",
"cmd",
"cmd_r",
"ctrl",
"ctrl_r",
"delete",
+ "dictation",
"down",
"end",
"enter",
@@ -1967,12 +1976,17 @@
"f9",
"home",
"insert",
+ "launch_app1",
+ "launch_app2",
"left",
+ "mail",
"media_next",
"media_play_pause",
"media_prev",
+ "media_select",
"media_stop",
"menu",
+ "mic_mute",
"num_lock",
"page_down",
"page_up",
@@ -1980,9 +1994,11 @@
"print_screen",
"right",
"scroll_lock",
+ "search",
"shift",
"shift_r",
"space",
+ "spotlight",
"tab",
"up",
"volume_down",
@@ -2035,12 +2051,17 @@
"125": "cmd",
"126": "cmd_r",
"127": "menu",
+ "128": "browser_stop",
+ "140": "calculator",
+ "150": "browser_home",
+ "155": "mail",
"158": "browser_back",
"159": "browser_forward",
"163": "media_next",
"164": "media_play_pause",
"165": "media_prev",
"166": "media_stop",
+ "173": "browser_refresh",
"183": "f13",
"184": "f14",
"185": "f15",
@@ -2052,7 +2073,11 @@
"191": "f21",
"192": "f22",
"193": "f23",
- "194": "f24"
+ "194": "f24",
+ "217": "search",
+ "224": "brightness_down",
+ "225": "brightness_up",
+ "248": "mic_mute"
}
},
"ack": {
diff --git a/tools/readme_shots_win.py b/tools/readme_shots_win.py
index 81fe6e1..0ad29cf 100644
--- a/tools/readme_shots_win.py
+++ b/tools/readme_shots_win.py
@@ -14,8 +14,16 @@ import tempfile
import time
from pathlib import Path
-REPO = Path(sys.argv[1])
-OUT = Path(sys.argv[2])
+if len(sys.argv) != 3 or (sys.argv[1] != "--linux" and not Path(sys.argv[1]).is_dir()):
+ raise SystemExit("Usage: readme_shots_win.py <repository-dir> <outdir> | --linux <outdir>")
+
+LINUX = sys.argv[1] == "--linux"
+if LINUX:
+ REPO = Path(__file__).resolve().parents[1]
+ OUT = Path(sys.argv[2])
+else:
+ REPO = Path(sys.argv[1])
+ OUT = Path(sys.argv[2])
sys.path.insert(0, str(REPO / "win_app"))
from PySide6.QtWidgets import QApplication # noqa: E402
@@ -28,25 +36,41 @@ appearance = os.environ.get("APPEARANCE", "dark").strip().lower()
app.setFont(theme.font(theme.TYPE["body"]))
import kvm_bridge_win # noqa: E402
+import app_config # noqa: E402
from core.receiver import ServerState # noqa: E402
+from core import pairing, peerlist # noqa: E402
kvm_bridge_win.VERSION = os.environ.get("SHOT_VERSION", kvm_bridge_win.VERSION)
# Drawn as the installed app is, not as a run from source, which cannot start at sign-in.
kvm_bridge_win.autostart_win.installed_exe = lambda: Path("Beamer.exe")
-kvm_bridge_win.autostart_win.is_enabled = lambda: True
+kvm_bridge_win.autostart_win.is_enabled = lambda: not LINUX
folder = Path(tempfile.mkdtemp())
-(folder / "config.json").write_text(json.dumps({
+fixture = {
"host": "192.168.1.20", "port": 24820, "auth_token": "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8", "paired_with": "MacBook Pro",
"mac_host": "192.168.1.10", "mac_return_edge": "left", "glow_colour": "signal",
"ignored_inputs": ["button:back", "button:forward", "key:175", "key:174"],
"appearance": appearance,
-}))
+}
+if LINUX:
+ fixture["paired_with"] = ""
+ fixture["peers"] = [pairing.peer_entry(
+ bytes([1]) * 16, "MacBook Pro", "macos", fixture["port"], fixture["auth_token"],
+ fixture["mac_host"], 1791321600,
+ )]
+if LINUX:
+ settings = app_config.migrate(fixture)
+ peerlist.add_peer(settings, fixture["peers"][0], settings["peers"][0])
+ app_config.write_settings(folder / "settings.json", settings)
+else:
+ (folder / "config.json").write_text(json.dumps(fixture))
window = kvm_bridge_win.WindowsApplication(folder / "settings.json")
window._set_status(ServerState.CONNECTED, "Connected to 192.168.1.10")
+if LINUX:
+ window.sender.links.up = lambda _peer: True
# This PC's own link to the Mac, as the Mac tool's CONNECTED fakes its socket: without it Overview
# says "not connected" under "Mac connected".
window.sender._sock = object()
-window.resize(820, 700)
+window.resize(1200, 675) if LINUX else window.resize(820, 700)
window.show()
# _set_status only takes effect on the next _refresh_window, whose status heading then cross-fades
# in: forced and settled here, before anything is timed, so that fade never lands mid-shot.
@@ -71,7 +95,8 @@ if switch_to:
OUT.mkdir(parents=True, exist_ok=True)
# PAGES names pages, space-separated; the README's three by default.
-for key in os.environ.get("PAGES", "overview design keyboard").split():
+pages = os.environ.get("PAGES", "overview crossing design" if LINUX else "overview design keyboard").split()
+for key in pages:
settle = 0.3
window._select_page(key)
window.stack.setFocus()
@@ -81,5 +106,6 @@ for key in os.environ.get("PAGES", "overview design keyboard").split():
time.sleep(0.01)
window._refresh_window()
app.processEvents()
- window.grab().save(str(OUT / f"windows-{key}{os.environ.get('SUFFIX', '')}.png"))
+ prefix = "linux" if LINUX else "windows"
+ window.grab().save(str(OUT / f"{prefix}-{key}{os.environ.get('SUFFIX', '')}.png"))
print(OUT)
diff --git a/tools/render_colour_choices.py b/tools/render_colour_choices.py
index f48ee0b..18e5a06 100644
--- a/tools/render_colour_choices.py
+++ b/tools/render_colour_choices.py
@@ -90,6 +90,57 @@ class MacRenderer:
def save(self, image, path):
path.write_bytes(bytes(image.representationUsingType_properties_(self.A.NSBitmapImageFileTypePNG, {})))
+ def design_tile(self, family, style, selected=False, hide_pointer=False):
+ from mac_app.tests.test_window_geometry import offscreen_control_window
+ from mac_app.tests.design_offscreen import settle
+ if not hasattr(self, "design"):
+ self.design = offscreen_control_window()
+ self.design.window.setFrame_display_(((100000, 100000), (1400, 1100)), False)
+ self.design._select_page("design")
+ settle(self.design.window)
+ choices = self.design.glow_style_select if family == "crossing" else self.design.switch_style_select
+ self.theme.repaint(self.design.window.contentView())
+ choices.value = style if selected else None
+ settle(self.design.window)
+ tile = next(tile for row in choices.rows for value, tile, _name in row.tiles if value == style)
+ if tile.tile_content is not None:
+ tile.tile_content.preview.setNeedsDisplay_(True)
+ if hide_pointer:
+ from core import effects
+ names = ("preview_scene", "preview_switch_scene")
+ with mock.patch.multiple(effects, **{
+ name: (lambda original: lambda *args, **kwargs: dict(original(*args, **kwargs), pointer=None))(
+ getattr(effects, name)) for name in names}):
+ return tile, self.capture(tile)
+ return tile, self.capture(tile)
+
+ def style_contact_sheet(self, rows, path):
+ A = self.A
+ cell_w, cell_h = 300, 240
+ view = A.NSView.alloc().initWithFrame_(((0, 0), (cell_w * 2, cell_h * len(rows))))
+ rep = self.capture(view)
+ context = A.NSGraphicsContext.graphicsContextWithBitmapImageRep_(rep)
+ A.NSGraphicsContext.saveGraphicsState()
+ A.NSGraphicsContext.setCurrentContext_(context)
+ import Quartz
+ Quartz.CGContextScaleCTM(context.CGContext(), self.scale, self.scale)
+ self.theme.colour("ground").setFill()
+ A.NSRectFill(view.bounds())
+ for index, (family, style, light, dark) in enumerate(rows):
+ top = len(rows) * cell_h - index * cell_h
+ A.NSString.stringWithString_(f"{family}: {style}").drawAtPoint_withAttributes_((8, top - 18), {
+ A.NSFontAttributeName: self.theme.font(12), A.NSForegroundColorAttributeName: self.theme.colour("ink")})
+ for column, (label, tile_image) in enumerate((("Light", light), ("Dark", dark))):
+ x = column * cell_w
+ A.NSString.stringWithString_(label).drawAtPoint_withAttributes_((x + 8, top - 38), {
+ A.NSFontAttributeName: self.theme.font(11), A.NSForegroundColorAttributeName: self.theme.colour("ink_2")})
+ native = A.NSImage.alloc().initWithSize_(tile_image.size())
+ native.addRepresentation_(tile_image)
+ native.drawInRect_fromRect_operation_fraction_(((x + 8, top - 48 - tile_image.size().height), tile_image.size()),
+ ((0, 0), tile_image.size()), A.NSCompositingOperationSourceOver, 1)
+ A.NSGraphicsContext.restoreGraphicsState()
+ self.save(rep, path)
+
def colour_page(self):
from mac_app.tests.test_window_geometry import offscreen_control_window
from mac_app.tests.design_offscreen import settle
@@ -185,8 +236,11 @@ class QtRenderer:
def capture(self, widget):
from PySide6.QtCore import QPoint
- image = self.image(widget.width(), widget.height())
+ image = self.QImage(math.ceil(widget.width() * self.scale), math.ceil(widget.height() * self.scale),
+ self.QImage.Format.Format_ARGB32_Premultiplied)
+ image.fill(self.Qt.GlobalColor.transparent)
painter = self.QPainter(image)
+ painter.scale(self.scale, self.scale)
widget.render(painter, QPoint(0, 0))
painter.end()
return image
@@ -200,7 +254,7 @@ class QtRenderer:
widget.resize(180, 84)
image = self.image(180, 84)
painter = self.QPainter(image)
- widget._paint_still(painter, widget.STILL_AT)
+ widget._paint_still(painter, widget._still_time(), still=True)
painter.end()
widget.deleteLater()
return image
@@ -216,6 +270,41 @@ class QtRenderer:
if not image.save(str(path)):
raise RuntimeError(f"Could not save {path}")
+ def design_tile(self, family, style, selected=False, hide_pointer=False):
+ from PySide6.QtCore import QCoreApplication, QEvent
+ from win_app.tests.test_settings_layout_acceptance import SyntheticWindow, responder_harness, write_synthetic_settings
+ import tempfile
+ if not hasattr(self, "design"):
+ self._settings = tempfile.TemporaryDirectory()
+ with mock.patch.object(responder_harness, "free_port", return_value=24821):
+ self.design = SyntheticWindow(write_synthetic_settings(Path(self._settings.name)))
+ self.design.full_screen_timer.stop()
+ self.design.refresh_timer.stop()
+ self.design._select_page("design")
+ self.design.resize(1400, 1100)
+ self.design.show()
+ choice = self.design.glow_style_choice if family == "crossing" else self.design.switch_style_choice
+ self.app.setStyleSheet(self.theme.stylesheet())
+ choice.set_value(style if selected else None)
+ preview = choice.tile(style).layout().itemAt(0).widget()
+ preview._image = None
+ preview.update()
+ for _ in range(2):
+ QCoreApplication.sendPostedEvents(None, QEvent.Type.LayoutRequest)
+ self.app.processEvents()
+ tile = choice.tile(style)
+ if hide_pointer:
+ from core import effects
+ names = ("preview_scene", "preview_switch_scene")
+ with mock.patch.multiple(effects, **{
+ name: (lambda original: lambda *args, **kwargs: dict(original(*args, **kwargs), pointer=None))(
+ getattr(effects, name)) for name in names}):
+ preview._image = None
+ self.app.processEvents()
+ return tile, self.capture(tile)
+ return tile, self.capture(tile)
+
+
def colour_page(self):
from PySide6.QtWidgets import QWidget, QVBoxLayout
import widgets
@@ -261,6 +350,76 @@ class QtRenderer:
painter.end()
return image, samples
+ def style_contact_sheet(self, rows, path):
+ from PySide6.QtCore import QRect
+ cell_w, cell_h = 300, 280
+ image = self.image(cell_w * 2, cell_h * len(rows))
+ image.fill(self.QColor(self.theme.colour("ground")))
+ painter = self.QPainter(image)
+ painter.setPen(self.QColor(self.theme.colour("ink")))
+ for index, (family, style, light, dark) in enumerate(rows):
+ y = index * cell_h
+ painter.drawText(8, y + 18, f"{family}: {style}")
+ painter.drawText(8, y + 38, "Light")
+ painter.drawText(cell_w + 8, y + 38, "Dark")
+ target = QRect(8, y + 48, 275, 210)
+ painter.drawImage(target, light)
+ painter.drawImage(target.translated(cell_w, 0), dark)
+ painter.end()
+ self.save(image, path)
+
+
+def style_cases():
+ from core import effects
+ for style in ("glow", "beam", *effects.EFFECT_IDS):
+ yield "crossing", style
+ for style in effects.SWITCH_STYLES:
+ yield "switch", style
+
+
+def relative_luminance(rgb):
+ channels = [value / 255 for value in rgb]
+ linear = [value / 12.92 if value <= .04045 else ((value + .055) / 1.055) ** 2.4 for value in channels]
+ return sum(value * weight for value, weight in zip(linear, (.2126, .7152, .0722)))
+
+
+def style_metrics(renderer, family, style):
+ tile, image = renderer.design_tile(family, style, False, hide_pointer=True)
+ if renderer.__class__.__name__ == "QtRenderer":
+ from PySide6.QtCore import QPoint
+ preview = tile.layout().itemAt(0).widget()
+ origin = preview.mapTo(tile, QPoint())
+ rect = (origin.x(), origin.y(), preview.width(), preview.height())
+ converted = image.convertToFormat(renderer.QImage.Format.Format_RGBA8888)
+ get_pixel = lambda x, y: converted.pixelColor(x, y).getRgb()[:3]
+ image_width, image_height = image.width(), image.height()
+ else:
+ preview = tile.tile_content.preview
+ bounds = preview.frame()
+ rect = (round(bounds.origin.x), round(bounds.origin.y), round(bounds.size.width), round(bounds.size.height))
+ channels, data = image.samplesPerPixel(), bytes(image.bitmapData())
+ image_width, image_height = image.pixelsWide(), image.pixelsHigh()
+ def get_pixel(x, y):
+ offset = y * image.bytesPerRow() + x * channels
+ return tuple(data[offset:offset + 3])
+ ground = (14, 15, 13)
+ ground_lum = relative_luminance(ground)
+ x0, y0, width, height = rect
+ left, top = max(0, round(x0 * renderer.scale)), max(0, round(y0 * renderer.scale))
+ right = min(image_width, round((x0 + width) * renderer.scale))
+ bottom = min(image_height, round((y0 + height) * renderer.scale))
+ distances, marked = [], 0
+ for y in range(top, bottom):
+ for x in range(left, right):
+ rgb = get_pixel(x, y)
+ if max(abs(rgb[index] - ground[index]) for index in range(3)) > 3:
+ marked += 1
+ lum = relative_luminance(rgb)
+ distances.append((max(lum, ground_lum) + .05) / (min(lum, ground_lum) + .05))
+ distances.sort()
+ index = min(len(distances) - 1, math.ceil(.9 * len(distances)) - 1) if distances else 0
+ return (distances[index] if distances else 1.0), marked / max(1, (right - left) * (bottom - top))
+
def main():
parser = argparse.ArgumentParser(description=__doc__)
@@ -268,9 +427,35 @@ def main():
parser.add_argument("--scale", type=int, choices=(1, 2), default=1)
parser.add_argument("--output", type=Path, required=True)
parser.add_argument("--contact-sheet", action="store_true")
+ parser.add_argument("--style-tiles", action="store_true", help="Render the native Design tile widgets")
args = parser.parse_args()
args.output.mkdir(parents=True, exist_ok=True)
renderer = (MacRenderer if args.platform == "mac" else QtRenderer)(args.scale)
+ if args.style_tiles:
+ report = []
+ tile_images = {}
+ for dark in (False, True):
+ mode = "dark" if dark else "light"
+ renderer.set_dark(dark)
+ for family, style in style_cases():
+ contrast, coverage = style_metrics(renderer, family, style)
+ folder = args.output / family / mode / f"{args.scale}x"
+ folder.mkdir(parents=True, exist_ok=True)
+ for selected in (False, True):
+ _tile, image = renderer.design_tile(family, style, selected)
+ suffix = "selected" if selected else "unselected"
+ renderer.save(image, folder / f"{style}-{suffix}.png")
+ if not selected:
+ tile_images.setdefault((family, style), {})[mode] = image
+ report.append((family, style, mode, args.scale, contrast, coverage))
+ sheet_rows = [(family, style, images["light"], images["dark"])
+ for (family, style), images in tile_images.items()]
+ renderer.style_contact_sheet(sheet_rows, args.output / f"{args.platform}-{args.scale}x-style-contact.png")
+ print("| Style | Appearance | Scale | Contrast | Coverage |")
+ print("|---|---|---:|---:|---:|")
+ for family, style, mode, scale, contrast, coverage in report:
+ print(f"| {family}/{style} | {mode} | {scale}x | {contrast:.2f}:1 | {coverage:.2%} |")
+ return
rows, records = colour_rows(args.platform), []
for dark in (False, True):
mode = "dark" if dark else "light"
diff --git a/uk.co.kalkman.beamer.json b/uk.co.kalkman.beamer.json
index 205795b..2d91ae0 100644
--- a/uk.co.kalkman.beamer.json
+++ b/uk.co.kalkman.beamer.json
@@ -9,7 +9,7 @@
"separate-locales": false,
"finish-args": [
"--socket=wayland",
- "--socket=fallback-x11",
+ "--socket=x11",
"--share=ipc",
"--share=network",
"--device=dri",
@@ -106,7 +106,8 @@
"install -Dm644 metainfo.xml /app/share/metainfo/uk.co.kalkman.beamer.metainfo.xml",
"install -Dm644 Beamer.svg /app/share/icons/hicolor/scalable/apps/uk.co.kalkman.beamer.svg",
"install -Dm644 LICENSE /app/share/licenses/uk.co.kalkman.beamer/LICENSE",
- "/app/cleanup-BaseApp.sh"
+ "/app/cleanup-BaseApp.sh",
+ "python3 -m compileall -q /app/share/beamer/core /app/share/beamer/win_app"
],
"sources": [
{"type": "dir", "path": "core", "dest": "core", "skip": ["tests", "__pycache__"]},
diff --git a/win_app/.gitignore b/win_app/.gitignore
index 8cc1f89..506cf6e 100644
--- a/win_app/.gitignore
+++ b/win_app/.gitignore
@@ -4,3 +4,5 @@ build/
dist/
*.pyc
config.json
+.test-*/
+test-results-crossing/
diff --git a/win_app/Beamer-Setup.iss b/win_app/Beamer-Setup.iss
index 90c22aa..b4d93a7 100644
--- a/win_app/Beamer-Setup.iss
+++ b/win_app/Beamer-Setup.iss
@@ -39,7 +39,7 @@ Name: "english"; MessagesFile: "compiler:Default.isl"
[Tasks]
; Autostart is asked for, never assumed, so it starts unticked.
-Name: "autostart"; Description: "Automatically start Beamer at Windows login"; GroupDescription: "Startup options:"; Flags: unchecked
+Name: "autostart"; Description: "Start Beamer elevated at sign-in without another UAC prompt"; GroupDescription: "Startup options:"; Flags: unchecked
[Files]
Source: "dist\Beamer.exe"; DestDir: "{app}"; Flags: ignoreversion
@@ -49,17 +49,62 @@ Source: "dist\Beamer.exe"; DestDir: "{app}"; Flags: ignoreversion
; instead of adding a second Beamer to the Start Menu.
Name: "{autoprograms}\Beamer"; Filename: "{app}\Beamer.exe"
+[InstallDelete]
+; Remove pre-task autostart entries. A Startup shortcut launches the requireAdministrator exe
+; through Explorer and raises UAC on every sign-in, even when the scheduled task is also present.
+Type: files; Name: "{userstartup}\Beamer.lnk"
+
+[Registry]
+; The same legacy Run entry has the same UAC behaviour as the old Startup shortcut.
+Root: HKCU; Subkey: "Software\Microsoft\Windows\CurrentVersion\Run"; ValueName: "Beamer"; Flags: deletevalue
+
[Run]
; CreateProcess refuses a requireAdministrator exe from this non-elevated setup (error 740);
; shellexec lets Windows raise the UAC prompt instead.
Filename: "{app}\Beamer.exe"; Description: "{cm:LaunchProgram,Beamer}"; Flags: nowait postinstall skipifsilent shellexec
-; A plain Startup-folder shortcut would UAC-prompt on every logon, so autostart is a Scheduled Task
-; with RunLevel Highest. Creating one needs elevation this setup does not have, so the step asks
-; for it; --hidden brings Beamer up in the tray rather than with a window.
-Filename: "schtasks.exe"; Parameters: "/Create /RL HIGHEST /SC ONLOGON /TN Beamer /TR ""\""{app}\Beamer.exe\"" --hidden"" /F"; Tasks: autostart; Flags: runhidden shellexec waituntilterminated; Verb: runas
[UninstallRun]
-; The rules and the task were written elevated (by the app, or by the autostart step above), so
-; removing them needs elevation the per-user uninstaller does not have: one prompt, one command,
-; rather than three deletions that fail silently and leave them behind.
-Filename: "cmd.exe"; Parameters: "/c netsh advfirewall firewall delete rule name=""Beamer Receiver (TCP-In)"" & netsh advfirewall firewall delete rule name=""Beamer Pairing (UDP-In)"" & netsh advfirewall firewall delete rule name=""Beamer Pairing (TCP-In)"" & schtasks /Delete /TN Beamer /F"; Flags: runhidden shellexec waituntilterminated; Verb: runas; RunOnceId: "BeamerCleanup"
+; The elevated app reads the interactive account from the session, then removes its task, the
+; legacy global task and firewall rules without relying on the UAC administrator's identity.
+Filename: "{app}\Beamer.exe"; Parameters: "--uninstall-cleanup"; Flags: runhidden shellexec waituntilterminated; Verb: runas; RunOnceId: "BeamerCleanup"
+
+[Code]
+function RunTaskOperation(const Filename, Params: String; var ResultCode: Integer): Boolean;
+begin
+ if IsAdmin then
+ Result := Exec(Filename, Params, '', SW_HIDE, ewWaitUntilTerminated, ResultCode)
+ else
+ Result := ShellExec('runas', Filename, Params, '', SW_HIDE, ewWaitUntilTerminated, ResultCode);
+end;
+
+function TaskCommandFailure(const Action: String; const Started: Boolean; const ResultCode: Integer): String;
+begin
+ if (not Started) and (ResultCode = 1223) then
+ Result := 'You cancelled the permission request.'
+ else if not Started then
+ Result := 'Windows could not start the task operation: ' + SysErrorMessage(ResultCode)
+ else
+ Result := 'Windows returned exit code ' + IntToStr(ResultCode) + '.';
+ Result := Action + ' ' + Result;
+end;
+
+// Keep the old elevated starter until first run migrates it successfully. This also preserves
+// autostart when a silent upgrade does not launch Beamer after replacing the executable.
+
+procedure CurStepChanged(CurStep: TSetupStep);
+var
+ ResultCode: Integer;
+ Started: Boolean;
+ Failure: String;
+begin
+ if (CurStep = ssPostInstall) and WizardIsTaskSelected('autostart') then
+ begin
+ Started := RunTaskOperation(ExpandConstant('{app}\Beamer.exe'), '--enable-autostart', ResultCode);
+ if (not Started) or (ResultCode <> 0) then
+ begin
+ Failure := TaskCommandFailure('Could not run Beamer sign-in setup.', Started, ResultCode);
+ Log(Failure);
+ RaiseException('Beamer was installed, but start at sign-in was not configured. It requires Beamer and the signed-in session to use the same administrator account. ' + Failure);
+ end;
+ end;
+end;
diff --git a/win_app/app_config.py b/win_app/app_config.py
index ab3b605..e865887 100644
--- a/win_app/app_config.py
+++ b/win_app/app_config.py
@@ -3,10 +3,9 @@
The file is settings.json (WIRE.md section 1), migrated from 1.4.x's config.json on the first start
and never written back to it. `Config` is the flat view the window, the sender and the receiver have
always read: this PC's own settings, and the first desktop peer as the fields that used to be the Mac's
-(`mac_host`, `auth_token`, `send_to_mac` and the rest). Each peer's side and zones are written only by
-`set_ways` and `apply_arrangement`, one peer at a time, never by a save of the flat view, so a view read
-before another machine sent its side cannot put the old one back. The settings carry whatever else
-the file holds through every save untouched."""
+(`mac_host`, `auth_token`, `send_to_mac` and the rest). Crossing events use core.crossing_state;
+the picture derives each peer's side and zones while ways retain the user's choices. Saving the
+flat view cannot restore stale crossing state. Unrelated settings survive every save."""
import base64
import binascii
@@ -28,7 +27,7 @@ from core import peerlist
from core import protocol
from core import receiver
from core import return_edge
-from core import ways
+from core import ways, crossing_state
from core.pairing import local_address_towards
import tokens
@@ -69,11 +68,6 @@ class ConfigError(Exception):
pass
-class ClashError(ConfigError):
- """Two machines' zones would lead from one stretch of this PC's screen; the message is the
- sentence that names both. Nothing was written."""
-
-
class SettingsFileError(ConfigError):
"""settings.json exists but this version cannot use it (another schema, a hand edit that broke
it). Nothing is written over it."""
@@ -97,6 +91,8 @@ class Config:
# How long an effect takes to play through once the pointer crosses: see effects.LENGTHS.
effect_length: str = "normal"
effect_size: str = "medium"
+ effect_pace: float = 1.0
+ effect_size_fraction: float = 0.045
# The Mac's name from the last pairing, for the window to say who this PC is paired with.
paired_with: str = ""
# Whether each machine may take the other's input. Two plain switches: the
@@ -110,8 +106,12 @@ class Config:
# seconds of the last change to that or to a shared value; see settings_sync.
same_on_both: bool = False
same_set_at: int = 0
+ same_groups: list = field(default_factory=list)
# The machine that made that last change, its id as base64: the larger id wins a tie.
same_by: str = ""
+ # Each shared value's own stamp, {key: [set_at, by]}, since 1.5.2; a key with none takes
+ # same_set_at and same_by (settings_sync.held_stamps).
+ same_stamps: dict = field(default_factory=dict)
design_set_at: int = 0
design_by: str = ""
design_follow_peer: str = ""
@@ -128,6 +128,7 @@ class Config:
# "Part of the edge": the thirds of the edge to the Mac that cross, as return_edge.PARTS names them.
crossing_edge_parts: list = field(default_factory=lambda: ["middle"])
crossing_resistance_px: int = 120
+ shortcut_goes_to: str = "last"
trigger_key: str = "cmd_r"
trigger_style: str = "double_tap"
double_tap_ms: int = 300
@@ -159,6 +160,9 @@ class Config:
# machines; empty until a settings file has given it one. The id never changes once made.
machine_id: str = ""
name: str = ""
+ layout: dict = field(default_factory=dict)
+ layout_set_at: int = 0
+ layout_by: str = ""
def _stamp(value) -> int:
@@ -209,10 +213,14 @@ def validate_config(config: Config) -> None:
raise ConfigError("auth_token must be text")
if config.auth_token == "CHANGE_ME":
raise ConfigError("auth_token is still the placeholder")
+ if not isinstance(config.layout, dict) or not isinstance(config.layout_by, str):
+ raise ConfigError("layout is invalid")
if config.trigger_key not in TRIGGER_KEYS:
raise ConfigError(f"trigger_key must be one of: {', '.join(TRIGGER_KEYS)}")
if config.trigger_style not in TRIGGER_STYLES:
raise ConfigError(f"trigger_style must be one of: {', '.join(TRIGGER_STYLES)}")
+ if config.shortcut_goes_to not in ("last", "next", "ticked"):
+ raise ConfigError("shortcut_goes_to must be last, next or ticked")
try:
double_tap_ms = int(config.double_tap_ms)
except (TypeError, ValueError) as exc:
@@ -252,6 +260,11 @@ def validate_config(config: Config) -> None:
raise ConfigError("hide_addresses must be true or false")
if not isinstance(config.same_on_both, bool):
raise ConfigError("same_on_both must be true or false")
+ if (not isinstance(config.same_groups, list)
+ or any(group not in ("crossing", "design", "shortcut", "names") for group in config.same_groups)):
+ raise ConfigError("same_groups must contain known group names")
+ if not isinstance(config.same_stamps, dict):
+ raise ConfigError("same_stamps must be an object")
for name in ("pointer_speed", "scroll_speed"):
value = getattr(config, name)
if isinstance(value, bool) or not isinstance(value, (int, float)) or not 0.25 <= value <= 4.0:
@@ -280,6 +293,10 @@ def validate_config(config: Config) -> None:
sizes = tuple(value for value, _name in effects.SIZES)
if config.effect_size not in sizes:
raise ConfigError(f"effect_size must be one of: {', '.join(sizes)}")
+ if not effects.valid_effect_pace(config.effect_pace):
+ raise ConfigError("effect_pace must be a number from 0.25 to 2.5")
+ if not effects.valid_effect_size_fraction(config.effect_size_fraction):
+ raise ConfigError("effect_size_fraction must be a number from 0.02 to 0.08")
if not isinstance(config.paired_with, str):
raise ConfigError("paired_with must be text")
if not isinstance(config.send_to_mac, bool):
@@ -306,6 +323,12 @@ def config_from_dict(raw: dict) -> Config:
missing = [key for key in ("host", "port", "auth_token") if key not in raw]
if missing:
raise ConfigError(f"config.json is missing required field(s): {', '.join(missing)}")
+ lengths = tuple(value for value, _name in effects.LENGTHS)
+ if raw.get("effect_length", "normal") not in lengths:
+ raise ConfigError(f"effect_length must be one of: {', '.join(lengths)}")
+ sizes = tuple(value for value, _name in effects.SIZES)
+ if raw.get("effect_size", "medium") not in sizes:
+ raise ConfigError(f"effect_size must be one of: {', '.join(sizes)}")
trigger_key = raw.get("trigger_key", "cmd_r")
try:
glow_style, glow_colour, switch_style = effects.offered(
@@ -322,13 +345,18 @@ def config_from_dict(raw: dict) -> Config:
shortcut_arrival_style=switch_style,
effect_length=raw.get("effect_length", "normal"),
effect_size=raw.get("effect_size", "medium"),
+ effect_pace=raw.get("effect_pace"),
+ effect_size_fraction=raw.get("effect_size_fraction"),
paired_with=raw.get("paired_with", "") or "",
allow_mac_to_drive=raw.get("allow_mac_to_drive", True),
check_updates=raw.get("check_updates", True),
hide_addresses=raw.get("hide_addresses", False),
same_on_both=raw.get("same_on_both", False),
same_set_at=_stamp(raw.get("same_set_at", 0)),
+ same_groups=raw.get("same_groups", ["crossing", "design", "shortcut", "names"]
+ if raw.get("same_on_both", False) else []),
same_by=raw.get("same_by", "") or "",
+ same_stamps=dict(raw["same_stamps"]) if isinstance(raw.get("same_stamps"), dict) else {},
design_set_at=_stamp(raw.get("design_set_at", 0)),
design_by=raw.get("design_by", "") or "",
design_follow_peer=raw.get("design_follow_peer", "") or "",
@@ -340,6 +368,7 @@ def config_from_dict(raw: dict) -> Config:
crossing_corner=raw.get("crossing_corner", "top_left"),
crossing_edge_parts=raw.get("crossing_edge_parts", ["middle"]),
crossing_resistance_px=int(raw.get("crossing_resistance_px", 120)),
+ shortcut_goes_to=raw.get("shortcut_goes_to", "last"),
trigger_key=trigger_key,
trigger_style=raw.get("trigger_style", "double_tap"),
double_tap_ms=int(raw.get("double_tap_ms", 300)),
@@ -355,9 +384,15 @@ def config_from_dict(raw: dict) -> Config:
appearance=raw.get("appearance") if raw.get("appearance") in tokens.APPEARANCES else "system",
machine_id=raw.get("machine_id", "") or "",
name=raw.get("name", "") or "",
+ layout=raw.get("layout", {}) or {},
+ layout_set_at=_stamp(raw.get("layout_set_at", 0)),
+ layout_by=raw.get("layout_by", "") or "",
)
except (TypeError, ValueError) as exc:
raise ConfigError(f"config.json contains an invalid value: {exc}") from exc
+ (config.effect_pace, config.effect_size_fraction,
+ config.effect_length, config.effect_size) = effects.design_values(
+ config.effect_pace, config.effect_size_fraction, config.effect_length, config.effect_size)
validate_config(config)
return config
@@ -391,13 +426,17 @@ def config_to_dict(config: Config) -> dict:
"shortcut_arrival_style": config.shortcut_arrival_style,
"effect_length": config.effect_length,
"effect_size": config.effect_size,
+ "effect_pace": config.effect_pace,
+ "effect_size_fraction": config.effect_size_fraction,
"paired_with": config.paired_with,
"allow_mac_to_drive": config.allow_mac_to_drive,
"check_updates": config.check_updates,
"hide_addresses": config.hide_addresses,
"same_on_both": config.same_on_both,
"same_set_at": int(config.same_set_at),
+ "same_groups": list(config.same_groups),
"same_by": config.same_by,
+ "same_stamps": copy.deepcopy(config.same_stamps),
"design_set_at": int(config.design_set_at),
"design_by": config.design_by,
"design_follow_peer": config.design_follow_peer,
@@ -409,6 +448,7 @@ def config_to_dict(config: Config) -> dict:
"crossing_corner": config.crossing_corner,
"crossing_edge_parts": list(config.crossing_edge_parts),
"crossing_resistance_px": int(config.crossing_resistance_px),
+ "shortcut_goes_to": config.shortcut_goes_to,
"trigger_key": config.trigger_key,
"trigger_style": config.trigger_style,
"double_tap_ms": int(config.double_tap_ms),
@@ -424,6 +464,9 @@ def config_to_dict(config: Config) -> dict:
"appearance": config.appearance,
"machine_id": config.machine_id,
"name": config.name,
+ "layout": config.layout,
+ "layout_set_at": int(config.layout_set_at),
+ "layout_by": config.layout_by,
}
@@ -512,6 +555,7 @@ def _peer_entry(raw: dict, token: str, port: int, own_id: str) -> dict:
side = raw.get("mac_return_edge")
side = side if side in EDGES else ""
set_at = _stamp(raw.get("arrangement_set_at", 0))
+ methods, corner, parts = _zone_fields(raw)
return {
"id": "", "name": _text(raw.get("paired_with")), "platform": "macos", "token": token,
"host": _text(raw.get("mac_host")), "port": port, "hw": _text(raw.get("mac_hardware_address")),
@@ -519,6 +563,9 @@ def _peer_entry(raw: dict, token: str, port: int, own_id: str) -> dict:
"in_use": True,
"side": side, "side_set_at": set_at, "side_by": own_id if set_at else "",
"paired_with": [], "paired_at": 0, "linked": False, "from_1_4": True,
+ "ways": {"edge": bool(set(methods) & {"edge", "part"}),
+ "thirds": list(ways.PARTS) if "edge" in methods else parts,
+ "corner": "corner" in methods, "corner_at": corner, "notch": False},
}
@@ -545,7 +592,7 @@ def migrate(legacy, machine_id=None) -> dict:
machine_id = machine_id or new_machine_id()
settings = {
"schema": SCHEMA, "machine_id": machine_id, "name": "", "port": protocol.DEFAULT_PORT, "shortcut": True,
- "peers": [], "zones": [], "migrated_token_sha256": "",
+ "peers": [], "zones": [], "migrated_token_sha256": "", "layout": {}, "layout_set_at": 0, "layout_by": "",
}
if not isinstance(legacy, dict):
return settings
@@ -648,6 +695,8 @@ def load_settings(path: Path) -> dict:
legacy = _read_object(legacy_config_path(path))
if not path.exists():
settings = migrate(legacy)
+ settings = crossing_state.migrate(settings, "pc")["settings"]
+ settings = crossing_state.paired(settings, platform="pc", own_displays={}, now=time.time())["settings"]
_write_json(path, settings)
return settings
settings = _read_object(path)
@@ -666,14 +715,41 @@ def load_settings(path: Path) -> dict:
or (entry["jump_key"] and not ways.valid_jump_key(entry["jump_key"])))
for entry in settings["peers"]):
raise SettingsFileError(f"{path} has a peer jump_key that is not a recorded modifier chord, and is left as it is")
- if _overlapping_zones(settings):
- raise SettingsFileError(f"{path} has two zones in use over the same stretch of the screen, and is left as it is")
settings.setdefault("name", "")
settings.setdefault("port", protocol.DEFAULT_PORT)
settings.setdefault("shortcut", True)
settings.setdefault("migrated_token_sha256", "")
- repaired = ways.ensure_zones(settings) or phones_repaired
- if (legacy is not None and remigrate(settings, legacy)) or repaired:
+ settings.setdefault("layout", {})
+ settings.setdefault("layout_set_at", 0)
+ settings.setdefault("layout_by", "")
+ if (not isinstance(settings["layout"], dict) or type(settings["layout_set_at"]) is not int
+ or not 0 <= settings["layout_set_at"] <= 2 ** 53 - 2
+ or not isinstance(settings["layout_by"], str)
+ or settings["layout_by"] and not is_machine_id(settings["layout_by"])):
+ raise SettingsFileError(f"{path} has an invalid layout")
+ if (len(settings["layout"]) > MAX_PEERS + 1 or any(
+ not is_machine_id(machine) or not isinstance(tile, dict)
+ or any(type(tile.get(key)) is not int for key in ("x", "y", "w", "h"))
+ or tile["w"] < 1 or tile["h"] < 1 or not ways._valid_tile_displays(tile)
+ for machine, tile in settings["layout"].items())):
+ raise SettingsFileError(f"{path} has an invalid layout tile")
+ remigrated = legacy is not None and remigrate(settings, legacy)
+ legacy_edges = [zone.get("peer") for zone in settings["zones"]
+ if zone.get("kind") == "edge" and not zone.get("off") and not zone.get("page_off")]
+ intents_repaired = False
+ for entry in settings["peers"]:
+ if "ways" not in entry and entry.get("port") != 0 and entry.get("id", "") in legacy_edges:
+ # Legacy whole edges covered thirds; retain that precedence before canonical allocation.
+ entry["ways"] = ways._read_intent(settings, entry.get("id", ""))
+ entry["ways"]["thirds"] = list(ways.PARTS)
+ intents_repaired = True
+ elif not entry.get("id") and entry.get("port") != 0 and "ways" not in entry:
+ entry["ways"] = ways._read_intent(settings, "")
+ outcome = crossing_state.migrate(settings, "pc")
+ settings = outcome["settings"]
+ if remigrated:
+ settings = crossing_state.paired(settings, platform="pc", own_displays={}, now=time.time())["settings"]
+ if remigrated or phones_repaired or intents_repaired or outcome["changed"]:
_write_json(path, settings)
return settings
@@ -687,28 +763,6 @@ def _own_address(target: str) -> str:
return ""
-def _overlapping_zones(settings: dict) -> bool:
- """Whether two zones in use cover one stretch (WIRE.md section 8): an edge zone covers its peer's side,
- a part zone the chosen thirds of it, a corner zone its corner. A corner inside an edge is fine, and
- a zone this reads as nothing (no such kind, no thirds) is left to the defaults as before."""
- sides = {peer.get("id", ""): peer.get("side", "") for peer in settings["peers"]}
- seen = set()
- for zone in settings["zones"]:
- if zone.get("off") is True:
- continue
- kind, side = zone.get("kind"), sides.get(zone.get("peer"), "")
- if kind == "corner" and zone.get("corner") in CORNERS:
- stretch = {("corner", zone["corner"])}
- elif kind == "edge" and side in return_edge.EDGES:
- stretch = {(side, part) for part in return_edge.PARTS}
- elif kind == "part" and side in return_edge.EDGES and isinstance(zone.get("parts"), list):
- stretch = {(side, part) for part in zone["parts"] if part in return_edge.PARTS}
- else:
- continue
- if stretch & seen:
- return True
- seen |= stretch
- return False
def _zones_of(settings: dict, peer_id: str) -> dict:
@@ -833,7 +887,10 @@ def save_config(path: Path, config: Config) -> None:
ways.check_trigger_key(settings, config.trigger_key)
except ValueError as exc:
raise ConfigError(str(exc)) from exc
+ old_tokens = [entry.get("token") for entry in settings["peers"]]
_apply_flat(settings, payload)
+ if old_tokens != [entry.get("token") for entry in settings["peers"]]:
+ settings = crossing_state.paired(settings, platform="pc", own_displays={}, now=time.time())["settings"]
write_settings(path, settings)
@@ -875,7 +932,7 @@ def set_own(path: Path, **fields) -> None:
def learned_fields(path: Path) -> dict:
"""What links write into the first peer's entry, in the flat view's names: its token, address,
- hardware address and name, and the two direction switches."""
+ hardware address and name, the two direction switches, and the shared layout."""
with SETTINGS_LOCK:
flat = _flat_from_settings(load_settings(path))
# With no peer there is nothing for links to have written, and the flat view has no such fields.
@@ -883,8 +940,9 @@ def learned_fields(path: Path) -> dict:
return {name: flat[name] if name in flat else getattr(fallback, name) for name in LEARNED}
-# What links and a fold write into the first peer, in the flat view's names.
-LEARNED = ("auth_token", "mac_host", "mac_hardware_address", "paired_with", "send_to_mac", "allow_mac_to_drive")
+# What links and a fold write while the window holds its flat view.
+LEARNED = ("auth_token", "mac_host", "mac_hardware_address", "paired_with", "send_to_mac", "allow_mac_to_drive",
+ "layout", "layout_set_at", "layout_by")
# The ones a link writes while the window is not looking, which a save must never overwrite.
LINK_WRITTEN = ("mac_host", "mac_hardware_address", "paired_with")
@@ -901,68 +959,41 @@ def set_peer_hardware_address(path: Path, peer: str, address: str) -> bool:
return True
-def set_ways(path: Path, peer: str, *, side=None, methods, parts, corner, live=None) -> bool:
- """Writes one peer's ways across (WIRE.md section 8): its `side`, and its edge, part and corner
- zones, in use when named in `methods`. `side` None keeps the side held now, so a change to a way
- never puts back a side that arrived since the window last read it. A machine with no link now
- (`live(id)` false) gives way to them (core/ways.py give_way). Raises ClashError, writing
- nothing, when two machines' zones would then cover one stretch of this PC's screen; ConfigError
- when no entry has `peer`. Returns whether the side moved, which the caller sends as `arrangement`."""
+def set_ways(path: Path, peer: str, *, side=None, methods, parts, corner, live=None, capable=()) -> bool:
+ """Save local intent through the shared crossing event; side belongs to the picture."""
with SETTINGS_LOCK:
settings = load_settings(path)
entry = next((item for item in settings["peers"] if item.get("id") == peer), None)
if entry is None:
raise ConfigError("that machine is not paired with this PC")
- moved = ways.edit(
- settings, peer, side=entry.get("side", "") if side is None else side, methods=methods, parts=parts,
- corner=corner, kinds=KINDS, corner_edge=_corner_edge, now=time.time(),
- )
- if moved:
- # Moved onto a side another machine's edge holds: the side stands and this machine's way
- # there goes off, as when the side arrives from it; the page says which machine holds it.
- ways.settle(settings, peer, "this PC", live)
- for notice in ways.give_way(settings, peer, "this PC", live):
- LOGGER.info("%s", notice)
- sentence = ways.clash(settings, "this PC")
- if sentence is not None:
- raise ClashError(sentence)
- _write_json(path, settings)
- return moved
+ outcome = crossing_state.edit_ways(
+ settings, peer, platform="pc", edge=bool(set(methods) & {"edge", "part"}),
+ thirds=list(ways.PARTS) if "edge" in methods else parts,
+ corner="corner" in methods, corner_at=corner, live=live, gone=None,
+ now=time.time(), capable=capable)
+ _write_json(path, outcome["settings"])
+ return entry.get("side", "") != ways._entry(outcome["settings"], peer).get("side", "")
def share_side(path: Path, side: str, thirds: dict) -> list:
- """Split one side's zones under the settings lock, returning every machine whose zones changed."""
- with SETTINGS_LOCK:
- settings = load_settings(path)
- changed = ways.share(settings, side, thirds, kinds=KINDS)
- _write_json(path, settings)
- return changed
+ """Compatibility no-op: placement and thirds now allocate shared edges."""
+ return []
def settle_presence(path: Path, live, gone):
- """What became of the zones set aside for a machine with no link (core/ways.py settle_presence).
- Returns (changed, notices): whether the file was written, and a sentence for each zone that stays
- off for good or could not be put back."""
- with SETTINGS_LOCK:
- settings = load_settings(path)
- before = copy.deepcopy(settings)
- notices = ways.settle_presence(settings, "this PC", live, gone)
- if settings == before:
- return False, notices
- _write_json(path, settings)
- return True, notices
+ """Compatibility no-op: picture peers keep intent through link changes."""
+ return False, []
def apply_arrangement(path: Path, peer: str, edge: str, set_at: int, by: str, way_back=None, way_back_by=None,
- live=None):
- """A peer's `arrangement` (WIRE.md section 8), as core.ways takes it: `edge` is the edge of the peer
- that faces this PC, so this PC's side for it is the opposite, and `way_back` is kept whatever the
- side. Returns (changed, notices): whether the file was written, and a sentence for each of that
- peer's zones turned off by a clash."""
+ live=None, capable=()):
+ """Compatibility entry point for capability-aware arrangement reception."""
with SETTINGS_LOCK:
settings = load_settings(path)
- changed, notices = ways.arrangement(settings, peer, edge, set_at, by, "this PC", way_back,
- way_back_by=way_back_by, corner_edge=_corner_edge, live=live)
- if changed:
- _write_json(path, settings)
- return changed, notices
+ outcome = crossing_state.receive_arrangement(
+ settings, peer, {"edge": edge, "set_at": set_at, "by": protocol.read_id(by),
+ "way_back": way_back, "way_back_by": protocol.read_id(way_back_by)},
+ platform="pc", capable=capable, live=live, gone=None, now=time.time())
+ if outcome["changed"]:
+ _write_json(path, outcome["settings"])
+ return outcome["changed"], []
diff --git a/win_app/autostart_win.py b/win_app/autostart_win.py
index aeca5ea..8b12d7a 100644
--- a/win_app/autostart_win.py
+++ b/win_app/autostart_win.py
@@ -1,10 +1,12 @@
-"""Start at logon, owned by the app: the scheduled task is the setting, so there is no config
-field to disagree with it.
+"""Start at logon, owned by the app: each interactive account has its own scheduled task, so there
+is no config field to disagree with it.
A scheduled task rather than a Run key or a Startup shortcut: Beamer.exe is manifested
requireAdministrator, and Explorer starts such an exe from either of those with a UAC prompt on
-every logon. A task with the highest run level starts it elevated and silently. The app is
-already elevated when it writes the task, so no prompt appears here either.
+every logon. A task with the highest run level starts it elevated and silently for an
+administrator account. Windows cannot do that for a standard account without storing another
+user's credentials, so the switch is unavailable when a different administrator approved this
+launch.
Registered from XML, not `schtasks /create /sc onlogon`: that form cannot set a working directory
and gives every task a 72-hour execution limit, which would stop Beamer three days after logon.
@@ -14,15 +16,20 @@ from __future__ import annotations
import ctypes
import os
+import ntpath
import subprocess
import sys
import tempfile
from typing import Callable, Optional
from xml.sax.saxutils import escape
+import xml.etree.ElementTree as ET
-TASK_NAME = "Beamer"
+TASK_PREFIX = "Beamer-"
CREATE_NO_WINDOW = 0x08000000
NAME_SAM_COMPATIBLE = 2
+WTS_CURRENT_SESSION = 0xFFFFFFFF
+WTS_USER_NAME = 5
+WTS_DOMAIN_NAME = 7
Runner = Callable[[list], "subprocess.CompletedProcess"]
@@ -31,9 +38,8 @@ def _run(args: list) -> subprocess.CompletedProcess:
return subprocess.run(args, capture_output=True, text=True, creationflags=CREATE_NO_WINDOW)
-def current_user() -> str:
- """DOMAIN\\user as Windows maps it, not USERDOMAIN, which reads WORKGROUP in some sessions and
- maps to no account."""
+def _process_user() -> str:
+ """DOMAIN\\user from the process token, which may be an administrator entered at UAC."""
size = ctypes.c_ulong(0)
secur32 = ctypes.windll.secur32
secur32.GetUserNameExW(NAME_SAM_COMPATIBLE, None, ctypes.byref(size))
@@ -43,12 +49,56 @@ def current_user() -> str:
return buffer.value
+def _session_value(info_class: int) -> str:
+ value = ctypes.c_void_p()
+ size = ctypes.c_ulong()
+ wtsapi32 = ctypes.windll.wtsapi32
+ query = wtsapi32.WTSQuerySessionInformationW
+ query.argtypes = [
+ ctypes.c_void_p,
+ ctypes.c_ulong,
+ ctypes.c_int,
+ ctypes.POINTER(ctypes.c_void_p),
+ ctypes.POINTER(ctypes.c_ulong),
+ ]
+ query.restype = ctypes.c_int
+ free_memory = wtsapi32.WTSFreeMemory
+ free_memory.argtypes = [ctypes.c_void_p]
+ free_memory.restype = None
+ if not query(
+ None, WTS_CURRENT_SESSION, info_class, ctypes.byref(value), ctypes.byref(size)
+ ):
+ raise OSError("could not read the signed-in account")
+ try:
+ return ctypes.wstring_at(value.value)
+ finally:
+ free_memory(value)
+
+
+def current_user() -> str:
+ """DOMAIN\\user from the interactive session, even when another admin approved UAC."""
+ domain = _session_value(WTS_DOMAIN_NAME)
+ username = _session_value(WTS_USER_NAME)
+ if not username:
+ raise OSError("could not identify the signed-in account")
+ return f"{domain}\\{username}" if domain else username
+
+
+def task_name(user: str) -> str:
+ return TASK_PREFIX + user.replace("\\", "-")
+
+
+def can_run_for_current_user() -> bool:
+ """The requireAdministrator app can start silently only for the account that elevated it."""
+ return current_user().casefold() == _process_user().casefold()
+
+
def installed_exe() -> Optional[str]:
"""The exe a task can start, or None when running from source, where there is none."""
return sys.executable if getattr(sys, "frozen", False) else None
-def task_xml(exe: str, user: str) -> str:
+def task_xml(exe: str, user: str, arguments: str = "--hidden") -> str:
return f"""<?xml version="1.0" encoding="UTF-16"?>
<Task version="1.2" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
<Triggers>
@@ -74,7 +124,7 @@ def task_xml(exe: str, user: str) -> str:
<Actions Context="Author">
<Exec>
<Command>{escape(exe)}</Command>
- <Arguments>--hidden</Arguments>
+ <Arguments>{escape(arguments)}</Arguments>
<WorkingDirectory>{escape(os.path.dirname(exe))}</WorkingDirectory>
</Exec>
</Actions>
@@ -82,23 +132,114 @@ def task_xml(exe: str, user: str) -> str:
"""
-def is_enabled(run: Runner = _run) -> bool:
- return run(["schtasks", "/query", "/tn", TASK_NAME]).returncode == 0
+def is_enabled(run: Runner = _run, user: Optional[str] = None) -> bool:
+ user = user or current_user()
+ migrate_legacy_task(run, user)
+ return _task_enabled(task_name(user), run)
+
+
+def _task_root(name: str, run: Runner):
+ result = run(["schtasks", "/query", "/tn", name, "/xml"])
+ if result.returncode != 0:
+ return None
+ try:
+ return ET.fromstring(result.stdout.lstrip("\ufeff"))
+ except ET.ParseError as exc:
+ raise OSError("Windows returned invalid sign-in task XML") from exc
+
+
+def _task_enabled(name: str, run: Runner) -> bool:
+ root = _task_root(name, run)
+ ns = {"t": "http://schemas.microsoft.com/windows/2004/02/mit/task"}
+ return root is not None and root.findtext("t:Settings/t:Enabled", "true", ns).lower() == "true"
+
+
+def _replacement_ready(root, exe: str, arguments: str) -> bool:
+ if root is None:
+ return False
+ ns = {"t": "http://schemas.microsoft.com/windows/2004/02/mit/task"}
+ command = root.findtext("t:Actions/t:Exec/t:Command", "", ns).strip('"')
+ return (
+ root.findtext("t:Settings/t:Enabled", "true", ns).lower() == "true"
+ and any(trigger.findtext("t:Enabled", "true", ns).lower() == "true"
+ for trigger in root.findall("t:Triggers/t:LogonTrigger", ns))
+ and ntpath.normcase(command) == ntpath.normcase(exe)
+ and root.findtext("t:Actions/t:Exec/t:Arguments", "", ns) == arguments
+ )
+
+
+def migrate_legacy_task(run: Runner = _run, user: Optional[str] = None) -> None:
+ """Keep the old starter until its owner's replacement has been registered successfully."""
+ user = user or current_user()
+ root = _task_root("Beamer", run)
+ if root is None:
+ return
+ ns = {"t": "http://schemas.microsoft.com/windows/2004/02/mit/task"}
+ owner = root.findtext("t:Principals/t:Principal/t:UserId", "", ns)
+ # schtasks can export the principal as a SID rather than its account name.
+ if owner.casefold() != user.casefold():
+ try:
+ if owner.casefold() != _user_sid(user).casefold():
+ return
+ except OSError:
+ return
+ exe = installed_exe()
+ command = root.findtext("t:Actions/t:Exec/t:Command", "", ns).strip('"')
+ if exe is None or ntpath.normcase(command) != ntpath.normcase(exe):
+ return
+ name = task_name(user)
+ arguments = root.findtext("t:Actions/t:Exec/t:Arguments", "", ns)
+ if _replacement_ready(_task_root(name, run), exe, arguments):
+ remove_legacy_task(run, disable_first=True)
+ elif root.findtext("t:Settings/t:Enabled", "true", ns).lower() != "true":
+ remove_legacy_task(run)
+ else:
+ set_enabled(True, exe, user, run, arguments=arguments)
+
+
+def _user_sid(user: str) -> str:
+ if sys.platform != "win32":
+ return user
+ import win32security
+ try:
+ sid, _, _ = win32security.LookupAccountName(None, user)
+ except win32security.error as exc:
+ raise OSError("could not identify the sign-in task owner") from exc
+ return win32security.ConvertSidToStringSid(sid)
-def set_enabled(enabled: bool, exe: str, user: Optional[str] = None, run: Runner = _run) -> None:
+def set_enabled(enabled: bool, exe: str, user: Optional[str] = None, run: Runner = _run,
+ *, arguments: str = "--hidden") -> None:
"""Raises OSError with schtasks' own words when Windows refuses."""
+ user = user or current_user()
+ name = task_name(user)
if not enabled:
- if not is_enabled(run):
+ remove_legacy_task(run)
+ if run(["schtasks", "/query", "/tn", name]).returncode != 0:
return
- result = run(["schtasks", "/delete", "/tn", TASK_NAME, "/f"])
+ result = run(["schtasks", "/delete", "/tn", name, "/f"])
else:
+ if not can_run_for_current_user():
+ raise OSError("Beamer can start elevated at sign-in only for an administrator account")
fd, path = tempfile.mkstemp(suffix=".xml")
try:
with os.fdopen(fd, "w", encoding="utf-16") as handle:
- handle.write(task_xml(exe, user or current_user()))
- result = run(["schtasks", "/create", "/tn", TASK_NAME, "/xml", path, "/f"])
+ handle.write(task_xml(exe, user, arguments))
+ result = run(["schtasks", "/create", "/tn", name, "/xml", path, "/f"])
finally:
os.unlink(path)
if result.returncode != 0:
raise OSError((result.stderr or result.stdout or "schtasks failed").strip())
+ if enabled:
+ remove_legacy_task(run, disable_first=True)
+
+
+def remove_legacy_task(run: Runner = _run, *, disable_first: bool = False) -> None:
+ if run(["schtasks", "/query", "/tn", "Beamer"]).returncode == 0:
+ if disable_first:
+ result = run(["schtasks", "/change", "/tn", "Beamer", "/disable"])
+ if result.returncode != 0:
+ raise OSError((result.stderr or result.stdout or "schtasks failed").strip())
+ result = run(["schtasks", "/delete", "/tn", "Beamer", "/f"])
+ if result.returncode != 0:
+ raise OSError((result.stderr or result.stdout or "schtasks failed").strip())
diff --git a/win_app/autostart_x11.py b/win_app/autostart_x11.py
index 902af63..5d48a67 100644
--- a/win_app/autostart_x11.py
+++ b/win_app/autostart_x11.py
@@ -40,6 +40,11 @@ def installed_exe() -> Optional[str]:
return sys.executable if getattr(sys, "frozen", False) else None
+def can_run_for_current_user() -> bool:
+ """autostart_win's question; a desktop entry always starts for the user whose it is."""
+ return True
+
+
def _exec_argument(arg: str) -> str:
"""One argument as the spec's Exec key wants it: %% for a literal percent, double quotes when
a reserved character is present (with " ` $ and \\ backslash-escaped inside), then the whole
diff --git a/win_app/brightness_worker.py b/win_app/brightness_worker.py
new file mode 100644
index 0000000..b98d9b4
--- /dev/null
+++ b/win_app/brightness_worker.py
@@ -0,0 +1,44 @@
+"""Run Windows display brightness changes away from the input reader."""
+
+import threading
+
+
+class BrightnessWorker:
+ def __init__(self, adjust):
+ self._adjust = adjust
+ self._condition = threading.Condition()
+ self._steps = 0
+ self._thread = None
+
+ def submit(self, delta):
+ steps = 1 if delta > 0 else -1 if delta < 0 else 0
+ if not steps:
+ return
+ with self._condition:
+ self._steps += steps
+ if self._thread is None or not self._thread.is_alive():
+ self._thread = threading.Thread(target=self._run, name="Beamer-brightness", daemon=True)
+ self._thread.start()
+ self._condition.notify()
+
+ def _run(self):
+ while True:
+ with self._condition:
+ if self._steps == 0:
+ self._thread = None
+ return
+ steps, self._steps = self._steps, 0
+ self._adjust(steps)
+
+
+def _adjust(steps):
+ from display_brightness import adjust
+
+ adjust(steps)
+
+
+_worker = BrightnessWorker(_adjust)
+
+
+def submit(delta):
+ _worker.submit(delta)
diff --git a/win_app/build.spec b/win_app/build.spec
index deb2b7e..3676ad7 100644
--- a/win_app/build.spec
+++ b/win_app/build.spec
@@ -15,7 +15,7 @@ analysis = Analysis(
datas=[(str(source_dir / "Beamer.ico"), "."), (str(source_dir / "assets"), "assets"), (str(source_dir.parent / "VERSION"), ".")],
# core/effects.py imports its fx_* modules by name, which PyInstaller's analysis cannot see; they are
# among core_modules. segno is imported inside a try in qr_code.py, so it is named here as well.
- hiddenimports=["nacl", "_cffi_backend", "segno"] + app_modules + core_modules,
+ hiddenimports=["nacl", "_cffi_backend", "segno", "win32com.client", "pythoncom", "pywintypes"] + app_modules + core_modules,
hookspath=[],
hooksconfig={},
runtime_hooks=[],
diff --git a/win_app/capture_portal.py b/win_app/capture_portal.py
index 3daec63..26a40cd 100644
--- a/win_app/capture_portal.py
+++ b/win_app/capture_portal.py
@@ -31,6 +31,7 @@ the state directory; v1 asks at every start."""
import logging
import math
import os
+import linux_desktop
import select
import threading
import time
@@ -108,9 +109,11 @@ _NORMAL = {"left": (-1, 0), "right": (1, 0), "top": (0, -1), "bottom": (0, 1)}
NO_PORTAL = ("This desktop does not let apps capture the keyboard and mouse (it has no InputCapture "
"portal), so this machine cannot drive another one. It can still be driven if the "
"desktop allows remote control.")
-REFUSED = ("Beamer was not allowed to capture the keyboard and mouse, so this machine cannot drive "
- "another one. Turn sending off and on again to be asked again.")
+REFUSED = ("The desktop did not allow Beamer to capture the keyboard and mouse. Choose Ask again and allow the "
+ "requested keyboard and pointer access in the desktop prompt.")
ENDED = "The desktop stopped letting Beamer capture the keyboard and mouse: {detail}"
+SESSION_CLOSED = ENDED.format(detail="the session was closed")
+MISSING_CAPABILITIES = "InputCapture did not grant both keyboard and pointer capabilities, so this machine cannot send input."
class CaptureUnavailable(RuntimeError):
@@ -176,7 +179,7 @@ def _thirds(monitor: crossing.Rect, edge: str) -> List[Tuple[int, int]]:
return [(cuts[i], cuts[i + 1]) for i in range(3)]
-def barriers(models: list, monitors: List[crossing.Rect]) -> List[Tuple[str, Tuple[int, int, int, int]]]:
+def barriers(models: list, monitors: List[crossing.Rect], whole_edges=False) -> List[Tuple[str, Tuple[int, int, int, int]]]:
"""(wall, position) for every barrier the sender's zone models need on these displays, in the
portal's coordinates, each once: a whole edge, the chosen thirds of it, or a corner's two walls
of CORNER_PX + 1 pixels. A notch stretch (SpanEdge) is the Mac's and has none here."""
@@ -190,6 +193,14 @@ def barriers(models: list, monitors: List[crossing.Rect]) -> List[Tuple[str, Tup
if isinstance(model, crossing.SpanEdge):
continue
for monitor in monitors:
+ if whole_edges:
+ walls = (model.vertical, model.horizontal) if isinstance(model, crossing.CornerPush) else (model.edge,)
+ for wall in walls:
+ start, length = (monitor.y, monitor.height) if wall in ("left", "right") else (monitor.x, monitor.width)
+ # KDE's portal rejects partial edges, including exposed pieces beside a staggered screen.
+ if _outer(monitors, monitor, wall) == [(start, start + length)]:
+ add(wall, _segment(monitor, wall, start, start + length))
+ continue
if isinstance(model, crossing.CornerPush):
for wall in (model.vertical, model.horizontal):
along_far = wall in ("left", "right")
@@ -294,6 +305,9 @@ class _Session:
options["restore_token"] = ("s", token)
started = self.portal.request(INTERFACE, "Start", "osa{sv}", lambda handle_token: (
self.handle, "", dict(options, handle_token=("s", handle_token))))
+ if started.get("capabilities", 0) & (CAP_KEYBOARD | CAP_POINTER) != CAP_KEYBOARD | CAP_POINTER:
+ self._tokens.write("")
+ raise CaptureUnavailable(MISSING_CAPABILITIES)
if started.get("restore_token"):
self._tokens.write(started["restore_token"])
else:
@@ -306,6 +320,9 @@ class _Session:
except portal.PortalError as exc:
raise CaptureUnavailable(f"{NO_PORTAL} ({exc})") from exc
self.handle = results["session_handle"]
+ if results.get("capabilities", 0) & (CAP_KEYBOARD | CAP_POINTER) != CAP_KEYBOARD | CAP_POINTER:
+ self._tokens.write("")
+ raise CaptureUnavailable(MISSING_CAPABILITIES)
except portal.Refused:
self._tokens.write("")
raise CaptureUnavailable(REFUSED) from None
@@ -323,9 +340,16 @@ class _Session:
return [crossing.Rect(x, y, width, height) for width, height, x, y in results.get("zones", [])]
def set_barriers(self, positions: List[Tuple[int, int, int, int]]) -> List[int]:
- """Barrier i + 1 for each position; the ids the desktop refused. Setting them suspends
- the session, so it is enabled again after, when there are any."""
- self.enabled = False
+ """Barrier i + 1 for each position; the ids the desktop refused. An enabled session is
+ disabled first and enabled again after, when there are any: GNOME refuses every barrier
+ and a second Enable on an enabled session, and an explicit Disable sends no Disabled signal.
+ A session the desktop already disabled is not sent another Disable, which GNOME refuses."""
+ if self.enabled:
+ self.enabled = False
+ try:
+ self.portal.call(INTERFACE, "Disable", "oa{sv}", (self.handle, {}))
+ except portal.PortalError as exc:
+ LOGGER.warning("Could not disable the capture session before setting its barriers (%s)", exc)
listed = [{"barrier_id": ("u", index + 1), "position": ("(iiii)", tuple(position))}
for index, position in enumerate(positions)]
results = self.portal.request(INTERFACE, "SetPointerBarriers", "oa{sv}aa{sv}u", lambda token: (
@@ -370,6 +394,7 @@ class Hooks:
self._ei_factory = ei or _ei_receiver
self._tokens = tokens or portal.TokenStore("input-capture")
self._clock = clock
+ self._whole_edges = linux_desktop.desktop() == "kde"
self._thread: Optional[threading.Thread] = None
self._ready = threading.Event()
self._stopping = threading.Event()
@@ -378,6 +403,7 @@ class Hooks:
self._models: Callable[[], list] = lambda: []
self.on_home: Optional[Callable[[], None]] = None
self.on_failure: Optional[Callable[[BaseException], None]] = None
+ self.on_permission: Optional[Callable[[str, str, bool], None]] = None
self._session: Optional[_Session] = None
self._beat = clock()
self._reset()
@@ -391,6 +417,9 @@ class Hooks:
self._early_at = 0.0
self._walls: Dict[int, str] = {}
self._placed: List[Tuple[str, Tuple[int, int, int, int]]] = []
+ self._selected: List[Tuple[str, Tuple[int, int, int, int]]] = []
+ self._rejected = set()
+ self._reject_unannounced = False
self._sequences: Dict[object, int] = {} # libei device: the sequence it emulates under
self._disabled_at: Optional[float] = None
self._sent_home_at: Optional[float] = None
@@ -435,6 +464,21 @@ class Hooks:
if self._failure is not None:
raise self._failure
+ def request_again(self) -> None:
+ thread = self._thread
+ if thread is not None and thread.is_alive():
+ thread.join(timeout=2.0)
+ if thread.is_alive():
+ raise RuntimeError("The last capture session has not stopped yet")
+ self.start()
+
+ def _report_permission(self, status: str, detail: str = "", retryable: bool = False) -> None:
+ if self.on_permission is not None:
+ try:
+ self.on_permission(status, detail, retryable)
+ except Exception:
+ LOGGER.exception("Could not report InputCapture permission state")
+
def stop(self) -> None:
self._stopping.set()
thread = self._thread
@@ -467,6 +511,7 @@ class Hooks:
self._ready.set()
session.open()
self._set_zones(session.zones())
+ self._report_permission("ready")
while not self._stopping.is_set():
self._beat = self._clock()
self._wait(session)
@@ -475,7 +520,7 @@ class Hooks:
if interface == INTERFACE and body and body[0] == session.handle:
self._signal(member, body[1] if len(body) > 1 else {})
elif interface == portal.SESSION and member == "Closed" and path == session.handle:
- raise CaptureUnavailable(ENDED.format(detail="the session was closed"))
+ raise CaptureUnavailable(SESSION_CLOSED)
events = session.ei.events()
for event in events:
self._beat = self._clock()
@@ -489,6 +534,10 @@ class Hooks:
except Exception as exc:
if not self._stopping.is_set():
LOGGER.exception("Keyboard and mouse capture stopped")
+ refused = getattr(exc, "sentence", None) in (REFUSED, MISSING_CAPABILITIES)
+ status = "refused" if refused else "unavailable"
+ self._report_permission(status, getattr(exc, "sentence", str(exc)),
+ refused or getattr(exc, "sentence", None) == SESSION_CLOSED)
started = self._ready.is_set()
self._failure = exc if not started else None
self._ready.set()
@@ -563,9 +612,12 @@ class Hooks:
LOGGER.info("The desktop ended the capture while input was away; bringing it home")
self._home()
elif member == "ZonesChanged":
+ # Mutter and KWin disable the session on a monitor change; mutter says only this.
+ self._session.enabled = False
self._set_zones(self._session.zones())
def _activated(self, options: dict) -> None:
+ self._reject_unannounced = False
activation = options.get("activation_id", NO_ID)
point = options.get("cursor_position") or desktop_portal.cursor_position()
barrier = options.get("barrier_id")
@@ -578,6 +630,13 @@ class Hooks:
LOGGER.info("Captured at a barrier Beamer does not know; letting go")
self._let_go(desktop_portal.clamp_to(self._zones, *point))
return
+ if self._whole_edges and not self._selected_at(wall, point):
+ self._reject_unannounced = activation == NO_ID
+ rejected = {activation} if activation != NO_ID else set(self._sequences.values())
+ self._rejected.update(rejected)
+ self._early = [(event, sequence) for event, sequence in self._early if sequence not in rejected]
+ self._let_go(desktop_portal.clamp_to(self._zones, *point))
+ return
self._press = Press(wall, point, self._zones, self._clock)
desktop_portal.note_position(*self._press.point)
early, self._early = self._early, []
@@ -585,6 +644,20 @@ class Hooks:
if self._current(sequence):
self._ei_event(event)
+ def _selected_at(self, wall, point) -> bool:
+ vertical = wall in ("left", "right")
+ x, y = point
+ candidates = [position for index, (edge, position) in enumerate(self._placed)
+ if edge == wall and index + 1 in self._walls]
+ if not candidates:
+ return False
+ actual = min(candidates, key=lambda p: max(p[0] - x, 0, x - p[2]) + max(p[1] - y, 0, y - p[3]))
+ line = actual[0] if vertical else actual[1]
+ along = y if vertical else x
+ return any(edge == wall and (p[0] if vertical else p[1]) == line
+ and (p[1] if vertical else p[0]) <= along <= (p[3] if vertical else p[2])
+ for edge, p in self._selected)
+
def _wall_at(self, point) -> Optional[str]:
"""The wall of the placed barrier nearest the pointer, within WALL_PX: the desktop reports
the pointer on the screen's side of a barrier, or past it by the push."""
@@ -594,7 +667,9 @@ class Hooks:
if index + 1 not in self._walls:
continue
distance = max(x1 - x, 0, x - x2) + max(y1 - y, 0, y - y2)
- if distance <= WALL_PX and (best is None or distance < best[0]):
+ # KWin omits barrier_id and may report a fast push far beyond the barrier line.
+ along_edge = y1 <= y <= y2 if wall in ("left", "right") else x1 <= x <= x2
+ if (distance <= WALL_PX or self._whole_edges and along_edge) and (best is None or distance < best[0]):
best = (distance, wall)
return best[1] if best else None
@@ -705,7 +780,8 @@ class Hooks:
session.enable()
return
self._key = key
- placed = self._placed = barriers(models, self._zones)
+ self._selected = barriers(models, self._zones)
+ placed = self._placed = barriers(models, self._zones, whole_edges=self._whole_edges)
failed = session.set_barriers([position for _wall, position in placed])
self._walls = {index + 1: wall for index, (wall, _position) in enumerate(placed) if index + 1 not in failed}
if failed:
@@ -733,16 +809,22 @@ class Hooks:
return
if kind == "start":
self._sequences[event[1]] = event[2]
+ if self._reject_unannounced:
+ self._rejected.add(event[2])
return
if kind == "stop":
# What arrives between a let-go and the desktop ending the capture belongs to nobody.
- self._sequences.pop(event[1], None)
+ ended = self._sequences.pop(event[1], None)
+ if ended not in self._sequences.values():
+ self._rejected.discard(ended)
if not self._sequences:
self._early = []
return
if kind not in ("motion", "button", "key", "scroll", "scroll_discrete", "frame"):
return
sequence = self._sequences.get(event[1]) if len(event) > 1 else None
+ if sequence in self._rejected:
+ return
if self._activation is None:
# Ahead of the Activated signal that says which barrier.
if sequence is not None and len(self._early) < EARLY_MAX:
diff --git a/win_app/capture_win.py b/win_app/capture_win.py
index 722f73d..24f107e 100644
--- a/win_app/capture_win.py
+++ b/win_app/capture_win.py
@@ -17,9 +17,12 @@ callback thread:
checks whether redirecting is still live, and the moment the sender says it
is not -- a dropped link, a missed acknowledgement -- it passes the event
through. Nothing it does can block.
-- Injected events are ignored (LLKHF_INJECTED / LLMHF_INJECTED). Without that,
- every SendInput this PC makes for the Mac's own input would come straight
- back round as a captured event. Raw Input has no such flag, so the injector
+- Injected mouse moves are ignored (LLMHF_INJECTED), and injected mouse
+ buttons and wheel only when they carry INJECTED_MARK. Injected keys follow
+ the same mark rule: keys another program types (Logi Options+, a remapper)
+ are the user's and cross. Without that, every SendInput this PC makes for
+ the Mac's own input would come straight back round as a captured event. Raw
+ Input has no such flag, so the injector
stamps INJECTED_MARK into every SendInput's dwExtraInfo and the WM_INPUT
reader drops a move carrying it. Without that, the Mac's last deltas after
a return crossing -- injected here, then reported by Raw Input as the mouse
@@ -46,6 +49,7 @@ import threading
import unicodedata
from typing import Callable, Dict, List, Optional, Set, Tuple, Union
+from core.capture_types import DeadKey, TextInput
from input_injector import INJECTED_MARK, SCAN_TO_US
LOGGER = logging.getLogger(__name__)
@@ -132,6 +136,50 @@ def mouse_event(message: int, mouse_data: int):
return None
+def internal_seam_position(point, monitors, display_map, models):
+ """Return the owning display edge when `point` has crossed an armed internal seam."""
+ x, y = point
+ for model in models:
+ display = getattr(model, "display", None)
+ edge = getattr(model, "edge", None)
+ rect = display_map.get(display) if isinstance(display, str) else None
+ if rect is None or edge not in ("left", "right", "top", "bottom"):
+ continue
+ if edge in ("left", "right"):
+ if not rect.y <= y <= rect.bottom:
+ continue
+ if edge == "left":
+ crossed = x < rect.x and any(
+ monitor.x + monitor.width == rect.x and monitor.y <= y <= monitor.bottom
+ and monitor.x <= x <= monitor.right for monitor in monitors
+ )
+ held = (rect.x, y)
+ else:
+ crossed = x > rect.right and any(
+ monitor.x == rect.x + rect.width and monitor.y <= y <= monitor.bottom
+ and monitor.x <= x <= monitor.right for monitor in monitors
+ )
+ held = (rect.right, y)
+ else:
+ if not rect.x <= x <= rect.right:
+ continue
+ if edge == "top":
+ crossed = y < rect.y and any(
+ monitor.y + monitor.height == rect.y and monitor.x <= x <= monitor.right
+ and monitor.y <= y <= monitor.bottom for monitor in monitors
+ )
+ held = (x, rect.y)
+ else:
+ crossed = y > rect.bottom and any(
+ monitor.y == rect.y + rect.height and monitor.x <= x <= monitor.right
+ and monitor.y <= y <= monitor.bottom for monitor in monitors
+ )
+ held = (x, rect.bottom)
+ if crossed and model._at_edge(monitors, held, display_map):
+ return held
+ return None
+
+
# What the Keyboard page calls a recorded key, in Windows' own words.
VK_TITLES: Dict[int, str] = {
0x08: "Backspace", 0x09: "Tab", 0x0D: "Enter", 0x13: "Pause", 0x14: "Caps Lock", 0x1B: "Esc",
@@ -141,8 +189,11 @@ VK_TITLES: Dict[int, str] = {
0x6D: "Num -", 0x6E: "Num .", 0x6F: "Num /", 0x90: "Num Lock", 0x91: "Scroll Lock",
0xA0: "Left Shift", 0xA1: "Right Shift", 0xA2: "Left Ctrl", 0xA3: "Right Ctrl",
0xA4: "Left Alt", 0xA5: "Right Alt", 0xA6: "Browser Back", 0xA7: "Browser Forward",
+ 0xA8: "Browser Refresh", 0xA9: "Browser Stop", 0xAA: "Browser Search", 0xAB: "Browser Favourites",
+ 0xAC: "Browser Home",
0xAD: "Mute", 0xAE: "Volume Down", 0xAF: "Volume Up", 0xB0: "Next Track",
- 0xB1: "Previous Track", 0xB2: "Stop", 0xB3: "Play/Pause", 0xBA: ";", 0xBB: "=", 0xBC: ",",
+ 0xB1: "Previous Track", 0xB2: "Stop", 0xB3: "Play/Pause", 0xB4: "Mail", 0xB5: "Media Select",
+ 0xB6: "Launch App 1", 0xB7: "Launch App 2", 0xBA: ";", 0xBB: "=", 0xBC: ",",
0xBD: "-", 0xBE: ".", 0xBF: "/", 0xC0: "`", 0xDB: "[", 0xDC: "\\", 0xDD: "]", 0xDE: "'",
}
for _index in range(24):
@@ -227,6 +278,11 @@ VK_TO_NAME: Dict[int, str] = {
0xA5: "alt_r",
0xA6: "browser_back",
0xA7: "browser_forward",
+ 0xA8: "browser_refresh",
+ 0xA9: "browser_stop",
+ 0xAA: "browser_search",
+ 0xAB: "browser_favourites",
+ 0xAC: "browser_home",
0xAD: "volume_mute",
0xAE: "volume_down",
0xAF: "volume_up",
@@ -234,6 +290,10 @@ VK_TO_NAME: Dict[int, str] = {
0xB1: "media_prev",
0xB2: "media_stop",
0xB3: "media_play_pause",
+ 0xB4: "mail",
+ 0xB5: "media_select",
+ 0xB6: "launch_app1",
+ 0xB7: "launch_app2",
# The undifferentiated modifiers, which a low-level hook does not normally
# report but a synthetic event can.
0x10: "shift",
@@ -246,9 +306,9 @@ for _index in range(1, 13):
for _index in range(13, 21):
VK_TO_NAME[0x7C + (_index - 13)] = f"f{_index}"
-# Media and browser keys are never the trigger: they are what the stays-on-this-PC list is for.
+# System and browser keys are never the trigger: they are what the stays-on-this-PC list is for.
# The undifferentiated 0x10-0x12 never reach the hook.
-NOT_TRIGGER_VKS = {0x10, 0x11, 0x12} | set(range(0xA6, 0xB4))
+NOT_TRIGGER_VKS = {0x10, 0x11, 0x12} | set(range(0xA6, 0xB8))
# Loaded if a config names them, never offered by the recorder, as on the Mac: Backspace, Tab,
# Enter, Esc and Space are typing keys a double-tap or a hold would take from every app, and
# Windows gives a window no key-down for Print Screen, so it cannot be recorded at all.
@@ -286,16 +346,6 @@ class KeyboardState:
return state
-class DeadKey:
- def __init__(self, character: str) -> None:
- self.character = character
-
-
-class TextInput:
- def __init__(self, text: str) -> None:
- self.text = text
-
-
def _compose_dead_key(dead_key: str, character: str) -> Union[str, TextInput]:
name = unicodedata.name(dead_key, "")
if name.startswith("MODIFIER LETTER "):
@@ -377,9 +427,21 @@ class Trigger:
self.window_ms = window_ms
self._last_at: Optional[float] = None
self._held = False
+ self._down = False
self._release_owed = False
+ def disarmed(self, name: str, down: bool) -> None:
+ """A key while the shortcut is off: no tap may be half-made across it, but the key is
+ still followed, so one held while the shortcut is armed again does not read its next
+ autorepeat as a fresh tap."""
+ self.configure(self.key, self.style, self.window_ms)
+ if name == self.key:
+ self._down = down
+
def configure(self, key: str, style: str, window_ms: int) -> None:
+ # `_down` is the physical key, so it survives a reconfigure of the same key.
+ if key != self.key:
+ self._down = False
self.key, self.style, self.window_ms = key, style, int(window_ms)
self._last_at = None
self._held = False
@@ -416,7 +478,12 @@ class Trigger:
return None
self._held = down
return REDIRECT if down else RETURN
- if not down:
+ was_down, self._down = self._down, down
+ if not down or was_down:
+ # A down while the key is already down is autorepeat, which every capture (the
+ # Windows hook, X11 and the portal) delivers as another down: counting it as a tap
+ # toggled input every 66 ms while the key was held. A lost release (the secure
+ # desktop takes the key-up) costs one tap, since the next release clears it.
return None
last = self._last_at
self._last_at = now
@@ -439,13 +506,15 @@ class Hooks:
must not reach the rest of Windows. `on_motion(dx, dy)` is called with
the mouse's own relative counts and consumes nothing -- raw input is a
listener, never a filter, which is why the hook is still what swallows a
- move. None of the three may block.
+ move. `on_seam(x, y)` may return a cursor position to hold at an internal display seam; it only
+ reads cached geometry and must stay bounded like the other hook callbacks.
"""
- def __init__(self, on_key, on_mouse, on_motion) -> None:
+ def __init__(self, on_key, on_mouse, on_motion, on_seam=None) -> None:
self._on_key = on_key
self._on_mouse = on_mouse
self._on_motion = on_motion
+ self._on_seam = on_seam
self._window = None
self._thread: Optional[threading.Thread] = None
self._thread_id: Optional[int] = None
@@ -561,7 +630,7 @@ class Hooks:
return user32.CallNextHookEx(None, code, wparam, lparam)
try:
data = ctypes.cast(lparam, ctypes.POINTER(KBDLLHOOKSTRUCT)).contents
- if data.flags & LLKHF_INJECTED:
+ if data.flags & LLKHF_INJECTED and data.dwExtraInfo == INJECTED_MARK:
return user32.CallNextHookEx(None, code, wparam, lparam)
down = wparam in KEY_DOWN_MESSAGES
if not down and wparam not in KEY_UP_MESSAGES:
@@ -610,8 +679,14 @@ class Hooks:
return user32.CallNextHookEx(None, code, wparam, lparam)
try:
data = ctypes.cast(lparam, ctypes.POINTER(MSLLHOOKSTRUCT)).contents
- if data.flags & LLMHF_INJECTED:
+ if data.flags & LLMHF_INJECTED and (
+ wparam == WM_MOUSEMOVE or data.dwExtraInfo == INJECTED_MARK
+ ):
return user32.CallNextHookEx(None, code, wparam, lparam)
+ if wparam == WM_MOUSEMOVE and self._on_seam is not None:
+ position = self._on_seam(data.pt.x, data.pt.y)
+ if position is not None and user32.SetCursorPos(*position):
+ return 1
if self._on_mouse(wparam, data.pt.x, data.pt.y, data.mouseData):
return 1
except Exception:
diff --git a/win_app/capture_x11.py b/win_app/capture_x11.py
index a51636d..168af34 100644
--- a/win_app/capture_x11.py
+++ b/win_app/capture_x11.py
@@ -75,6 +75,7 @@ from capture_win import ( # noqa: F401 (re-exported for the bridge, which read
wheel_notches,
)
from core import keytable
+import x11_seams
LOGGER = logging.getLogger(__name__)
@@ -84,6 +85,7 @@ XI_HIERARCHY_CHANGED = 11
XI_RAW_KEY_PRESS, XI_RAW_KEY_RELEASE = 13, 14
XI_RAW_BUTTON_PRESS, XI_RAW_BUTTON_RELEASE = 15, 16
XI_RAW_MOTION = 17
+XI_BARRIER_HIT, XI_BARRIER_LEAVE = x11_seams.XI_BARRIER_HIT, x11_seams.XI_BARRIER_LEAVE
XI_ALL_DEVICES, XI_ALL_MASTER_DEVICES = 0, 1
XI_MASTER_POINTER, XI_MASTER_KEYBOARD, XI_SLAVE_POINTER = 1, 2, 3
XI_KEY_REPEAT = 1 << 16
@@ -128,7 +130,10 @@ _TITLES = {
"insert": "Insert", "home": "Home", "end": "End", "page_up": "Page Up", "page_down": "Page Down", "left": "Left",
"right": "Right", "up": "Up", "down": "Down", "menu": "Menu", "print_screen": "Print Screen", "pause": "Pause",
"num_lock": "Num Lock", "scroll_lock": "Scroll Lock", "browser_back": "Browser Back",
- "browser_forward": "Browser Forward", "volume_mute": "Mute", "volume_down": "Volume Down", "volume_up": "Volume Up",
+ "browser_forward": "Browser Forward", "browser_stop": "Browser Stop", "browser_home": "Browser Home",
+ "browser_refresh": "Browser Refresh", "search": "Search", "mail": "Mail", "calculator": "Calculator",
+ "brightness_up": "Brightness Up", "brightness_down": "Brightness Down", "mic_mute": "Microphone Mute",
+ "volume_mute": "Mute", "volume_down": "Volume Down", "volume_up": "Volume Up",
"media_next": "Next Track", "media_prev": "Previous Track", "media_stop": "Stop", "media_play_pause": "Play/Pause",
}
_TITLES.update({f"f{index}": f"F{index}" for index in range(1, 25)})
@@ -138,7 +143,9 @@ VK_TITLES[96] = "Num Enter"
# Offered by the recorder or not, as app_config reads capture_win's: media and browser keys are for
# the stays-here list, and typing keys a double-tap or a hold would take from every app. On X the
# trigger also reaches apps at home, so Print Screen stays out as on Windows.
-NOT_TRIGGER_VKS = {code for code, physical in keytable.EVDEV_NAMES.items() if physical.startswith(("media_", "volume_", "browser_"))}
+NOT_TRIGGER_VKS = {code for code, physical in keytable.EVDEV_NAMES.items()
+ if physical.startswith(("media_", "volume_", "browser_", "brightness_", "mic_"))
+ or physical in ("search", "mail", "calculator")}
UNRECORDABLE_TRIGGER_VKS = {code for code, physical in keytable.EVDEV_NAMES.items()
if physical in ("backspace", "tab", "enter", "esc", "space", "print_screen")}
@@ -289,14 +296,17 @@ class _Connection:
if not self.display.has_extension("XTEST"):
raise RuntimeError("This X server has no XTEST extension")
self._opcode = self.display.display.get_extension_major("XInputExtension")
- # python-xlib's xinput_query_version announces 2.0, and a 2.0 client is sent raw events
- # only while nothing is grabbed.
- reply = xinput.XIQueryVersion(display=self.display.display, opcode=self._opcode, major_version=2, minor_version=2)
+ # XI 2.3 adds barrier-hit events and the release request used for seam resistance.
+ # Older servers negotiate down and retain the existing 2.1 capture behaviour.
+ reply = xinput.XIQueryVersion(display=self.display.display, opcode=self._opcode, major_version=2, minor_version=3)
+ self._xi_version = (reply.major_version, reply.minor_version)
if (reply.major_version, reply.minor_version) < (2, 1):
raise RuntimeError(f"This X server has XInput {reply.major_version}.{reply.minor_version}; Beamer needs 2.1")
self.keymap = xkb_x11.Keymap(self.display.get_display_name())
self.root = self.display.screen().root
self.root.xinput_select_events([(XI_ALL_MASTER_DEVICES, RAW_MASK), (XI_ALL_DEVICES, 1 << XI_HIERARCHY_CHANGED)])
+ self._seam_controller = None
+ self._seam_unavailable = False
# An invisible cursor for the pointer grab: a 1x1 pixmap with an empty mask.
pixmap = self.root.create_pixmap(1, 1, 1)
gc = pixmap.create_gc(foreground=0)
@@ -332,6 +342,8 @@ class _Connection:
def _generic(self, event) -> list:
kind = event.evtype
+ if kind in (XI_BARRIER_HIT, XI_BARRIER_LEAVE):
+ return [x11_seams.parse_barrier_event(kind, event.data)]
if XI_RAW_KEY_PRESS <= kind <= XI_RAW_MOTION:
deviceid, detail, sourceid, flags, raw = parse_raw(event.data)
return [("raw", kind, detail, sourceid, flags, raw, deviceid, event.sequence_number)]
@@ -402,10 +414,60 @@ class _Connection:
def close(self) -> None:
try:
+ if self._seam_controller is not None:
+ self._seam_controller.close()
+ self._seam_controller = None
self.keymap.close()
finally:
self.display.close()
+ def configure_seams(self, monitors, resistance_px: int, enabled: bool = True) -> bool:
+ """Configure XFixes holds on internal RandR monitor seams."""
+ if self._seam_unavailable:
+ return False
+ try:
+ if self._seam_controller is None:
+ if self._xi_version < (2, 3) or not self.display.has_extension("XFIXES"):
+ self._seam_unavailable = True
+ LOGGER.info("X11 seam holds need XInput 2.3 and XFixes 5; leaving this desktop unchanged")
+ return False
+ from Xlib.ext import xfixes
+
+ # python-xlib's convenience method asks for 4.0, so query 5.0 explicitly here.
+ version = xfixes.QueryVersion(
+ display=self.display.display,
+ opcode=self.display.display.get_extension_major("XFIXES"),
+ major_version=5,
+ minor_version=0,
+ )
+ if (version.major_version, version.minor_version) < (5, 0):
+ self._seam_unavailable = True
+ LOGGER.info("X11 seam holds need XFixes 5; leaving this desktop unchanged")
+ return False
+ self.root.xinput_select_events([
+ (XI_ALL_MASTER_DEVICES, RAW_MASK | x11_seams.XI_BARRIER_EVENTS),
+ (XI_ALL_DEVICES, 1 << XI_HIERARCHY_CHANGED),
+ ])
+ self.display.sync()
+ self._seam_controller = x11_seams.Controller(x11_seams.XlibBackend(self.display, self.root))
+ self._seam_controller.configure(monitors, resistance_px, enabled)
+ self.display.flush()
+ return True
+ except Exception:
+ LOGGER.exception("X11 seam holds are unavailable; disabling them for this session")
+ self._seam_unavailable = True
+ if self._seam_controller is not None:
+ try:
+ self._seam_controller.close()
+ except Exception:
+ LOGGER.exception("Could not remove X11 seam barriers after setup failed")
+ self._seam_controller = None
+ return False
+
+ def handle_seam_event(self, event: tuple) -> None:
+ if self._seam_controller is not None:
+ self._seam_controller.handle(event)
+
class Hooks:
"""The listener, the grab and the thread that owns both, with capture_win.Hooks' callbacks:
@@ -424,6 +486,8 @@ class Hooks:
self._stopping = threading.Event()
self._failure: Optional[BaseException] = None
self._predicate: Optional[Callable[[], bool]] = None
+ self._seam_lock = threading.Lock()
+ self._seam_config = None
# The proof harness turns this off to read its own injection back.
self.drop_injected = True
self._masters: List[Device] = []
@@ -455,6 +519,15 @@ class Hooks:
and never block."""
self._predicate = predicate
+ def configure_seams(self, monitors, resistance_px: int) -> None:
+ """Enable X11 internal-monitor seam holds using X root-pixel rectangles.
+
+ Call again when the monitor layout or crossing resistance changes. Barriers are managed
+ on the capture thread, and are suspended while a peer is driving this machine.
+ """
+ with self._seam_lock:
+ self._seam_config = (tuple(monitors), max(0, int(resistance_px)))
+
@property
def grabbed(self) -> bool:
return bool(self._grabbed)
@@ -552,11 +625,29 @@ class Hooks:
want = bool(predicate())
except Exception:
LOGGER.exception("Could not tell whether input is away; letting go")
+ self._sync_seams(not want)
if want and not self._grabbed:
self._take()
elif not want and self._grabbed:
self._let_go()
+ def _sync_seams(self, enabled: bool) -> None:
+ configure = getattr(self._connection, "configure_seams", None)
+ if not callable(configure):
+ return
+ with self._seam_lock:
+ config = self._seam_config
+ if config is None:
+ return
+ try:
+ configure(config[0], config[1], enabled=enabled)
+ except Exception:
+ LOGGER.exception("Could not update X11 seam barriers; disabling them")
+ try:
+ configure((), 0, enabled=False)
+ except Exception:
+ LOGGER.exception("Could not clear X11 seam barriers")
+
def _take(self) -> None:
self._taking = True
try:
@@ -669,7 +760,11 @@ class Hooks:
def _handle(self, event: tuple) -> None:
kind = event[0]
- if kind == "raw":
+ if kind == "barrier":
+ handle = getattr(self._connection, "handle_seam_event", None)
+ if callable(handle):
+ handle(event)
+ elif kind == "raw":
_, evtype, detail, sourceid, flags, raw, master, sequence = event
if self.drop_injected and sourceid in self._xtest:
return
diff --git a/win_app/clipboard_portal.py b/win_app/clipboard_portal.py
index 77572da..3ba7f04 100644
--- a/win_app/clipboard_portal.py
+++ b/win_app/clipboard_portal.py
@@ -24,6 +24,9 @@ LOGGER = logging.getLogger(__name__)
TEXT_MIMES = ("text/plain;charset=utf-8", "text/plain", "UTF8_STRING", "STRING", "TEXT")
PNG_MIME = "image/png"
TIMEOUT_SECONDS = 2.0
+# Each wait in set_contents, which runs on the link's reader: two stay under the sender's 1.5 s
+# wait for an acknowledgement (core/link.py ACK_STALL_SECONDS).
+SET_SECONDS = 0.5
MAX_BYTES = 64 * 1024 * 1024
_synced: Optional[int] = None
@@ -125,8 +128,13 @@ def forget_sync() -> None:
def set_contents(text: Optional[str], png: Optional[bytes]) -> bool:
"""Offer `text` and/or `png` as this machine's clipboard. False when there is nothing to set or
- the clipboard cannot be reached. Never raises."""
+ the clipboard cannot be reached. Never raises, and never waits for the session to start: the
+ link's reader calls this, and a consent dialog holding the session up would stop it reading
+ (and acknowledging) input for as long as the sender tolerates."""
global _synced
+ session = inject_portal._remote
+ if session is None or not session.ready.is_set():
+ return False
offer = {}
if text is not None:
data = text.replace("\r\n", "\n").encode("utf-8")
@@ -136,11 +144,12 @@ def set_contents(text: Optional[str], png: Optional[bytes]) -> bool:
if not offer:
return False
try:
- written = bool(inject_portal.remote().ask(lambda session: session.set_selection(offer), default=False))
+ written = bool(inject_portal.remote().ask(lambda session: session.set_selection(offer), default=False,
+ timeout=SET_SECONDS))
except Exception:
LOGGER.exception("Could not set the clipboard")
return False
if written:
- changes = inject_portal.remote().ask(lambda session: session.changes, default=None)
+ changes = inject_portal.remote().ask(lambda session: session.changes, default=None, timeout=SET_SECONDS)
_synced = changes
return written
diff --git a/win_app/crossing_ledger.py b/win_app/crossing_ledger.py
new file mode 100644
index 0000000..bee536e
--- /dev/null
+++ b/win_app/crossing_ledger.py
@@ -0,0 +1,509 @@
+"""The Crossing ledger: kept intent, edited directly in each machine's row."""
+
+from PySide6.QtCore import QEvent, QPointF, QRectF, QSize, Qt
+from PySide6.QtGui import QAccessible, QColor, QFontMetrics, QPainter, QPen
+from PySide6.QtWidgets import (QAccessibleWidget, QCheckBox, QFrame, QGraphicsOpacityEffect,
+ QGridLayout, QHBoxLayout, QLabel, QLineEdit, QPushButton,
+ QSizePolicy, QStyle, QStyleOptionButton, QVBoxLayout, QWidget)
+
+from core import ways
+import theme
+import widgets
+
+
+def _accessible_factory(_name, obj):
+ role = obj.property("ledger_role") if isinstance(obj, QWidget) else None
+ roles = {"table": QAccessible.Role.Table, "row": QAccessible.Role.Row,
+ "columnheader": QAccessible.Role.ColumnHeader, "rowheader": QAccessible.Role.RowHeader,
+ "cell": QAccessible.Role.Cell}
+ if role in roles:
+ return QAccessibleWidget(obj, roles[role])
+
+
+QAccessible.installFactory(_accessible_factory)
+
+
+def _quiet(text, callback=None):
+ button = QPushButton(text)
+ button.setProperty("vernier", "plain")
+ button.setProperty("ledger_quiet", True)
+ button.setFont(theme.font(theme.TYPE["note"]))
+ button.setCursor(Qt.CursorShape.PointingHandCursor)
+ button.setMinimumWidth(0)
+ button.setFixedHeight(24)
+ _quiet_style(button)
+ if callback:
+ button.clicked.connect(callback)
+ return button
+
+
+def _quiet_style(button):
+ button.setStyleSheet(f"QPushButton {{ color: {theme.colour('ink_2')}; background: transparent; border: 0; padding: 0; font-size: {round(theme.TYPE['note'])}px; font-weight: 400; text-align: left; }} QPushButton:focus {{ border: 1px solid {theme.colour('signal')}; }}")
+
+
+class ScreenGlyph(QWidget):
+ def __init__(self, kind, callback, parent=None):
+ super().__init__(parent)
+ self.kind, self.callback = kind, callback
+ self.side, self.picked, self.corner, self.holders = "", [], "", {}
+ self.setFixedSize(50, 38)
+ self.buttons = {}
+ details = ways.PARTS if kind == "edge" else ways.CORNERS
+ for detail in details:
+ button = QPushButton(self)
+ button.setCheckable(True)
+ button.setCursor(Qt.CursorShape.PointingHandCursor)
+ button.setStyleSheet("QPushButton { background: transparent; border: 0; padding: 0; } QPushButton:focus { border: 1px solid " + theme.colour("signal") + "; }")
+ button.clicked.connect(lambda _checked=False, value=detail: self.callback(value))
+ self.buttons[detail] = button
+
+ def reflect(self, side="", picked=(), corner="", holders=None, left_out=False):
+ self.side, self.picked, self.corner, self.holders = side or "", list(picked), corner, holders or {}
+ rect = QRectF(7.5, 7.5, 35, 23)
+ for index, (detail, button) in enumerate(self.buttons.items()):
+ button.setStyleSheet("QPushButton { background: transparent; border: 0; padding: 0; } QPushButton:focus { border: 1px solid " + theme.colour("signal") + "; }")
+ if self.kind == "edge":
+ horizontal = side in ("top", "bottom")
+ span = rect.width() if horizontal else rect.height()
+ fixed = rect.top() if side == "top" else rect.bottom() if side == "bottom" else rect.left() if side == "left" else rect.right()
+ start = (rect.left() if horizontal else rect.top()) + index * span / 3
+ hit = QRectF(start, fixed - 6, span / 3, 12) if horizontal else QRectF(fixed - 6, start, 12, span / 3)
+ title = ways.part_names(side or "top")[detail]
+ on = detail in picked
+ name = f"{(side or 'Unplaced').capitalize()} edge, {title.lower()} third, {'on' if on else 'off'}"
+ tooltip = f"{title} third: click to {'leave it out' if on else 'turn it on'}"
+ allowed = bool(side)
+ else:
+ x = 10.5 if detail.endswith("left") else 39.5
+ y = 10.5 if detail.startswith("top") else 27.5
+ hit = QRectF(x - 7, y - 7, 14, 14)
+ title = detail.replace("_", " ").capitalize()
+ on = corner == detail
+ name = f"{title} corner, {'on' if on else 'off'}"
+ tooltip = (f"{self.holders[detail]}'s corner" if detail in self.holders else
+ f"{title} corner: click to {'turn it off' if on else 'move the corner here' if corner else 'turn it on'}")
+ allowed = detail not in self.holders
+ button.setGeometry(hit.toAlignedRect())
+ button.setAccessibleName(name)
+ button.setToolTip("Left out: Put back to change its ways" if left_out else tooltip)
+ button.setEnabled(allowed and not left_out)
+ button.blockSignals(True)
+ button.setChecked(on)
+ button.blockSignals(False)
+ self.update()
+
+ def paintEvent(self, _event):
+ painter = QPainter(self)
+ painter.setRenderHint(QPainter.RenderHint.Antialiasing)
+ painter.setPen(QPen(QColor(theme.colour("edge")), 1))
+ painter.setBrush(QColor(theme.colour("well")))
+ rect = QRectF(7.5, 7.5, 35, 23)
+ painter.drawRoundedRect(rect, 2.5, 2.5)
+ if self.kind == "edge" and self.side:
+ horizontal = self.side in ("top", "bottom")
+ fixed = rect.top() if self.side == "top" else rect.bottom() if self.side == "bottom" else rect.left() if self.side == "left" else rect.right()
+ span = rect.width() if horizontal else rect.height()
+ origin = rect.left() if horizontal else rect.top()
+ for index, third in enumerate(ways.PARTS):
+ on = third in self.picked
+ colour = QColor(theme.colour("signal" if on else "edge"))
+ colour.setAlphaF(1 if on else .7)
+ pen = QPen(colour, 3 if on else 1.5)
+ pen.setCapStyle(Qt.PenCapStyle.RoundCap)
+ painter.setPen(pen)
+ start, end = origin + index * span / 3 + 1, origin + (index + 1) * span / 3 - 1
+ painter.drawLine(QPointF(start, fixed), QPointF(end, fixed)) if horizontal else painter.drawLine(QPointF(fixed, start), QPointF(fixed, end))
+ elif self.kind == "corner":
+ for corner in ways.CORNERS:
+ x = 10.5 if corner.endswith("left") else 39.5
+ y = 10.5 if corner.startswith("top") else 27.5
+ on, held = corner == self.corner, corner in self.holders
+ colour = QColor(theme.colour("signal" if on or held else "edge"))
+ colour.setAlphaF(.45 if held else 1)
+ painter.setPen(QPen(colour, 1))
+ painter.setBrush(colour if on else Qt.BrushStyle.NoBrush)
+ radius = 3.2 if on else 2
+ painter.drawEllipse(QPointF(x, y), radius, radius)
+ painter.end()
+
+
+class _Name(QLabel):
+ def __init__(self):
+ super().__init__()
+ self.full_text = ""
+ self.setMinimumWidth(0)
+ self.setFont(theme.font(theme.TYPE["body"], 600))
+
+ def set_name(self, text):
+ self.full_text = text
+ self.setAccessibleName(text)
+ self.setToolTip(text)
+ self._fit()
+
+ def sizeHint(self):
+ return QSize(132, self.fontMetrics().height())
+
+ def minimumSizeHint(self):
+ return QSize(0, self.fontMetrics().height())
+
+ def _fit(self):
+ self.setText(QFontMetrics(self.font()).elidedText(self.full_text, Qt.TextElideMode.ElideRight, max(1, self.width())))
+
+ def resizeEvent(self, event):
+ self._fit()
+ super().resizeEvent(event)
+
+
+class _Jump(widgets.JumpKeyRecorder):
+ def __init__(self, callback, on_arm):
+ super().__init__(callback, on_arm)
+ self.setMinimumHeight(24)
+ self.layout().setContentsMargins(5, 2, 5, 2)
+ self.key.setFont(theme.mono_font(theme.TYPE["small"]))
+ self.hint.hide()
+
+ def sizeHint(self):
+ return QSize(self.key.fontMetrics().horizontalAdvance(self.key.text()) + 10,
+ 24 if not self.armed else 56)
+
+ def heightForWidth(self, width):
+ return 24 if not self.armed else 56
+
+ def set_value(self, value):
+ super().set_value(value)
+ if not value and not self.armed:
+ self.key.setText("Set a key")
+ self._reflect_style()
+
+ def _reflect_style(self):
+ chip = bool(self.value) or self.armed
+ widgets.set_role(self, "keycap-live" if self.armed else "keycap" if chip else "plain")
+ self.key.setFont(theme.mono_font(theme.TYPE["small"]) if chip else theme.font(theme.TYPE["note"]))
+ if chip:
+ self.setStyleSheet("")
+ else:
+ _quiet_style(self)
+
+ def _toggle(self):
+ super()._toggle()
+ self._reflect_style()
+ self.hint.setVisible(self.armed)
+ self.updateGeometry()
+
+ def cancel(self):
+ super().cancel()
+ self._reflect_style()
+ self.hint.hide()
+ self.updateGeometry()
+
+ def eventFilter(self, watched, event):
+ if self.armed and event.type() == QEvent.Type.KeyPress and event.key() == Qt.Key.Key_Escape:
+ self.cancel()
+ return True
+ return super().eventFilter(watched, event)
+
+
+class _Cycle(QCheckBox):
+ def paintEvent(self, event):
+ super().paintEvent(event)
+ if not self.isChecked():
+ return
+ option = QStyleOptionButton()
+ self.initStyleOption(option)
+ rect = self.style().subElementRect(QStyle.SubElement.SE_CheckBoxIndicator, option, self)
+ painter = QPainter(self)
+ painter.setRenderHint(QPainter.RenderHint.Antialiasing)
+ pen = QPen(QColor(theme.colour("ground")), 1.8)
+ pen.setCapStyle(Qt.PenCapStyle.RoundCap)
+ painter.setPen(pen)
+ points = [QPointF(rect.x() + rect.width() * x, rect.y() + rect.height() * y)
+ for x, y in ((.25, .52), (.43, .7), (.78, .28))]
+ painter.drawLine(points[0], points[1])
+ painter.drawLine(points[1], points[2])
+ painter.end()
+
+
+class LedgerRow(QFrame):
+ def minimumSizeHint(self):
+ return QSize(0, self.grid.minimumSize().height())
+
+ def __init__(self, peer, owner):
+ super().__init__()
+ self.peer, self.owner, self.selected, self.narrow = peer, owner, False, None
+ self.setProperty("ledger_role", "row")
+ self.setProperty("vernier", "plain")
+ self.setMinimumWidth(0)
+ self.grid = QGridLayout(self)
+ self.grid.setContentsMargins(12, 12, 0, 12)
+ self.grid.setHorizontalSpacing(16)
+ self.grid.setVerticalSpacing(8)
+ self.cells = []
+ for _ in range(4):
+ cell = QWidget(self)
+ cell.setProperty("vernier", "plain")
+ cell.setProperty("ledger_role", "cell")
+ cell.setMinimumWidth(0)
+ self.cells.append(cell)
+ self.machine, self.edge, self.corner_cell, self.keys = self.cells
+ self.machine.setProperty("ledger_role", "rowheader")
+ machine = QVBoxLayout(self.machine)
+ machine.setContentsMargins(0, 0, 0, 0)
+ machine.setSpacing(2)
+ machine.setSizeConstraint(machine.SizeConstraint.SetMinimumSize)
+ self.name = _Name()
+ self.name.installEventFilter(self)
+ self.machine.installEventFilter(self)
+ self.status = widgets.label("", "small", wrap=True)
+ self.status.installEventFilter(self)
+ status_line = QHBoxLayout()
+ status_line.setSpacing(6)
+ self.dot = QLabel()
+ self.dot.setFixedSize(6, 6)
+ status_line.addWidget(self.dot, 0, Qt.AlignmentFlag.AlignVCenter)
+ status_line.addWidget(self.status, 1)
+ self.edit = QLineEdit()
+ self.edit.setMinimumWidth(0)
+ self.edit.hide()
+ self.edit.returnPressed.connect(self.save_name)
+ self.edit.installEventFilter(self)
+ self.rename_hint = widgets.label("Return saves, Escape cancels · Only on this PC", "small", wrap=True)
+ self.rename_hint.hide()
+ machine.addWidget(self.name)
+ machine.addWidget(self.edit)
+ machine.addWidget(self.rename_hint)
+ machine.addLayout(status_line)
+ actions = QHBoxLayout()
+ actions.setSpacing(10)
+ self.rename = _quiet("Rename", self.begin_rename)
+ self.leave = _quiet("Leave out", lambda: owner._canvas_left_out(peer, not self.left_out))
+ actions.addWidget(self.rename)
+ actions.addWidget(self.leave)
+ actions.addStretch()
+ machine.addLayout(actions)
+ self.edge_glyph = ScreenGlyph("edge", lambda third: owner._ledger_third(peer, third))
+ self.corner_glyph = ScreenGlyph("corner", lambda corner: owner._ledger_corner(peer, corner))
+ self.edge_text = _quiet("", lambda: owner._ledger_edge(peer))
+ self.edge_text.setMaximumHeight(16777215)
+ self.edge_text.setMinimumHeight(40)
+ text = QVBoxLayout(self.edge_text)
+ text.setContentsMargins(0, 0, 0, 0)
+ text.setSpacing(1)
+ text.setSizeConstraint(text.SizeConstraint.SetMinimumSize)
+ self.edge_value = widgets.label("", "body", wrap=True)
+ self.edge_detail = widgets.label("", "small", wrap=True)
+ for label in (self.edge_value, self.edge_detail):
+ label.setAttribute(Qt.WidgetAttribute.WA_TransparentForMouseEvents)
+ text.addWidget(label)
+ for cell, glyph, content in ((self.edge, self.edge_glyph, self.edge_text), (self.corner_cell, self.corner_glyph, None)):
+ box = QHBoxLayout(cell)
+ box.setContentsMargins(0, 0, 0, 0)
+ box.setSpacing(4)
+ box.addWidget(glyph, 0, Qt.AlignmentFlag.AlignTop)
+ if content is None:
+ content = QWidget()
+ content.setProperty("vernier", "plain")
+ texts = QVBoxLayout(content)
+ texts.setContentsMargins(0, 0, 0, 0)
+ texts.setSpacing(1)
+ self.corner_value = widgets.label("", "body", wrap=True)
+ self.corner_detail = widgets.label("", "small", wrap=True)
+ texts.addWidget(self.corner_value)
+ texts.addWidget(self.corner_detail)
+ box.addWidget(content, 1, Qt.AlignmentFlag.AlignTop)
+ keys = QVBoxLayout(self.keys)
+ keys.setContentsMargins(0, 0, 0, 0)
+ keys.setSpacing(4)
+ self.cycle = _Cycle()
+ self.cycle.setFont(theme.font(theme.TYPE["body"]))
+ self.cycle.setToolTip("In the shortcut's cycle")
+ self.cycle.toggled.connect(lambda on: owner._set_shortcut_cycle(peer, on))
+ keys.addWidget(self.cycle)
+ jump = QHBoxLayout()
+ jump.setSpacing(5)
+ jump.addWidget(widgets.label("Jump", "small"))
+ self.jump = _Jump(lambda value: owner._ledger_jump(peer, value), owner._jump_arming)
+ jump.addWidget(self.jump, 0, Qt.AlignmentFlag.AlignLeft)
+ self.clear = _quiet("Clear", lambda: owner._ledger_jump(peer, ""))
+ self.clear.setAccessibleName("Clear jump key")
+ jump.addWidget(self.clear)
+ jump.addStretch()
+ keys.addLayout(jump)
+ keys.addStretch()
+ self.effect = QGraphicsOpacityEffect(self)
+ self.setGraphicsEffect(self.effect)
+ self.reflow(False)
+
+ def reflow(self, narrow):
+ if self.narrow == narrow:
+ return
+ self.narrow = narrow
+ for cell in self.cells:
+ self.grid.removeWidget(cell)
+ for col in range(4):
+ self.grid.setColumnMinimumWidth(col, 0)
+ self.grid.setColumnStretch(col, 0)
+ if narrow:
+ self.grid.addWidget(self.machine, 0, 0, 1, 2)
+ self.grid.addWidget(self.edge, 1, 0)
+ self.grid.addWidget(self.corner_cell, 1, 1)
+ self.grid.addWidget(self.keys, 2, 0, 1, 2)
+ self.grid.setColumnStretch(0, 1)
+ self.grid.setColumnStretch(1, 1)
+ else:
+ for index, (cell, minimum, stretch) in enumerate(zip(self.cells, (132, 124, 104, 128), (13, 10, 9, 10))):
+ self.grid.addWidget(cell, 0, index)
+ self.grid.setColumnMinimumWidth(index, minimum)
+ self.grid.setColumnStretch(index, stretch)
+
+ def reflect(self, settings, entry, name, side, linked, selected, trigger, labels, legacy=""):
+ self._reflection = (settings, entry, name, side, linked, selected, trigger, labels, legacy)
+ for button in (self.rename, self.leave, self.edge_text, self.clear):
+ _quiet_style(button)
+ self.entry, self.left_out, self.selected = entry, bool(entry.get("left_out")), selected
+ self.setAccessibleName(name)
+ self.machine.setAccessibleName(name)
+ self.name.set_name(name)
+ self.name.setStyleSheet(f"color: {theme.colour('ink' if linked and not self.left_out else 'ink_2')}")
+ platform = {"windows": "Windows", "macos": "macOS", "linux": "Linux"}.get(entry.get("platform"), "Computer")
+ status = "Left out" if self.left_out else "Linked" if linked else "Offline, ways kept"
+ self.status.setText(legacy or f"{platform} · {status}")
+ self.status.setStyleSheet(f"color: {theme.colour('amber' if legacy else 'ink_3')}")
+ self.dot.setStyleSheet(f"background: {theme.colour('amber' if legacy else 'signal' if linked and not self.left_out else 'ink_3')}; border-radius: 3px;")
+ self.status.setAccessibleDescription("Linked" if linked else status)
+ self.leave.setText("Put back" if self.left_out else "Leave out")
+ self.leave.setToolTip("Left out machines stay paired and linked. The shortcut, menu and clipboard still reach them." if self.left_out else "Leave this machine out of crossings")
+ held = ways.ways(settings, self.peer)
+ picked = ways.picked_thirds(held["methods"], held["parts"])
+ on = bool(picked) and bool(side)
+ self.edge_glyph.reflect(side, picked if on else (), left_out=self.left_out)
+ self.edge_value.setText(ways.edge_form_detail(side, held["methods"], held["parts"], here="This PC") if on else "Off")
+ self.edge_value.setStyleSheet(f"color: {theme.colour('ink' if on else 'ink_3')}")
+ self.edge_detail.setText(f"{side} edge{' off' if not on else ''}" if side else "place it on the map")
+ self.edge_text.setEnabled(bool(side) and not self.left_out)
+ self.edge_text.setToolTip("Left out: Put back to change its ways" if self.left_out else "Edge: click to turn it off" if on else f"Edge: click for the whole {side} edge")
+ self.edge_text.setAccessibleName(f"Edge, {'whole ' + side + ' edge' if len(picked) == 3 and side else self.edge_value.text().lower()}")
+ corner = held["corner"] if "corner" in held["methods"] else ""
+ holders = {c: labels.get(holder, "Another machine") for c in ways.CORNERS
+ if (holder := ways.corner_holder(settings, c, exclude=self.peer))}
+ self.corner_glyph.reflect(corner=corner, holders=holders, left_out=self.left_out)
+ self.corner_value.setText(corner.replace("_", " ").capitalize() if corner else "None")
+ self.corner_value.setStyleSheet(f"color: {theme.colour('ink' if corner else 'ink_3')}")
+ self.corner_detail.setText("diagonal push" if corner else "click a dot")
+ self.cycle.blockSignals(True)
+ self.cycle.setText(trigger)
+ self.cycle.setChecked(entry.get("shortcut_cycle", True))
+ self.cycle.blockSignals(False)
+ self.jump.set_value(entry.get("jump_key", ""))
+ self.jump.setToolTip(f"Press {self.jump.key.text()} to send input to {name}; press again to bring it home." if self.jump.value else f"Choose a key combination to jump to {name} and back.")
+ self.clear.setVisible(bool(self.jump.value))
+ self.effect.setOpacity(.5 if self.left_out or not linked else 1)
+ self.update()
+
+ def refresh_colours(self):
+ if hasattr(self, "_reflection"):
+ self.reflect(*self._reflection)
+
+ def begin_rename(self):
+ self.edit.setText(self.entry.get("label") or self.entry.get("name") or "")
+ self.name.hide()
+ self.edit.show()
+ self.rename_hint.show()
+ self.edit.setFocus()
+ self.edit.selectAll()
+
+ def save_name(self):
+ self.owner._rename_canvas_peer(self.peer, self.edit.text().strip()[:64])
+ self.cancel_name()
+
+ def cancel_name(self):
+ self.edit.hide()
+ self.rename_hint.hide()
+ self.name.show()
+
+ def eventFilter(self, watched, event):
+ if watched is self.edit and event.type() == QEvent.Type.KeyPress and event.key() == Qt.Key.Key_Escape:
+ self.cancel_name()
+ return True
+ if watched in (self.machine, self.name, self.status) and event.type() == QEvent.Type.MouseButtonPress:
+ self.owner._choose_machine(self.peer)
+ return True
+ return super().eventFilter(watched, event)
+
+ def paintEvent(self, event):
+ super().paintEvent(event)
+ painter = QPainter(self)
+ painter.setPen(QPen(QColor(theme.colour("rule")), 1))
+ painter.drawLine(0, self.height() - 1, self.width(), self.height() - 1)
+ if self.selected:
+ painter.fillRect(0, 12, 3, max(1, self.height() - 24), QColor(theme.colour("signal")))
+ painter.end()
+
+
+class CrossingLedger(QWidget):
+ def minimumSizeHint(self):
+ return QSize(0, self.column.minimumSize().height())
+
+ def __init__(self, owner):
+ super().__init__()
+ self.owner, self.rows, self.narrow = owner, {}, False
+ self.setProperty("ledger_role", "table")
+ self.setProperty("vernier", "plain")
+ self.setAccessibleName("How each machine is reached")
+ self.setMinimumWidth(0)
+ self.column = QVBoxLayout(self)
+ self.column.setContentsMargins(0, 0, 0, 0)
+ self.column.setSpacing(0)
+ self.header = QWidget()
+ self.header.setProperty("vernier", "plain")
+ head = QGridLayout(self.header)
+ head.setContentsMargins(12, 0, 0, 8)
+ head.setHorizontalSpacing(16)
+ for index, (title, minimum, stretch) in enumerate(zip(("Machine", "Edge", "Corner", "Keys"), (132, 124, 104, 128), (13, 10, 9, 10))):
+ label = widgets.Eyebrow(title)
+ label.setProperty("ledger_role", "columnheader")
+ label.setAccessibleName(title)
+ head.addWidget(label, 0, index)
+ head.setColumnMinimumWidth(index, minimum)
+ head.setColumnStretch(index, stretch)
+ self.header.setStyleSheet(f"border-bottom: 1px solid {theme.colour('rule')};")
+ self.column.addWidget(self.header)
+
+ def cancel_recording(self):
+ for row in self.rows.values():
+ row.jump.cancel()
+
+ def refresh_colours(self):
+ self.header.setStyleSheet(f"border-bottom: 1px solid {theme.colour('rule')};")
+
+ def reflect(self, settings, layout, labels, chosen, live, trigger, legacy=None):
+ self.header.setStyleSheet(f"border-bottom: 1px solid {theme.colour('rule')};")
+ entries = {p["id"]: p for p in settings.get("peers", [])}
+ order = sorted(entries, key=lambda p: (0, layout[p]["x"], layout[p]["y"]) if p in layout else (1, 0, 0))
+ for peer in self.rows.keys() - entries.keys():
+ row = self.rows.pop(peer)
+ row.jump.cancel()
+ self.column.removeWidget(row)
+ row.deleteLater()
+ for index, peer in enumerate(order):
+ row = self.rows.get(peer)
+ if row is None:
+ row = LedgerRow(peer, self.owner)
+ self.rows[peer] = row
+ row.reflow(self.narrow)
+ if self.column.indexOf(row) != index + 1:
+ self.column.insertWidget(index + 1, row)
+ own = layout.get(settings.get("machine_id"))
+ tile = layout.get(peer)
+ contact = ways._rect_contact(own, tile) if own and tile else None
+ side = contact[0] if contact and contact[0] != "corner" else ""
+ row.reflect(settings, entries[peer], labels.get(peer, "Other machine"), side, live(peer), chosen == peer, trigger, labels, (legacy or {}).get(peer, ""))
+ self.setVisible(bool(entries))
+
+ def resizeEvent(self, event):
+ super().resizeEvent(event)
+ narrow = self.width() < 620
+ if narrow != self.narrow:
+ self.narrow = narrow
+ self.header.setVisible(not narrow)
+ for row in self.rows.values():
+ row.reflow(narrow)
diff --git a/win_app/desktop_portal.py b/win_app/desktop_portal.py
index 05eade3..bcac384 100644
--- a/win_app/desktop_portal.py
+++ b/win_app/desktop_portal.py
@@ -32,6 +32,7 @@ _zones: List[Rect] = [] # the InputCapture session's
_regions: List[Rect] = [] # the RemoteDesktop absolute pointer's
_mover: Optional[Callable[[int, int], None]] = None
_captured = False
+_screens: List[Rect] = []
def set_zones(zones: List[Rect]) -> None:
@@ -89,16 +90,27 @@ def clamp_to(displays: List[Rect], x: float, y: float) -> Tuple[int, int]:
return best[1]
-def _qt_screens() -> List[Rect]:
+def refresh_qt_screens() -> None:
+ """Capture Qt geometry on the GUI thread for link and input threads."""
+ global _screens
try:
+ from PySide6.QtCore import QThread
from PySide6.QtGui import QGuiApplication
- if QGuiApplication.instance() is None:
- return []
- return [Rect(g.x(), g.y(), g.width(), g.height()) for g in (screen.geometry() for screen in QGuiApplication.screens())]
+ app = QGuiApplication.instance()
+ if app is None or QThread.currentThread() != app.thread():
+ return
+ screens = [Rect(g.x(), g.y(), g.width(), g.height())
+ for g in (screen.geometry() for screen in app.screens())]
+ with _lock:
+ _screens = screens
except Exception:
LOGGER.exception("Could not read the displays from Qt")
- return []
+
+
+def _qt_screens() -> List[Rect]:
+ with _lock:
+ return list(_screens)
def _displays() -> List[Rect]:
@@ -111,6 +123,10 @@ def monitors() -> List[Rect]:
return _displays() or [Rect(0, 0, 1920, 1080)]
+def display_map() -> dict:
+ return {str(index): rect for index, rect in enumerate(_qt_screens())}
+
+
def cursor_position() -> Tuple[int, int]:
found = position()
if found is not None:
diff --git a/win_app/desktop_win.py b/win_app/desktop_win.py
index 36b2cc7..2e46f47 100644
--- a/win_app/desktop_win.py
+++ b/win_app/desktop_win.py
@@ -65,6 +65,10 @@ def monitors() -> List[Rect]:
return found
+def display_map() -> dict:
+ return {str(index): rect for index, rect in enumerate(monitors())}
+
+
def cursor_position() -> Tuple[int, int]:
_require()
point = POINT()
diff --git a/win_app/desktop_x11.py b/win_app/desktop_x11.py
index b452f8f..0d5dc23 100644
--- a/win_app/desktop_x11.py
+++ b/win_app/desktop_x11.py
@@ -87,6 +87,10 @@ def monitors() -> List[Rect]:
return [Rect(0, 0, geometry.width, geometry.height)]
+def display_map() -> dict:
+ return {str(index): rect for index, rect in enumerate(monitors())}
+
+
def cursor_position() -> Tuple[int, int]:
with _session() as conn:
pointer = conn.root.query_pointer()
diff --git a/win_app/diagram.py b/win_app/diagram.py
index 7a19bc4..31aecea 100644
--- a/win_app/diagram.py
+++ b/win_app/diagram.py
@@ -3,16 +3,21 @@ strip in Resistance. Geometry is pages_win's, pure and tested; this file only pa
from __future__ import annotations
-from PySide6.QtCore import QPointF, QRectF, QSize, Qt
-from PySide6.QtGui import QColor, QFontMetrics, QPainter, QPainterPath, QPen
-from PySide6.QtWidgets import QSizePolicy, QWidget
+import sys
+
+from PySide6.QtCore import QPointF, QRectF, QSize, Qt, QTimer
+from PySide6.QtGui import QColor, QFontMetrics, QPainter, QPainterPath, QPen, QAccessible, QAccessibleAnnouncementEvent
+from PySide6.QtWidgets import QLineEdit, QPushButton, QSlider, QSizePolicy, QToolTip, QWidget
import motion
import pages_win
import theme
import tokens
+from core import ways
+from core.resistance_strip import MAX_RESISTANCE, resistance_x
OTHER = "Other machine"
+ATLAS_TILE = (160, 100)
SCREEN = (120.0, 75.0)
GAP = 14.0
PAD = 8.0
@@ -23,6 +28,9 @@ CORNER = 16.0
# The marks of the machines the page is not showing: there, but not the ones being edited.
QUIET = "ink_3"
QUIET_ALPHA = 0.55
+# The clear space centred on each third boundary of the selected machine's seam and tracks.
+THIRD_GAP = 2.0
+CYCLE_BOX = 16.0
def _colour(name: str, alpha: float = 1.0) -> QColor:
@@ -232,6 +240,7 @@ class ArrangementDiagram(QWidget):
self._cap(painter, top, level)
painter.end()
+
def _screen(self, painter, rect: QRectF, name, fill, line: QColor, ink: QColor, radius) -> None:
painter.setPen(QPen(line, 1.0))
painter.setBrush(_colour(fill))
@@ -313,129 +322,1077 @@ class ArrangementDiagram(QWidget):
painter.setOpacity(1.0)
-class PushStrip(QWidget):
- """A band of this screen's edge: the edge line, the other machine beyond it, and a `signal` fill from the
- edge as deep as the resistance, with the pointer at its end. A change slides the fill and the
- pointer to the new depth, lit bright, and the light then settles."""
+def outcome_for_tile(state, crosses, is_own=False, other_name=""):
+ if is_own:
+ return ""
+ if state in ("between", "set-elsewhere", "set_elsewhere") and other_name:
+ return f"Crosses to {other_name}" if state == "between" else f"Set on {other_name}"
+ if state in ("between", "set-elsewhere", "set_elsewhere"):
+ return "Set elsewhere"
+ if state == "gap" or not crosses:
+ return "Drag to connect" if state == "gap" else "Edge off"
+ return "Crosses"
- HEIGHT = 44
- MAC = 64.0
- SETTLE_MS = 700
- def __init__(self, parent: QWidget | None = None) -> None:
+class AtlasCanvas(QWidget):
+ """One tile per paired machine, laid out around this screen with shared edge snaps."""
+
+ def __init__(self, parent=None, on_drop=None, on_rename=None, on_leave_out=None, on_cycle=None,
+ on_select=None, on_third=None):
super().__init__(parent)
+ self.on_drop = on_drop or (lambda *_: None)
+ self.on_rename = on_rename or (lambda *_: None)
+ self.on_leave_out = on_leave_out or (lambda *_: None)
+ self.on_cycle = on_cycle or (lambda *_: None)
+ self.on_select = on_select or (lambda *_: None)
+ self.on_third = on_third or (lambda *_: None)
+ self.on_announce = None
+ self.on_hint = None
+ self.on_rename_state = None
+ self.setMinimumHeight(268)
+ self.setMaximumHeight(268)
+ self.setFocusPolicy(Qt.FocusPolicy.StrongFocus)
+ self.setMouseTracking(True)
+ self.setAccessibleName("Crossing layout")
+ self.setToolTip("")
+ self.tiles = {}
+ self.labels = {}
+ self.states = {}
+ self.selected = None
+ self.own_id = None
+ self.shelf_ids = set()
+ self.left_out_ids = set()
+ self.in_use = {}
+ self.cycle = {}
+ self.cycle_mode = "last"
+ self.capable = set()
+ self._drag = None
+ self._drag_display = None
+ self._display_offset_start = None
+ self._dragged_display = False
+ self._split_on_release = False
+ self._group_on_release = False
+ self._keyboard_focus = False
+ self._hover = None
+ self._third_press = None
+ self.corner_marks = []
+ self.seam_paths = []
+ self.ledger_height = False
+ self._height_timer = QTimer(self)
+ self._height_timer.setSingleShot(True)
+ self._height_timer.timeout.connect(self._fit_ledger_height)
+ self._origin = None
+ self._scale = 1.0
+ self._bounds = (0, 0, 1, 1)
+ self._recentre_colours = None
+ self.recentre_button = QPushButton("Recentre", self)
+ self.recentre_button.setFont(theme.font(tokens.TYPE["note"]))
+ self.recentre_button.setFixedSize(76, 26)
+ self.recentre_button.clicked.connect(self.recentre)
+ self.recentre_button.setVisible(False)
+ self.recentre_button.installEventFilter(self)
+ self.rename_edit = QLineEdit(self)
+ self.rename_edit.setFont(theme.font(tokens.TYPE["body"]))
+ self.rename_edit.setFixedHeight(28)
+ self.rename_edit.setStyleSheet("QLineEdit { border-radius: 4px; padding: 3px 6px; }")
+ self._rename_peer = None
+ self.rename_edit.setVisible(False)
+ self.rename_edit.returnPressed.connect(self._save_rename)
+ self.rename_edit.installEventFilter(self)
+
+ def set_tiles(self, tiles, labels, states, selected, cycle_mode="last", cycle=None, capable=(), own_id=None,
+ rename_values=None):
+ self.tiles = {key: dict(tile) for key, tile in tiles.items()}
+ self.labels = dict(labels)
+ self.rename_values = dict(rename_values if rename_values is not None else labels)
+ self.states = {key: dict(state) for key, state in states.items()}
+ self.selected = selected if selected in tiles else next(iter(tiles), None)
+ self.cycle_mode = cycle_mode
+ self.cycle = dict(cycle or {})
+ self.capable = set(capable)
+ self.own_id = own_id
+ if own_id in self.tiles:
+ own_detail = self.states.get(own_id, {}).get("detail") or \
+ ("Linux" if sys.platform.startswith("linux") else "Windows")
+ self.states.setdefault(own_id, {}).update(
+ detail=own_detail, linked=True
+ )
+ description = [self.labels.get(peer, OTHER) for peer in self.tiles]
+ own_detail = self.states.get(own_id, {}).get("detail", "")
+ if own_id in self.tiles and own_detail:
+ description.append(own_detail)
+ self.setAccessibleDescription("; ".join(description))
+ self._geometry()
+ if self._drag is None:
+ self.update()
+
+ def set_left_out(self, peers, in_use=None, dormant=()):
+ self.left_out_ids = set(peers)
+ self.in_use = dict(in_use or {})
+ self.shelf_ids = self.left_out_ids | set(dormant) | {peer for peer, enabled in self.in_use.items() if enabled is False}
+ self._geometry()
+ self.update()
+
+ def set_cycle(self, peer, enabled):
+ self.cycle[peer] = bool(enabled)
+ self.on_cycle(peer, bool(enabled))
+ self.update()
+
+ def put_back(self, peer):
+ self.on_leave_out(peer, False)
+
+ def leave_out(self, peer):
+ self.on_leave_out(peer, True)
+
+ def animate_tile(self, peer, target, done=None):
+ current = self.tiles[peer]
+ start = (current["x"], current["y"])
+ end = (target["x"], target["y"])
+
+ def apply(position):
+ self.tiles[peer] = {**current, "x": round(position[0]), "y": round(position[1])}
+ self._geometry()
+ self.update()
+
+ motion.animate(self, f"tile:{peer}", start, end, apply, done=done)
+
+ def tile_rect(self, peer):
+ tile = self.tiles[peer]
+ x, y, w, h = (tile[k] for k in ("x", "y", "w", "h"))
+ left, top, _width, _height = self._bounds
+ return QRectF((x-left)*self._scale + self._origin.x(), (y-top)*self._scale + self._origin.y(),
+ w*self._scale, h*self._scale)
+
+ def display_rect(self, peer, display):
+ frame = next(frame for frame in ways._display_frames(self.tiles[peer]) if frame["display"] == display)
+ left, top, _width, _height = self._bounds
+ return QRectF((frame["x"]-left)*self._scale + self._origin.x(),
+ (frame["y"]-top)*self._scale + self._origin.y(),
+ frame["w"]*self._scale, frame["h"]*self._scale)
+
+ def display_at(self, point):
+ for peer in reversed(list(self.tiles)):
+ if peer in self.shelf_ids or not self.tiles[peer].get("displays"):
+ continue
+ for frame in reversed(ways._display_frames(self.tiles[peer])):
+ if self.display_rect(peer, frame["display"]).contains(point):
+ return peer, frame["display"]
+ return None, None
+
+ def _geometry(self):
+ self._sync_recentre()
+ if self._drag:
+ return
+ visible = {key: tile for key, tile in self.tiles.items() if key not in self.shelf_ids}
+ if not visible:
+ self._bounds, self._scale = (0, 0, 1, 1), 1.0
+ self._origin = QPointF(12, 12)
+ return
+ frames = [frame for tile in visible.values() for frame in ways._display_frames(tile)]
+ left = min([tile["x"] for tile in visible.values()] + [frame["x"] for frame in frames])
+ top = min([tile["y"] for tile in visible.values()] + [frame["y"] for frame in frames])
+ right = max([tile["x"] + tile["w"] for tile in visible.values()] +
+ [frame["x"] + frame["w"] for frame in frames])
+ bottom = max([tile["y"] + tile["h"] for tile in visible.values()] +
+ [frame["y"] + frame["h"] for frame in frames])
+ cx, cy = (left+right)/2, (top+bottom)/2
+ self._bounds = (cx, cy, right-left, bottom-top)
+ room_w, room_h = max(1, self.width()-24), max(1, self.height()-24)
+ self._scale = min(room_w/max(1, right-left), room_h/max(1, bottom-top), 1.0)
+ self._origin = QPointF(self.width()/2, self.height()/2)
+
+ def resizeEvent(self, event):
+ self._geometry()
+ if self.ledger_height:
+ self._height_timer.start(0)
+ super().resizeEvent(event)
+
+ def _fit_ledger_height(self):
+ target = 220 if self.width() < 620 else 260
+ if self.minimumHeight() != target or self.maximumHeight() != target:
+ self.setFixedHeight(target)
+ self.updateGeometry()
+
+ def _recentre_side(self):
+ own_id = self._own_id()
+ if (own_id not in self.tiles or self.selected not in self.tiles
+ or self.selected == own_id or self.selected in self.shelf_ids):
+ return None
+ own, tile = self.tiles[own_id], self.tiles[self.selected]
+ contact = ways._rect_contact(own, tile)
+ if contact and contact[0] != "corner":
+ return contact[0]
+ targets = {side: ways.place_beside({own_id: own, self.selected: tile},
+ own_id, self.selected, side) for side in ways.EDGES}
+ return min(targets, key=lambda side: (targets[side]["x"]-tile["x"])**2
+ + (targets[side]["y"]-tile["y"])**2)
+
+ def _can_recentre(self):
+ side = self._recentre_side()
+ if side is None:
+ return False
+ own_id = self._own_id()
+ tile = self.tiles[self.selected]
+ centred = ways.place_beside({own_id: self.tiles[own_id], self.selected: tile},
+ own_id, self.selected, side)
+ return (tile["x"], tile["y"]) != (centred["x"], centred["y"])
+
+ def _sync_recentre(self):
+ button = self.recentre_button
+ button.move(self.width()-button.width()-10, 10)
+ button.setAccessibleName(f"Recentre {self.labels.get(self.selected, OTHER)}")
+ colours = tuple(theme.colour(name) for name in ("panel", "ink_3", "ink", "edge", "ink_2"))
+ if colours != self._recentre_colours:
+ panel, ink_3, ink, edge, ink_2 = colours
+ button.setStyleSheet(
+ f"QPushButton {{ background: {panel}; color: {ink_3};"
+ " border: 1px solid transparent; border-radius: 4px; padding: 3px 8px; }"
+ f"QPushButton:hover {{ color: {ink}; border-color: {edge}; }}"
+ f"QPushButton:focus {{ border-color: {ink_2}; }}")
+ self._recentre_colours = colours
+ button.setVisible(self._can_recentre())
+ button.raise_()
+
+ def _commit_tile(self, peer):
+ accepted = self.on_drop({key: dict(tile) for key, tile in self.tiles.items()}, peer) is not False
+ if accepted:
+ self._announce_move(peer)
+ self._geometry()
+ self.update()
+
+ def recentre(self):
+ if self._drag is not None or not self._can_recentre():
+ return
+ peer = self.selected
+ active = {key: tile for key, tile in self.tiles.items() if key not in self.shelf_ids}
+ target = ways.place_beside(active, self._own_id(), peer, self._recentre_side())
+ self.animate_tile(peer, target, done=lambda: self._commit_tile(peer))
+
+ def snap_preview(self):
+ if not self._drag or self._drag == self._own_id() or self._drag_display is not None:
+ return None
+ tile = self.tiles[self._drag]
+ others = {key: value for key, value in self.tiles.items()
+ if key != self._drag and key not in self.shelf_ids}
+ radius = 12 / max(self._scale, 0.001)
+ snapped = ways.snap_position(tile, self._own_id(), others, radius=radius)
+ if ((snapped["x"], snapped["y"]) != (tile["x"], tile["y"])
+ and ways.within_snap_radius(tile, snapped, self._own_id(), others, radius)):
+ return {**tile, **snapped}
+ return None
+
+ def _paint_contact(self, painter, tile, rect, contact, colour="signal", alpha=1.0, breaks=(), screen=None):
+ side, start, end = contact
+ width = 4.0 if colour == "signal" else 2.0
+ painter.setBrush(Qt.BrushStyle.NoBrush)
+ pen = QPen(_colour(colour, alpha), width,
+ Qt.PenStyle.SolidLine if colour == "signal" else Qt.PenStyle.DashLine)
+ pen.setCapStyle(Qt.PenCapStyle.RoundCap)
+ painter.setPen(pen)
+ if side == "corner":
+ x = self._edge_px(tile, rect, screen or tile, "left" if start.endswith("left") else "right")
+ y = self._edge_px(tile, rect, screen or tile, "top" if start.startswith("top") else "bottom")
+ painter.setPen(Qt.PenStyle.NoPen)
+ painter.setBrush(_colour(colour, alpha))
+ painter.drawEllipse(QPointF(x, y), 3.5, 3.5)
+ else:
+ self._paint_seam(painter, tile, rect, contact, alpha, width, breaks, screen)
+
+ def _paint_seam(self, painter, tile, rect, contact, alpha, width, breaks, screen=None):
+ line = self.seam_line(tile, rect, contact, breaks, width, screen)
+ if line is None:
+ return
+ one, two = line
+ self.seam_paths.append((contact[0], one, two, alpha, width))
+ painter.drawLine(one, two)
+
+ def seam_line(self, tile, rect, contact, breaks=(), width=0.0, screen=None):
+ """Pixel endpoints shared by the seam and its ghost track, including corner halos, on the edge
+ of `screen` (one of the tile's display frames) or of the tile. An end at one of `breaks`, a third
+ boundary in layout units, stops short enough that a round cap of `width` leaves half of THIRD_GAP
+ clear; a piece with such an end and no length left is None."""
+ side, start, end = contact
+ vertical = side in ("left", "right")
+ origin = tile["y"] if vertical else tile["x"]
+ low = (rect.top() if vertical else rect.left()) + (start - origin) * self._scale
+ high = (rect.top() if vertical else rect.left()) + (end - origin) * self._scale
+ first, last = (rect.top(), rect.bottom()) if vertical else (rect.left(), rect.right())
+ low_inset = high_inset = min(2.0, max(0.0, (high - low) / 2))
+ broken = False
+ if any(abs(start - point) < 1e-6 for point in breaks):
+ low_inset, broken = THIRD_GAP / 2 + width / 2, True
+ if any(abs(end - point) < 1e-6 for point in breaks):
+ high_inset, broken = THIRD_GAP / 2 + width / 2, True
+ if broken and high - high_inset <= low + low_inset:
+ return None
+ if tile is self.tiles.get(self._own_id()):
+ corners = {data.get("corner_way") for peer, data in self.states.items()
+ if peer in self.tiles and peer not in self.shelf_ids}
+ near, far = {"top": ("top_left", "top_right"), "bottom": ("bottom_left", "bottom_right"),
+ "left": ("top_left", "bottom_left"), "right": ("top_right", "bottom_right")}[side]
+ if near in corners and abs(low - first) < 2.1:
+ low_inset = 11
+ if far in corners and abs(high - last) < 2.1:
+ high_inset = 11
+ fixed = self._edge_px(tile, rect, screen or tile, side)
+ return ((QPointF(fixed, low + low_inset), QPointF(fixed, max(low + low_inset, high - high_inset)))
+ if vertical else (QPointF(low + low_inset, fixed), QPointF(max(low + low_inset, high - high_inset), fixed)))
+
+ def _edge_px(self, tile, rect, screen, side):
+ """Where `screen`'s `side`, in layout units, falls in pixels across `tile`'s `rect`."""
+ if side in ("left", "right"):
+ return rect.left() + (screen["x"] + (screen["w"] if side == "right" else 0) - tile["x"]) * self._scale
+ return rect.top() + (screen["y"] + (screen["h"] if side == "bottom" else 0) - tile["y"]) * self._scale
+
+ def _side_contacts(self, peer):
+ """[(screen, contact)]: this machine's display frames that meet `peer`'s along a side, as the
+ engine finds them; thirds are measured along `screen`, the pointer's own display."""
+ return ways.side_contacts(self.tiles[self._own_id()], self.tiles[peer])
+
+ def _third_segment_at(self, point):
+ own_id, peer = self._own_id(), self.selected
+ if (own_id not in self.tiles or peer not in self.tiles or peer == own_id
+ or peer in self.shelf_ids):
+ return None
+ own_rect, own = self.tile_rect(own_id), self.tiles[own_id]
+ for screen, contact in self._side_contacts(peer):
+ side = contact[0]
+ edge = self._edge_px(own, own_rect, screen, side)
+ for third, _side, low, high in ways.third_stretches(contact, screen):
+ if side in ("left", "right"):
+ y1 = own_rect.top() + (low - own["y"]) * self._scale
+ y2 = own_rect.top() + (high - own["y"]) * self._scale
+ hit = abs(point.x() - edge) <= 5 and y1 <= point.y() <= y2
+ else:
+ x1 = own_rect.left() + (low - own["x"]) * self._scale
+ x2 = own_rect.left() + (high - own["x"]) * self._scale
+ hit = abs(point.y() - edge) <= 5 and x1 <= point.x() <= x2
+ if hit:
+ return peer, third, side
+ return None
+
+ def _third_at(self, point):
+ hit = self._third_segment_at(point)
+ return hit[:2] if hit else None
+
+ def _third_tooltip(self, peer, third, side):
+ picked = self.states.get(peer, {}).get("thirds", [])
+ name = ways.part_names(side)[third]
+ return f"{name} third: click to {'leave it out' if third in picked else 'turn it on'}"
+
+ @staticmethod
+ def _paint_corner_pad(painter, rect, corner, opacity):
+ x = rect.left() if corner.endswith("left") else rect.right()
+ y = rect.top() if corner.startswith("top") else rect.bottom()
+ painter.setPen(Qt.PenStyle.NoPen)
+ painter.setBrush(_colour("ground"))
+ painter.drawRoundedRect(QRectF(x - 11, y - 11, 22, 22), 5, 5)
+ painter.setBrush(_colour("signal", opacity))
+ painter.drawRoundedRect(QRectF(x - 8, y - 8, 16, 16), 4, 4)
+ dx = 1 if corner.endswith("left") else -1
+ dy = 1 if corner.startswith("top") else -1
+ pen = QPen(_colour("ground", opacity), 1.8)
+ pen.setCapStyle(Qt.PenCapStyle.RoundCap)
+ painter.setPen(pen)
+ point = QPointF(x - 3 * dx, y - 3 * dy)
+ painter.drawLine(point, QPointF(point.x() + 7 * dx, point.y()))
+ painter.drawLine(point, QPointF(point.x(), point.y() + 7 * dy))
+
+ def _paint_third_track(self, painter, own, rect, stretch, breaks=(), screen=None):
+ _third, side, low, high = stretch
+ pen = QPen(_colour("signal", 0.3), 2.0)
+ pen.setCapStyle(Qt.PenCapStyle.RoundCap)
+ painter.setPen(pen)
+ self._paint_seam(painter, own, rect, (side, low, high), .3, 2.0, breaks, screen)
+
+ @staticmethod
+ def _title_top(rect):
+ return rect.top()+7 if rect.height() >= 56 else rect.center().y()-11
+
+ def _shows_cycle(self, peer):
+ return self.cycle_mode == "ticked" and peer != self._own_id() and peer not in self.shelf_ids
+
+ @staticmethod
+ def _cycle_box(rect):
+ """The shortcut-cycle tick: its own column at the right end of the name's line, or in the
+ bottom-right corner of a tile 44 to 56pt tall, under the name."""
+ if 44 <= rect.height() < 56:
+ return QRectF(rect.right() - 8 - CYCLE_BOX, rect.bottom() - 4 - CYCLE_BOX, CYCLE_BOX, CYCLE_BOX)
+ return QRectF(rect.right() - 8 - CYCLE_BOX, AtlasCanvas._title_top(rect) + 11 - CYCLE_BOX/2,
+ CYCLE_BOX, CYCLE_BOX)
+
+ @staticmethod
+ def _cycle_hit_rect(rect):
+ return AtlasCanvas._cycle_box(rect).adjusted(-4, -4, 4, 4)
+
+ def _title_rect(self, peer, rect):
+ """The name's text rect. Beside the shortcut-cycle tick the name stays centred on the tile while
+ it fits the room left symmetric by the tick, else takes the room left of the tick; a tile 44 to
+ 56pt tall puts the name on its own row above the tick, 20pt tall so a 44pt tile still fits both."""
+ if not self._shows_cycle(peer):
+ return QRectF(rect.left()+8, self._title_top(rect), max(1, rect.width()-16), 22)
+ if 44 <= rect.height() < 56:
+ return QRectF(rect.left()+8, rect.top()+4, max(1, rect.width()-16), 20)
+ room = 8 + CYCLE_BOX + 6
+ label = self.labels.get(peer, f"Machine · {peer[-6:]}")
+ if (rect.height() >= 56 and QFontMetrics(theme.font(tokens.TYPE["body"], 650)).horizontalAdvance(label)
+ <= rect.width() - 2*room):
+ return QRectF(rect.left()+room, self._title_top(rect), rect.width()-2*room, 22)
+ return QRectF(rect.left()+8, self._title_top(rect), max(1, self._cycle_box(rect).left()-6-rect.left()-8), 22)
+
+ def paintEvent(self, _event):
+ self._geometry()
+ self.seam_paths = []
+ painter = QPainter(self)
+ painter.setRenderHint(QPainter.RenderHint.Antialiasing)
+ painter.setPen(QPen(_colour("edge"), 1.0))
+ painter.setBrush(_colour("ground"))
+ painter.drawRoundedRect(QRectF(0.5, 0.5, self.width()-1, self.height()-1), 4, 4)
+ own_id = self._own_id()
+ if own_id in self.tiles:
+ own_rect = self.tile_rect(own_id)
+ painter.setPen(QPen(_colour("edge", 0.22), 1.0))
+ for fraction in (1.0/3.0, 2.0/3.0):
+ x = own_rect.left() + own_rect.width()*fraction
+ y = own_rect.top() + own_rect.height()*fraction
+ painter.drawLine(QPointF(x, 4), QPointF(x, self.height()-4))
+ painter.drawLine(QPointF(4, y), QPointF(self.width()-4, y))
+ for peer, tile in self.tiles.items():
+ if peer in self.shelf_ids:
+ continue
+ rect = self.tile_rect(peer)
+ state = self.states.get(peer, {}).get("state", "edge")
+ chosen = peer == self.selected
+ is_own = peer == own_id
+ inactive = peer in self.shelf_ids or self.in_use.get(peer, True) is False
+ fill = "well" if is_own else "panel"
+ line = "edge" if is_own else "ink_2" if chosen else "amber" if state in ("gap", "between", "set-elsewhere", "overlap") else "edge"
+ if inactive:
+ fill, line = "ground", "ink_2" if chosen and not is_own else "rule"
+ painter.setOpacity(0.55 if inactive else 1.0)
+ painter.setPen(QPen(_colour(line), 2.0 if chosen and not is_own else 1.0))
+ painter.setBrush(_colour(fill))
+ painter.drawRoundedRect(rect, tokens.RADIUS["button"], tokens.RADIUS["button"])
+ if tile.get("displays"):
+ for screen in ways._display_frames(tile):
+ screen_rect = self.display_rect(peer, screen["display"]).adjusted(2, 2, -2, -2)
+ painter.setPen(QPen(_colour("edge"), 1.0))
+ painter.setBrush(_colour("well"))
+ painter.drawRoundedRect(screen_rect, 2, 2)
+ state_data = self.states.get(peer, {})
+ dot_colour = "signal" if state_data.get("linked") else "amber" if state_data.get("legacy") else "ink_3"
+ painter.setPen(Qt.PenStyle.NoPen)
+ painter.setBrush(_colour(dot_colour))
+ if rect.height() >= 56:
+ painter.drawEllipse(QPointF(rect.left()+15, rect.top()+39), 3, 3)
+ if self._hover == peer and not chosen and not is_own:
+ painter.setPen(QPen(_colour("ink_3"), 1.0))
+ painter.setBrush(Qt.BrushStyle.NoBrush)
+ painter.drawRoundedRect(rect, 4, 4)
+ sentence_keys = state_data.get("sentence_keys", [])
+ legacy = state_data.get("legacy", False)
+ painter.setPen(_colour("ink"))
+ painter.setFont(theme.font(tokens.TYPE["body"], 650))
+ title = self.labels.get(peer, f"Machine · {peer[-6:]}")
+ title_room = self._title_rect(peer, rect)
+ painter.drawText(title_room, Qt.AlignmentFlag.AlignCenter,
+ painter.fontMetrics().elidedText(title, Qt.TextElideMode.ElideRight,
+ max(1, round(title_room.width()))))
+ detail = state_data.get("detail", "")
+ if detail and rect.height() >= 56:
+ painter.setPen(_colour("ink_2"))
+ painter.setFont(theme.font(tokens.TYPE["note"]))
+ painter.drawText(QRectF(rect.left()+24, rect.top()+31, max(1, rect.width()-32), 16),
+ Qt.AlignmentFlag.AlignBottom | Qt.AlignmentFlag.AlignLeft,
+ painter.fontMetrics().elidedText(detail, Qt.TextElideMode.ElideRight,
+ max(1, round(rect.width()-32))))
+ if legacy and rect.height() >= 78:
+ painter.setPen(_colour("amber"))
+ painter.setFont(theme.font(tokens.TYPE["note"]))
+ painter.drawText(rect.adjusted(7, rect.height()-62, -7, -36),
+ Qt.AlignmentFlag.AlignCenter | Qt.TextFlag.TextWordWrap,
+ state_data.get("legacy_label", ""))
+ if inactive and rect.height() >= 78:
+ label = "Left out" if peer in self.shelf_ids else "Not in use"
+ painter.setPen(_colour("ink_3"))
+ painter.setFont(theme.font(tokens.TYPE["note"]))
+ painter.drawText(rect.adjusted(4, 0, -4, -6), Qt.AlignmentFlag.AlignBottom | Qt.AlignmentFlag.AlignHCenter, label)
+ foot = ("" if is_own else "Offline" if state_data.get("linked") is False else
+ "Crosses" if state_data.get("corner_way") else "Edge off" if state_data.get("edge_off") else
+ "Drag to connect" if state == "gap" else "Overlaps" if state == "overlap" else
+ outcome_for_tile(state, state_data.get("crosses", is_own), is_own,
+ state_data.get("other_name", "")))
+ if foot and not legacy and rect.height() >= 78:
+ painter.setPen(_colour("signal" if foot == "Crosses" else "amber" if foot in
+ ("Drag to connect", "Overlaps") else "ink_3"))
+ painter.setFont(theme.font(tokens.TYPE["note"]))
+ painter.drawText(QRectF(rect.left()+7, rect.bottom()-24, max(1, rect.width()-14), 16),
+ Qt.AlignmentFlag.AlignBottom | Qt.AlignmentFlag.AlignHCenter, foot)
+ if self._shows_cycle(peer):
+ box = self._cycle_box(rect)
+ ticked = bool(self.cycle.get(peer, True))
+ painter.setPen(Qt.PenStyle.NoPen if ticked else QPen(_colour("edge"), 1.0))
+ painter.setBrush(_colour("ink_2" if ticked else "well"))
+ painter.drawRoundedRect(box, 3, 3)
+ if ticked:
+ pen = QPen(_colour("ground"), 1.8)
+ pen.setCapStyle(Qt.PenCapStyle.RoundCap)
+ pen.setJoinStyle(Qt.PenJoinStyle.RoundJoin)
+ painter.setPen(pen)
+ painter.setBrush(Qt.BrushStyle.NoBrush)
+ check = QPainterPath(QPointF(box.left()+4.5, box.top()+8.5))
+ check.lineTo(box.left()+7, box.top()+11)
+ check.lineTo(box.left()+11.5, box.top()+5)
+ painter.drawPath(check)
+ painter.setOpacity(1.0)
+ own_id = self._own_id()
+ if own_id in self.tiles:
+ own = self.tiles[own_id]
+ own_rect = self.tile_rect(own_id)
+ for peer, tile in self.tiles.items():
+ if peer == own_id or peer in self.shelf_ids:
+ continue
+ held = self.states.get(peer, {})
+ seam_alpha = 1.0 if held.get("linked", True) else .55
+ sides = self._side_contacts(peer)
+ contact = ways._rect_contact(own, tile)
+ # Only a machine reached at a corner alone keeps the corner dot; corners where two
+ # displays meet beside a side contact are not marks.
+ found = sides or ([(own, contact)] if contact and contact[0] == "corner" else [])
+ if not found:
+ continue
+ if peer == self.selected and sides and (
+ (held.get("state") in ("edge", "part") or held.get("unpicked"))
+ and held.get("thirds")):
+ lit_thirds = held.get("lit", held.get("thirds", []))
+ for screen, contact in sides:
+ stretches = ways.third_stretches(contact, screen)
+ breaks = [before[3] for before, after in zip(stretches, stretches[1:])
+ if before[1] == after[1] and abs(before[3] - after[2]) < 1e-6]
+ for stretch in stretches:
+ if stretch[0] in lit_thirds:
+ for lit in ways.crossing_stretches(contact, screen, [stretch[0]]):
+ self._paint_contact(painter, own, own_rect, lit, alpha=seam_alpha,
+ breaks=breaks, screen=screen)
+ else:
+ self._paint_third_track(painter, own, own_rect, stretch, breaks, screen)
+ # The seam is the edge's own mark: a machine reached only by its corner shows the
+ # corner bracket and no seam.
+ elif (held.get("state") in ("edge", "part", "corner")
+ and held.get("crosses") is not False
+ and set(held.get("methods", ["edge"])) & {"edge", "part"}):
+ for screen, contact in found:
+ for stretch in ways.crossing_stretches(contact, screen, held.get("lit", held.get("thirds", []))):
+ self._paint_contact(painter, own, own_rect, stretch, alpha=seam_alpha, screen=screen)
+ self.corner_marks = []
+ for peer, data in self.states.items():
+ corner = data.get("corner_way", "")
+ if (peer == own_id or peer not in self.tiles or peer in self.shelf_ids
+ or corner not in pages_win.CORNER_NAMES):
+ continue
+ opacity = 1.0 if peer == self.selected else 0.55
+ self.corner_marks.append((peer, corner, opacity))
+ self._paint_corner_pad(painter, own_rect, corner, opacity)
+ else:
+ self.corner_marks = []
+ peers = [peer for peer in self.tiles if peer != own_id and peer not in self.shelf_ids]
+ for index, one in enumerate(peers):
+ for two in peers[index+1:]:
+ if not any(self.states.get(peer, {}).get("state") in ("between", "set-elsewhere")
+ for peer in (one, two)):
+ continue
+ contact = ways._rect_contact(self.tiles[one], self.tiles[two])
+ if contact:
+ self._paint_contact(painter, self.tiles[one], self.tile_rect(one), contact, "amber")
+ snapped = self.snap_preview()
+ if snapped is not None:
+ left, top, _width, _height = self._bounds
+ ghost = QRectF((snapped["x"]-left)*self._scale + self._origin.x(),
+ (snapped["y"]-top)*self._scale + self._origin.y(),
+ snapped["w"]*self._scale, snapped["h"]*self._scale)
+ painter.setBrush(Qt.BrushStyle.NoBrush)
+ painter.setPen(QPen(_colour("signal", 0.4), 1.0, Qt.PenStyle.DashLine))
+ painter.drawRoundedRect(ghost, tokens.RADIUS["button"], tokens.RADIUS["button"])
+ contact = ways._rect_contact(self.tiles[own_id], snapped)
+ if contact:
+ self._paint_contact(painter, self.tiles[own_id], self.tile_rect(own_id), contact, alpha=0.5)
+ if self.hasFocus() and self.selected in self.tiles and self._keyboard_focus:
+ painter.setPen(QPen(_colour("ink_2"), 2.0))
+ painter.setBrush(Qt.BrushStyle.NoBrush)
+ painter.drawRoundedRect(self.tile_rect(self.selected).adjusted(-3, -3, 3, 3), 3, 3)
+ painter.end()
+
+ def _own_id(self):
+ return self.own_id or next((peer for peer, label in self.labels.items() if label == "This PC"), None)
+
+ def mousePressEvent(self, event):
+ point = event.position()
+ third = self._third_at(point)
+ if third is not None:
+ self._third_press = third
+ event.accept()
+ return
+ display_peer, display = self.display_at(point)
+ if display_peer is not None and display_peer != self._own_id():
+ offsets = self.tiles[display_peer].get("display_offsets", {})
+ split = display in offsets
+ alt = bool(event.modifiers() & Qt.KeyboardModifier.AltModifier)
+ if split or alt:
+ motion.stop(self, f"tile:{display_peer}")
+ self.selected = display_peer
+ self._drag = display_peer
+ self._drag_display = display
+ self._dragged_display = False
+ self._display_offset_start = dict(offsets.get(display, {"x": 0, "y": 0}))
+ self._split_on_release = alt and not split
+ self._group_on_release = alt and split
+ self._drag_start = QPointF(point)
+ self._tile_start = dict(self.tiles[display_peer])
+ self.setFocus(Qt.FocusReason.MouseFocusReason)
+ self._keyboard_focus = False
+ self.on_select(display_peer)
+ self.update()
+ event.accept()
+ return
+ for peer in reversed(list(self.tiles)):
+ if peer in self.shelf_ids:
+ continue
+ rect = self.tile_rect(peer)
+ if rect.contains(point):
+ if peer == self._own_id():
+ event.accept()
+ return
+ if self._shows_cycle(peer) and self._cycle_hit_rect(rect).contains(point):
+ self.set_cycle(peer, not self.cycle.get(peer, True))
+ event.accept()
+ return
+ self.selected = peer
+ motion.stop(self, f"tile:{peer}")
+ self._drag = peer
+ self._drag_start = QPointF(point)
+ self._tile_start = dict(self.tiles[peer])
+ self.setFocus(Qt.FocusReason.MouseFocusReason)
+ self._keyboard_focus = False
+ self.on_select(peer)
+ self.update()
+ event.accept()
+ return
+ super().mousePressEvent(event)
+
+ def mouseMoveEvent(self, event):
+ if self._drag:
+ self.setCursor(Qt.CursorShape.ClosedHandCursor)
+ delta = event.position() - self._drag_start
+ if self._drag_display is not None:
+ tile = self.tiles[self._drag]
+ offsets = dict(tile.get("display_offsets", {}))
+ offsets[self._drag_display] = {
+ "x": round(self._display_offset_start["x"] + delta.x()/self._scale),
+ "y": round(self._display_offset_start["y"] + delta.y()/self._scale),
+ }
+ self.tiles[self._drag] = {**tile, "display_offsets": offsets}
+ self._dragged_display = self._dragged_display or not delta.isNull()
+ else:
+ tile = self.tiles[self._drag]
+ self.tiles[self._drag] = {**self._tile_start,
+ "x": round(self._tile_start["x"] + delta.x()/self._scale),
+ "y": round(self._tile_start["y"] + delta.y()/self._scale)}
+ self._geometry()
+ self.update()
+ event.accept()
+ return
+ third = self._third_segment_at(event.position())
+ hovered = next((peer for peer in self.tiles if peer not in self.shelf_ids and self.tile_rect(peer).contains(event.position())), None)
+ if hovered != self._hover:
+ self._hover = hovered
+ self.update()
+ if third is not None:
+ self.setToolTip(self._third_tooltip(*third))
+ self.setCursor(Qt.CursorShape.PointingHandCursor)
+ else:
+ self.setToolTip(self.labels.get(hovered, "") if hovered else "")
+ self.setCursor(Qt.CursorShape.OpenHandCursor if hovered and hovered != self._own_id()
+ else Qt.CursorShape.ArrowCursor)
+ if hovered and self._shows_cycle(hovered) and self._cycle_hit_rect(self.tile_rect(hovered)).contains(event.position()):
+ QToolTip.showText(self.mapToGlobal(event.position().toPoint()), "In the shortcut's cycle", self)
+ super().mouseMoveEvent(event)
+
+ def mouseReleaseEvent(self, event):
+ if self._third_press is not None:
+ pressed = self._third_press
+ self._third_press = None
+ if self._third_at(event.position()) == pressed:
+ self.on_third(*pressed)
+ event.accept()
+ return
+ peer = self._drag
+ if peer:
+ snapped = self.snap_preview()
+ display = self._drag_display
+ moved_display = self._dragged_display
+ split_on_release = self._split_on_release
+ group_on_release = self._group_on_release
+ self._drag = None
+ self._drag_display = None
+ self._display_offset_start = None
+ self._dragged_display = False
+ self._split_on_release = False
+ self._group_on_release = False
+ self.setCursor(Qt.CursorShape.ArrowCursor)
+ if display is not None and not moved_display and (split_on_release or group_on_release):
+ tile = dict(self.tiles[peer])
+ offsets = dict(tile.get("display_offsets", {}))
+ if split_on_release:
+ offsets[display] = {"x": 0, "y": 0}
+ else:
+ offsets.pop(display, None)
+ updated = {**tile, "display_offsets": offsets}
+ if not offsets:
+ updated.pop("display_offsets", None)
+ self.tiles[peer] = updated
+ self.on_drop({key: dict(value) for key, value in self.tiles.items()}, peer)
+ self.update()
+ event.accept()
+ return
+ if display is not None and not moved_display:
+ self.update()
+ event.accept()
+ return
+ if display is None and event.position().y() > self.height() - 4:
+ self.on_leave_out(peer, True)
+ self.update()
+ event.accept()
+ return
+ if snapped is not None and snapped != self.tiles[peer]:
+ self.animate_tile(peer, snapped, done=lambda: self._commit_tile(peer))
+ else:
+ self._commit_tile(peer)
+ self.update()
+ event.accept()
+ return
+ super().mouseReleaseEvent(event)
+
+ def mouseDoubleClickEvent(self, event):
+ peer = next((key for key in self.tiles if key not in self.shelf_ids
+ and self.tile_rect(key).contains(event.position())), None)
+ if peer == self._own_id():
+ if self.on_hint:
+ self.on_hint("Rename this computer on Overview.")
+ event.accept()
+ return
+ if peer is not None and peer != self._own_id():
+ self.begin_rename(peer)
+ event.accept()
+ return
+ super().mouseDoubleClickEvent(event)
+
+ def keyPressEvent(self, event):
+ self._keyboard_focus = True
+ if event.key() == Qt.Key.Key_C and not event.modifiers():
+ self.recentre()
+ event.accept()
+ return
+ if event.key() in (Qt.Key.Key_F2, Qt.Key.Key_Return, Qt.Key.Key_Enter) and self.selected is not None:
+ self.begin_rename(self.selected)
+ event.accept()
+ return
+ if (event.key() == Qt.Key.Key_Space and self.cycle_mode == "ticked"
+ and self.selected in self.tiles and self.selected != self._own_id()):
+ self.set_cycle(self.selected, not self.cycle.get(self.selected, True))
+ event.accept()
+ return
+ moves = {Qt.Key.Key_Left: (-1, 0), Qt.Key.Key_Right: (1, 0),
+ Qt.Key.Key_Up: (0, -1), Qt.Key.Key_Down: (0, 1)}
+ if event.key() in moves and self.selected in self.shelf_ids:
+ event.accept()
+ return
+ if event.key() in moves and self.selected in self.tiles and self.selected != self._own_id():
+ dx, dy = moves[event.key()]
+ own = self.tiles[self._own_id()]
+ tile = self.tiles[self.selected]
+ self.tiles[self.selected] = {**tile, "x": tile["x"] + round(own["w"]/3)*dx,
+ "y": tile["y"] + round(own["h"]/3)*dy}
+ accepted = self.on_drop({key: dict(value) for key, value in self.tiles.items()}, self.selected) is not False
+ if accepted:
+ self._announce_move(self.selected)
+ self._geometry()
+ self.update()
+ event.accept()
+ return
+ super().keyPressEvent(event)
+
+ def focusNextPrevChild(self, next):
+ peers = [peer for peer in self.tiles if peer != self._own_id() and peer not in self.shelf_ids]
+ peers.sort(key=lambda peer: (self.tiles[peer]["y"] + self.tiles[peer]["h"] / 2,
+ self.tiles[peer]["x"] + self.tiles[peer]["w"] / 2))
+ rows = []
+ for peer in peers:
+ tile = self.tiles[peer]
+ centre = tile["y"] + tile["h"] / 2
+ if not rows or centre - rows[-1][0][0] > min(tile["h"], rows[-1][0][1]) / 2:
+ rows.append([])
+ rows[-1].append((centre, tile["h"], peer))
+ peers = [peer for row in rows for _centre, _height, peer in
+ sorted(row, key=lambda item: self.tiles[item[2]]["x"] + self.tiles[item[2]]["w"] / 2)]
+ if not peers:
+ return super().focusNextPrevChild(next)
+ index = peers.index(self.selected) if self.selected in peers else (-1 if next else len(peers))
+ target = index + (1 if next else -1)
+ if 0 <= target < len(peers):
+ self.selected = peers[target]
+ self.on_select(self.selected)
+ self._keyboard_focus = True
+ self.update()
+ return True
+ return super().focusNextPrevChild(next)
+
+ def _announce_move(self, peer):
+ own = self.tiles.get(self._own_id())
+ contact = ways._rect_contact(own, self.tiles[peer]) if own else None
+ tile = self.tiles[peer]
+ if contact and contact[0] != "corner":
+ side = contact[0]
+ elif own:
+ dx = tile["x"] + tile["w"] / 2 - own["x"] - own["w"] / 2
+ dy = tile["y"] + tile["h"] / 2 - own["y"] - own["h"] / 2
+ side = ("left" if dx < 0 else "right") if abs(dx) >= abs(dy) else ("top" if dy < 0 else "bottom")
+ else:
+ side = "corner"
+ state = self.states.get(peer, {})
+ position = f"{side} of This PC" if side != "corner" else "at a corner of This PC"
+ part = None
+ if own:
+ along, start, span = ((tile["y"] + tile["h"] / 2, own["y"], own["h"])
+ if side in ("left", "right") else
+ (tile["x"] + tile["w"] / 2, own["x"], own["w"]))
+ part = ways.ATLAS_PARTS[min(2, max(0, int((along-start) / (span/3))))]
+ parts = state.get("thirds", [])
+ chosen_part = parts[0] if parts else part
+ part_name = pages_win.part_names(side).get(chosen_part, chosen_part) if chosen_part else ""
+ detail = f", {part_name.lower()} third" if part_name else ""
+ result = state.get("announcement", "Crosses.")
+ message = f"{self.labels.get(peer, OTHER)}, {position}{detail}. {result}"
+ self.announce(message)
+
+ def announce(self, message):
+ self.setAccessibleDescription(message)
+ QAccessible.updateAccessibility(QAccessibleAnnouncementEvent(self, message))
+ if self.on_announce:
+ self.on_announce(message)
+
+ def focusInEvent(self, event):
+ self._keyboard_focus = event.reason() != Qt.FocusReason.MouseFocusReason
+ self.update()
+ super().focusInEvent(event)
+
+ def begin_rename(self, peer):
+ if peer not in self.tiles or peer in self.shelf_ids or peer == self._own_id():
+ return
+ rect = self.tile_rect(peer).toRect()
+ self.selected = peer
+ self._rename_peer = peer
+ self.rename_edit.setGeometry(rect.adjusted(8, rect.height()//3, -8, -rect.height()//3))
+ self.rename_edit.setText(self.rename_values.get(peer, ""))
+ self.rename_edit.setVisible(True)
+ if self.on_rename_state:
+ self.on_rename_state(True)
+ self.rename_edit.setFocus(Qt.FocusReason.OtherFocusReason)
+ self.rename_edit.selectAll()
+
+ def _save_rename(self):
+ peer, value = self._rename_peer, self.rename_edit.text().strip()[:64]
+ self._rename_peer = None
+ self.rename_edit.setVisible(False)
+ if self.on_rename_state:
+ self.on_rename_state(False)
+ self.setFocus(Qt.FocusReason.OtherFocusReason)
+ if peer:
+ self.on_rename(peer, value)
+
+ def eventFilter(self, watched, event):
+ if (watched is self.recentre_button and event.type() == event.Type.KeyPress
+ and event.key() == Qt.Key.Key_C and not event.modifiers()):
+ self.recentre()
+ return True
+ if watched is self.rename_edit and event.type() == event.Type.KeyPress and event.key() == Qt.Key.Key_Escape:
+ self.rename_edit.setVisible(False)
+ self._rename_peer = None
+ if self.on_rename_state:
+ self.on_rename_state(False)
+ self.setFocus(Qt.FocusReason.OtherFocusReason)
+ return True
+ if watched is self.rename_edit and event.type() == event.Type.FocusOut and self._rename_peer:
+ self._save_rename()
+ return super().eventFilter(watched, event)
+
+
+
+class PushStrip(QSlider):
+ """The Crossing page's one Resistance slider, with its live pressure drawn on the same scale."""
+
+ HEIGHT = 72
+ INSET = 18.0
+ TRACK_TOP = 20.0
+ TRACK_HEIGHT = 12.0
+
+ def __init__(self, parent: QWidget | None = None) -> None:
+ super().__init__(Qt.Orientation.Horizontal, parent)
+ self.setRange(0, MAX_RESISTANCE)
+ self.setSingleStep(10)
+ self.setPageStep(50)
+ self.setAccessibleName("Resistance")
self.setMinimumHeight(self.HEIGHT)
- policy = QSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Preferred)
- policy.setHeightForWidth(True)
- self.setSizePolicy(policy)
- self.setAttribute(Qt.WidgetAttribute.WA_TransparentForMouseEvents)
+ self.setMaximumHeight(self.HEIGHT)
+ self.setCursor(Qt.CursorShape.PointingHandCursor)
self._other = OTHER
- self._value = None
- self._shown = 0.0
- self._glow = 0.0
- self._mac_left = False
+ self._active_edge = "right"
+ self._pressure = 0.0
+ self._crossing = False
+ self._flash_timer = QTimer(self)
+ self._flash_timer.setSingleShot(True)
+ self._flash_timer.setInterval(120)
+ self._flash_timer.timeout.connect(self._clear_crossing_flash)
+ self._update_accessibility_description()
+ self.valueChanged.connect(self._update_value_description)
def minimumSizeHint(self) -> QSize:
return QSize(160, self.HEIGHT)
- def target_width(self, width=None):
- metrics = QFontMetrics(theme.font(tokens.TYPE["small"], 600))
- return min(max(self.MAC, metrics.horizontalAdvance(self._other) + 12),
- (self.width() if width is None else width) * .65)
-
- def heightForWidth(self, width):
- metrics = QFontMetrics(theme.font(tokens.TYPE["small"], 600))
- room = QRectF(0, 0, max(1, self.target_width(width) - 8), 10000).toRect()
- return max(self.HEIGHT, metrics.boundingRect(room, int(Qt.TextFlag.TextWrapAnywhere), self._other).height() + 4)
-
def set_other_name(self, name: str) -> None:
name = name or OTHER
if name != self._other:
self._other = name
- self.updateGeometry()
self.update()
+ def peer_label_text(self) -> str:
+ metrics = QFontMetrics(theme.font(tokens.TYPE["eyebrow"], 600))
+ return metrics.elidedText(self._other.upper(), Qt.TextElideMode.ElideRight,
+ max(1, round(self.width() / 2 - 16)))
+
def set_edge(self, edge: str) -> None:
- mac_left = edge == "left"
- if mac_left != self._mac_left:
- self._mac_left = mac_left
- self.update()
+ if edge:
+ self._active_edge = edge
+ self._update_accessibility_description()
def set_value(self, value: int) -> None:
- value = float(value)
- if value == self._value:
+ self.setValue(int(value))
+
+ def set_pressure(self, pressure: float, edge: str | None = None, crossed: bool = False) -> None:
+ self._flash_timer.stop()
+ self._crossing = bool(crossed)
+ if edge:
+ self._active_edge = edge
+ self._pressure = min(float(MAX_RESISTANCE), max(0.0, float(pressure)))
+ if self._crossing:
+ self._flash_timer.start()
+ self._update_accessibility_description()
+ self.update()
+
+ def _clear_crossing_flash(self) -> None:
+ self._crossing = False
+ self._pressure = 0.0
+ self._update_accessibility_description()
+ self.update()
+
+ def _update_value_description(self, _value: int) -> None:
+ self._update_accessibility_description()
+ self.update()
+
+ def _update_accessibility_description(self) -> None:
+ pressure = int(round(self._pressure))
+ threshold = self.value()
+ description = (
+ f"Current pressure {pressure} of {threshold} pointer units at the {self._active_edge} edge."
+ if pressure > 0 else f"No push. Current pressure is 0 of {threshold} pointer units."
+ )
+ self.setAccessibleDescription(description)
+
+ def keyPressEvent(self, event) -> None:
+ steps = {Qt.Key.Key_Left: -1, Qt.Key.Key_Down: -1, Qt.Key.Key_Right: 1, Qt.Key.Key_Up: 1}
+ direction = steps.get(event.key())
+ if direction is not None and event.modifiers() & Qt.KeyboardModifier.AltModifier:
+ self.setValue(self.value() + direction)
+ event.accept()
return
- first = self._value is None
- self._value = value
- self.setAccessibleDescription(f"{int(value)} px")
- if first:
- self._shown = value
- self.update()
+ super().keyPressEvent(event)
+
+ def mousePressEvent(self, event) -> None:
+ if event.button() == Qt.MouseButton.LeftButton:
+ self.setSliderDown(True)
+ self._move_to(event.position().x())
+ event.accept()
return
- start = self._shown
+ super().mousePressEvent(event)
- def apply(depth):
- self._shown = depth
- self.update()
+ def mouseMoveEvent(self, event) -> None:
+ if self.isSliderDown():
+ self._move_to(event.position().x())
+ event.accept()
+ return
+ super().mouseMoveEvent(event)
- motion.animate(self, "depth", start, value, apply)
- if motion.should_animate(self):
- def glow(level):
- self._glow = level
- self.update()
+ def mouseReleaseEvent(self, event) -> None:
+ if self.isSliderDown() and event.button() == Qt.MouseButton.LeftButton:
+ self._move_to(event.position().x())
+ self.setSliderDown(False)
+ event.accept()
+ return
+ super().mouseReleaseEvent(event)
- motion.animate(self, "glow", 1.0, 0.0, glow, duration=self.SETTLE_MS)
+ def _move_to(self, x: float) -> None:
+ fraction = (float(x) - self.INSET) / max(1.0, self.width() - 2 * self.INSET)
+ self.setValue(round(min(1.0, max(0.0, fraction)) * MAX_RESISTANCE))
def paintEvent(self, _event) -> None:
painter = QPainter(self)
painter.setRenderHint(QPainter.RenderHint.Antialiasing)
- # Drawn with the other machine on the right; flipped when it is on the left.
- if self._mac_left:
- painter.translate(self.width(), 0)
- painter.scale(-1, 1)
- band = QRectF(0.5, 0.5, self.width() - 1.0, self.height() - 1.0)
- radius = tokens.RADIUS["field"]
- target_width = self.target_width()
- edge_x = band.right() - target_width
+ painter.fillRect(self.rect(), _colour("ground"))
painter.setPen(QPen(_colour("rule"), 1.0))
+ painter.setBrush(Qt.BrushStyle.NoBrush)
+ painter.drawRoundedRect(QRectF(0.5, 0.5, self.width() - 1, self.height() - 1), 3, 3)
+
+ left = resistance_x(self.width(), 0)
+ right = resistance_x(self.width(), MAX_RESISTANCE)
+ span = right - left
+ track = QRectF(left, self.TRACK_TOP, span, self.TRACK_HEIGHT)
+ painter.setPen(QPen(_colour("ink_3"), 1.0))
painter.setBrush(_colour("well"))
- painter.drawRoundedRect(band, radius, radius)
- mac = QRectF(edge_x, band.top(), target_width, band.height())
- path = QPainterPath()
- path.addRoundedRect(mac, radius, radius)
- painter.setPen(Qt.PenStyle.NoPen)
- painter.setBrush(_colour("panel"))
- painter.drawPath(path)
- track = edge_x - band.left() - 14.0
- depth = pages_win.push_depth(self._shown or 0.0, track)
- if depth > 0.5:
- fill = QRectF(edge_x - depth, band.top() + 8, depth, band.height() - 16)
- painter.setBrush(_colour("signal", 0.28 + 0.42 * self._glow))
- painter.drawRect(fill)
- painter.setPen(QPen(_colour("signal" if depth > 0.5 or self._glow else "edge"), 2.0))
- painter.drawLine(QPointF(edge_x, band.top() + 4), QPointF(edge_x, band.bottom() - 4))
- tip = QPointF(edge_x - depth - (2.0 if depth > 0.5 else 1.0), band.center().y())
- self._pointer(painter, tip)
+ painter.drawRoundedRect(track, 3, 3)
+
+ head = resistance_x(self.width(), self._pressure)
+ if self._pressure > 0:
+ painter.setPen(Qt.PenStyle.NoPen)
+ painter.setBrush(_colour("signal"))
+ painter.drawRoundedRect(QRectF(left, self.TRACK_TOP + 0.5, max(0.0, head - left),
+ self.TRACK_HEIGHT - 1), 2.5, 2.5)
+
+ thumb_x = resistance_x(self.width(), self.value())
+ painter.setPen(QPen(_colour("ink"), 2.0))
+ painter.drawLine(QPointF(thumb_x, 17.5), QPointF(thumb_x, 38.0))
+ marker = "resistance_flash" if self._crossing else "signal" if self._pressure > 0 else "edge"
+ painter.setPen(QPen(_colour(marker), 3.0 if self._crossing else 2.0))
+ painter.drawLine(QPointF(left, 17.0), QPointF(left, 41.0))
+
+ if self.hasFocus():
+ painter.setPen(QPen(_colour("signal"), 1.0))
+ painter.setBrush(Qt.BrushStyle.NoBrush)
+ painter.drawRoundedRect(track.adjusted(-3, -3, 3, 3), 4, 4)
+
+ painter.setFont(theme.font(tokens.TYPE["eyebrow"], 600))
painter.setPen(_colour("ink_3"))
- painter.setFont(theme.font(tokens.TYPE["small"], 600))
- label = QRectF(edge_x, band.top(), target_width, band.height()).adjusted(4, 2, -4, -2)
- if self._mac_left:
- # Text drawn in the flipped frame would read backwards.
- painter.resetTransform()
- label = QRectF(self.width() - label.right(), label.top(), label.width(), label.height())
- painter.drawText(
- label, Qt.AlignmentFlag.AlignCenter | Qt.TextFlag.TextWrapAnywhere, self._other,
- )
- painter.end()
+ local_rect = QRectF(8, 2, self.width() / 2 - 8, 15)
+ peer_rect = QRectF(self.width() / 2, 2, self.width() / 2 - 8, 15)
+ painter.drawText(local_rect, Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter, "THIS PC")
+ painter.drawText(peer_rect, Qt.AlignmentFlag.AlignRight | Qt.AlignmentFlag.AlignVCenter,
+ self.peer_label_text())
- def _pointer(self, painter, tip: QPointF) -> None:
- # An arrow pointing at the edge, its tip where the push has reached.
- path = QPainterPath()
- k = 0.9
- points = ((0, 0), (-14, -8), (-11, 0), (-14, 8))
- for index, (x, y) in enumerate(points):
- (path.lineTo if index else path.moveTo)(tip.x() + x * k, tip.y() + y * k)
- path.closeSubpath()
- painter.setPen(QPen(_colour("ground"), 1.0))
- painter.setBrush(_colour("ink"))
- painter.drawPath(path)
+ for value in range(0, MAX_RESISTANCE + 1, 25):
+ x = resistance_x(self.width(), value)
+ major = value % 100 == 0
+ painter.setPen(QPen(_colour("ink_3" if major else "edge"), 1.0))
+ painter.drawLine(QPointF(x, track.bottom()), QPointF(x, track.bottom() + (12 if major else 4)))
+ if major:
+ painter.setFont(theme.mono_font(tokens.TYPE["eyebrow"]))
+ painter.setPen(_colour("ink_2"))
+ painter.drawText(QRectF(x - 22, 52, 44, 17), Qt.AlignmentFlag.AlignCenter, str(value))
+ painter.end()
diff --git a/win_app/display_brightness.py b/win_app/display_brightness.py
new file mode 100644
index 0000000..3a4bf5b
--- /dev/null
+++ b/win_app/display_brightness.py
@@ -0,0 +1,60 @@
+"""Adjust built-in displays through WMI's brightness methods."""
+
+import logging
+
+LOGGER = logging.getLogger(__name__)
+_WARNED_UNAVAILABLE = False
+
+
+def _next_level(levels, current, direction):
+ ordered = sorted(int(level) for level in levels)
+ if direction > 0:
+ return next((level for level in ordered if level > current), ordered[-1])
+ return next((level for level in reversed(ordered) if level < current), ordered[0])
+
+
+def adjust(steps: int, dispatch=None) -> bool:
+ global _WARNED_UNAVAILABLE
+ uninitialise_com = False
+ try:
+ if dispatch is None:
+ import pythoncom
+
+ pythoncom.CoInitialize()
+ uninitialise_com = True
+ from win32com.client import Dispatch
+
+ dispatch = Dispatch
+ service = dispatch("WbemScripting.SWbemLocator").ConnectServer(".", r"root\wmi")
+ levels = service.ExecQuery("SELECT InstanceName, CurrentBrightness, Level FROM WmiMonitorBrightness")
+ methods = {str(item.InstanceName): item for item in service.ExecQuery(
+ "SELECT InstanceName FROM WmiMonitorBrightnessMethods"
+ )}
+ changed = False
+ for screen in levels:
+ method = methods.get(str(screen.InstanceName))
+ if method is None:
+ continue
+ target = int(screen.CurrentBrightness)
+ for _ in range(abs(int(steps))):
+ target = _next_level(screen.Level, target, 1 if steps > 0 else -1)
+ parameters = method.Methods_("WmiSetBrightness").InParameters.SpawnInstance_()
+ parameters.Timeout = 0
+ parameters.Brightness = target
+ result = method.ExecMethod_("WmiSetBrightness", parameters)
+ status = int(result.ReturnValue)
+ if status != 0:
+ raise OSError(f"WmiSetBrightness returned {status}")
+ changed = True
+ except Exception:
+ LOGGER.exception("Windows display brightness failed")
+ return False
+ finally:
+ if uninitialise_com:
+ pythoncom.CoUninitialize()
+ if not changed:
+ if not _WARNED_UNAVAILABLE:
+ LOGGER.info("No built-in display exposes WMI brightness control; external monitors are unchanged")
+ _WARNED_UNAVAILABLE = True
+ return False
+ return True
diff --git a/win_app/edge_glow.py b/win_app/edge_glow.py
index 1aaa39c..4693936 100644
--- a/win_app/edge_glow.py
+++ b/win_app/edge_glow.py
@@ -18,13 +18,14 @@ import math
import sys
import time
-from PySide6.QtCore import QRect, QRectF, Qt, QTimer
+from PySide6.QtCore import QRect, QRectF, Qt
from PySide6.QtGui import QColor, QCursor, QImage, QLinearGradient, QPainter, QPainterPath, QPen
from PySide6.QtWidgets import QApplication, QSizePolicy, QWidget
import app_config
from core import effects
from core import return_edge as crossing
+from frame_clock import PREVIEW_MAX_RATE, frame_timer, start_paced
import theme
import tokens
@@ -290,19 +291,20 @@ class EdgeGlow(QWidget):
self._colour = "signal"
self._size = "medium"
self._band = float(BAND_PX)
+ self._size_fraction = None
self._state = GlowState()
self._dark = True
self._updated_at = 0.0
self._ticked_at = 0.0
- self._timer = QTimer(self)
- self._timer.setInterval(16)
- self._timer.timeout.connect(self._tick)
+ self._timer = frame_timer(self, self._tick, self)
- def configure(self, style: str, colour: str, length: str = "normal", size: str = "medium") -> None:
+ def configure(self, style: str, colour: str, length: str = "normal", size: str = "medium",
+ effect_pace: float | None = None, size_fraction: float | None = None) -> None:
self._style = style
self._colour = colour
self._size = size
- self._state.pace = effects.pace(length)
+ self._state.pace = effect_pace if effect_pace is not None else effects.pace(length)
+ self._size_fraction = size_fraction
def set_pressure(self, edge: str, pressure: float, crossed: bool, part=None) -> None:
"""`part` is the third of the edge being pushed for Part of the edge, which lights only
@@ -319,7 +321,7 @@ class EdgeGlow(QWidget):
self._dark = system_dark()
self._state.restart()
self.show()
- self._timer.start()
+ start_paced(self._timer, self)
keep_on_top(self)
self.update()
@@ -333,7 +335,7 @@ class EdgeGlow(QWidget):
cursor = QCursor.pos()
owner = next((r for r in rects if r.x <= cursor.x() < r.x + r.width and r.y <= cursor.y() < r.y + r.height),
None) or crossing.owning_monitor(rects, self._edge)
- self._band = effects.edge_depth(owner.width, owner.height, self._size)
+ self._band = effects.edge_depth(owner.width, owner.height, self._size, self._size_fraction)
if self._part in crossing.CORNERS:
box = corner_of_monitor(owner, self._part, min(CORNER_ARM_PX, owner.width, owner.height))
self.setGeometry(QRect(box.x, box.y, box.width, box.height))
@@ -439,11 +441,7 @@ class PreviewLoop:
self._started_at = None
self._ticked_at = 0.0
self._phase = None
- self._timer = QTimer(parent)
- # Precise: a coarse timer may fire up to 5% either side, which lands frames unevenly.
- self._timer.setTimerType(Qt.TimerType.PreciseTimer)
- self._timer.setInterval(16)
- self._timer.timeout.connect(self._tick)
+ self._timer = frame_timer(parent, self._tick, parent, PREVIEW_MAX_RATE)
def add(self, preview: GlowPreview) -> None:
self.previews.append(preview)
@@ -455,7 +453,8 @@ class PreviewLoop:
self.running = wanted
self._settle()
if wanted:
- self._timer.start()
+ if self.hovered is not None:
+ start_paced(self._timer, self._timer.parent(), PREVIEW_MAX_RATE)
else:
self._timer.stop()
@@ -465,6 +464,10 @@ class PreviewLoop:
return
self._settle()
self.hovered, self._hovered_at = preview, time.monotonic()
+ if self.running and preview in self.previews:
+ start_paced(self._timer, self._timer.parent(), PREVIEW_MAX_RATE)
+ elif preview is None:
+ self._timer.stop()
def playing(self, preview) -> bool:
return preview is self.hovered and self._started_at is not None
@@ -482,10 +485,14 @@ class PreviewLoop:
def _tick(self) -> None:
preview = self.hovered
+ if preview is None:
+ self._timer.stop()
+ return
now = time.monotonic()
- if preview is None or now - self._hovered_at < self.INTENT_S:
+ if now - self._hovered_at < self.INTENT_S:
return
if not preview.isVisible() or preview.visibleRegion().isEmpty():
+ # Kept running: a tile scrolled out and back under a still pointer gets no new Enter.
self._settle()
return
if self._started_at is None:
diff --git a/win_app/effect_overlay.py b/win_app/effect_overlay.py
index 3455b83..30fb532 100644
--- a/win_app/effect_overlay.py
+++ b/win_app/effect_overlay.py
@@ -4,7 +4,8 @@ click-through window, sized each frame to what the effect drew.
effects.py records every effect as operations in desktop points; `replay` turns them into Qt paths,
brushes and pens. The window is today's EdgeGlow pattern: frameless, translucent, input passes
through it, a tool window (so no taskbar button and no Alt-Tab entry), above everything, the
-taskbar included, never activated. It repaints at 60Hz only while the Player is busy and hides as soon as it is not.
+taskbar included, never activated. Its frame timer follows the screen refresh rate while the Player
+is busy, and it hides as soon as it is not.
Any exception from an effect or the replay is logged once with the effect's id and turns the new
effects off for the rest of the run; the app then falls back to today's glow.
@@ -25,7 +26,7 @@ import time
if sys.platform == "win32":
os.environ["QT_NO_GUI_THREADPOOL"] = "1"
-from PySide6.QtCore import QPointF, QRect, QRectF, Qt, QTimer
+from PySide6.QtCore import QPointF, QRect, QRectF, Qt
from PySide6.QtGui import (
QBrush,
QColor,
@@ -44,10 +45,10 @@ import app_config
import edge_glow
from core import effects
from core import return_edge as crossing
+from frame_clock import frame_timer, start_paced
LOGGER = logging.getLogger(__name__)
-FRAME_MS = 16
# How long without a pressure update before the push is taken to have stopped and drains on its
# own clock, as EdgeGlow's does.
STALE_SECONDS = 0.08
@@ -254,7 +255,7 @@ def edge_region(edge: str, rects, origin, pointer=None, part=None) -> dict:
class EffectOverlay(QWidget):
"""One window for every effect on this PC, departures and arrivals alike."""
- def __init__(self, on_failure=None) -> None:
+ def __init__(self, on_failure=None, fixed_geometry: bool = False) -> None:
super().__init__(
None,
Qt.WindowType.Tool
@@ -268,6 +269,10 @@ class EffectOverlay(QWidget):
self.setAttribute(Qt.WidgetAttribute.WA_TransparentForMouseEvents)
self.failed = False
self._on_failure = on_failure
+ self._fixed_geometry = fixed_geometry
+ self._fixed_geometry_ready = False
+ self._dirty_rect = QRect()
+ self._hide_after_paint = False
self.player = effects.Player()
self._style = None
self._fx = None
@@ -280,11 +285,10 @@ class EffectOverlay(QWidget):
self._offset = (0.0, 0.0)
self._push = None
self._ticked_at = 0.0
- self._timer = QTimer(self)
- self._timer.setInterval(FRAME_MS)
- self._timer.timeout.connect(self._tick)
+ self._timer = frame_timer(self, self._tick, self)
- def configure(self, style: str, colour: str, length: str = "normal", size: str = "medium") -> None:
+ def configure(self, style: str, colour: str, length: str = "normal", size: str = "medium",
+ effect_pace: float | None = None, size_fraction: float | None = None) -> None:
if style != self._style:
self._style = style
self.player = effects.Player()
@@ -299,8 +303,9 @@ class EffectOverlay(QWidget):
return
# Read each time, like the colours; a Player already playing keeps the pace it started with.
if not self.player.busy:
- self.player.pace = effects.pace(length)
+ self.player.pace = effect_pace if effect_pace is not None else effects.pace(length)
self.player.effect_size = size
+ self.player.effect_size_fraction = size_fraction
try:
self._palette = app_config.palette_colours(colour)
except Exception:
@@ -375,6 +380,10 @@ class EffectOverlay(QWidget):
self.player = effects.Player()
self._push = None
self._pens = []
+ self._hide_after_paint = False
+ if self._fixed_geometry and not self._dirty_rect.isNull():
+ self.update(self._dirty_rect)
+ self._dirty_rect = QRect()
self.hide()
def _start(self, now: float) -> bool:
@@ -389,7 +398,8 @@ class EffectOverlay(QWidget):
self._displays = [(g.x() - self._desk.x(), g.y() - self._desk.y(), g.width(), g.height())
for g in (screen.geometry() for screen in QGuiApplication.screens())]
self._ticked_at = now
- self._timer.start()
+ self._fixed_geometry_ready = False
+ start_paced(self._timer)
return True
def _display(self, at):
@@ -415,6 +425,18 @@ class EffectOverlay(QWidget):
self.player.release()
self._push = None
+ def _clear_fixed(self) -> None:
+ """Nothing to draw this frame: repaint the last frame's area clear, and once the player is
+ done hide the window after that paint lands."""
+ dirty, self._dirty_rect = self._dirty_rect, QRect()
+ if not dirty.isNull():
+ self.update(dirty)
+ if not self.player.busy:
+ self._timer.stop()
+ self._hide_after_paint = not dirty.isNull()
+ if dirty.isNull():
+ self.hide()
+
def _tick(self) -> None:
now = time.monotonic()
try:
@@ -427,6 +449,9 @@ class EffectOverlay(QWidget):
box = union_bounds(pens, MARGIN)
if box is None:
self._pens = []
+ if self._fixed_geometry:
+ self._clear_fixed()
+ return
if not self.player.busy:
self._timer.stop()
self.hide()
@@ -437,11 +462,29 @@ class EffectOverlay(QWidget):
y1 = min(self._desk.height(), math.ceil(box[3]))
if x1 <= x0 or y1 <= y0:
self._pens = []
+ if self._fixed_geometry:
+ self._clear_fixed()
+ return
self.hide()
return
self._pens = pens
- self._offset = (float(x0), float(y0))
frame = QRect(self._desk.x() + x0, self._desk.y() + y0, x1 - x0, y1 - y0)
+ if self._fixed_geometry:
+ current = QRect(x0, y0, x1 - x0, y1 - y0)
+ dirty = current.united(self._dirty_rect)
+ self._dirty_rect = current
+ self._offset = (0.0, 0.0)
+ if not self._fixed_geometry_ready:
+ # Resizing an ARGB XWayland window exposes uninitialised black pixels.
+ self.setGeometry(self._desk)
+ self._fixed_geometry_ready = True
+ if self.isHidden():
+ self.show()
+ self._hide_after_paint = False
+ edge_glow.keep_on_top(self)
+ self.update(dirty)
+ return
+ self._offset = (float(x0), float(y0))
if frame != self.geometry():
self.setGeometry(frame)
if self.isHidden():
@@ -449,19 +492,27 @@ class EffectOverlay(QWidget):
edge_glow.keep_on_top(self)
self.update()
- def paintEvent(self, _event) -> None:
- if not self._pens:
+ def paintEvent(self, event) -> None:
+ if not self._pens and not self._fixed_geometry:
return
painter = QPainter(self)
try:
+ if self._fixed_geometry:
+ painter.setCompositionMode(QPainter.CompositionMode.CompositionMode_Source)
+ painter.fillRect(event.rect(), QColor(0, 0, 0, 0))
+ painter.setCompositionMode(QPainter.CompositionMode.CompositionMode_SourceOver)
painter.setRenderHint(QPainter.RenderHint.Antialiasing)
painter.translate(-self._offset[0], -self._offset[1])
- replay(painter, self._pens)
+ if self._pens:
+ replay(painter, self._pens)
except Exception:
painter.end()
self._fail("replaying")
return
painter.end()
+ if self._hide_after_paint:
+ self._hide_after_paint = False
+ self.hide()
def _fail(self, doing: str) -> None:
if not self.failed:
diff --git a/win_app/effect_overlay_x11.py b/win_app/effect_overlay_x11.py
new file mode 100644
index 0000000..e574603
--- /dev/null
+++ b/win_app/effect_overlay_x11.py
@@ -0,0 +1,237 @@
+"""Run crossing windows on XWayland when the compositor permits edge overlays."""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+import select
+import subprocess
+import sys
+
+
+def available(wayland, environ):
+ return bool(wayland and environ.get("DISPLAY"))
+
+
+def mapped_point(x, y, source, target):
+ """Map a desktop point by fraction between the source and helper desktop bounds."""
+ sx, sy, sw, sh = source
+ return (target.x() + (x - sx) * target.width() / sw,
+ target.y() + (y - sy) * target.height() / sh)
+
+
+def dispatch(command, overlay, glow, target, point_factory=None):
+ op = command["op"]
+ if op == "effect_configure":
+ overlay.configure(command["style"], command["colour"], command["length"], command["size"],
+ command.get("effect_pace"), command.get("size_fraction"))
+ elif op == "push":
+ if "x" in command:
+ point = mapped_point(command["x"], command["y"], command["desk"], target)
+ if point_factory is not None:
+ point = point_factory(*point)
+ overlay.push(command["edge"], command["pressure"], command["crossed"], cursor=point,
+ part=command.get("part"))
+ else:
+ overlay.push(command["edge"], command["pressure"], command["crossed"], part=command.get("part"))
+ elif op == "arrive":
+ point = mapped_point(command["x"], command["y"], command["desk"], target)
+ if point_factory is not None:
+ point = point_factory(*point)
+ overlay.arrive(command["method"], command["edge"], point)
+ elif op == "crossed_in":
+ overlay.crossed_in()
+ elif op == "switched":
+ point = mapped_point(command["x"], command["y"], command["desk"], target)
+ if point_factory is not None:
+ point = point_factory(*point)
+ overlay.switched(point, command["choice"])
+ elif op == "glow_configure":
+ glow.configure(command["style"], command["colour"], command["length"], command["size"],
+ command.get("effect_pace"), command.get("size_fraction"))
+ elif op == "glow_pressure":
+ glow.set_pressure(command["edge"], command["pressure"], command["crossed"], command.get("part"))
+ elif op == "stop":
+ overlay.stop()
+ glow.hide()
+ return True
+
+
+class EffectOverlayX11Proxy:
+ def __init__(self, on_failure=None, popen=subprocess.Popen):
+ self._on_failure = on_failure
+ self._popen = popen
+ self._process = None
+ self._reader = None
+ self._timer = None
+ self._failed = False
+ self._effect_ready = False
+
+ @property
+ def failed(self):
+ self.check_process()
+ return self._failed
+
+ @property
+ def effect_ready(self):
+ return self._effect_ready
+
+ def configure(self, style, colour, length="normal", size="medium", effect_pace=None, size_fraction=None):
+ self._effect_ready = bool(style)
+ self._send("effect_configure", style=style, colour=colour, length=length, size=size,
+ effect_pace=effect_pace, size_fraction=size_fraction)
+
+ def configure_glow(self, style, colour, length="normal", size="medium", effect_pace=None, size_fraction=None):
+ self._send("glow_configure", style=style, colour=colour, length=length, size=size,
+ effect_pace=effect_pace, size_fraction=size_fraction)
+
+ def push(self, edge, pressure, crossed, cursor=None, part=None, desk=None):
+ values = {"edge": edge, "pressure": pressure, "crossed": crossed, "part": part}
+ if cursor is not None:
+ values.update(x=cursor.x(), y=cursor.y(),
+ desk=[desk.x(), desk.y(), desk.width(), desk.height()])
+ self._send("push", **values)
+
+ def set_pressure(self, edge, pressure, crossed, part=None):
+ self._send("glow_pressure", edge=edge, pressure=pressure, crossed=crossed, part=part)
+
+ def arrive(self, method, edge, x, y, desk):
+ self._send("arrive", method=method, edge=edge, x=x, y=y, desk=desk)
+
+ def crossed_in(self):
+ self._send("crossed_in")
+
+ def switched(self, x, y, desk, choice="match"):
+ self._send("switched", x=x, y=y, desk=desk, choice=choice)
+
+ def hide(self):
+ self.stop()
+
+ def stop(self):
+ # Hides both windows and keeps the helper: _hide_crossing runs on every settings change
+ # and departure, and a new helper costs a Python and Qt start. It exits when this
+ # process closes its stdin, at quit.
+ if self._process is not None:
+ self._send("stop")
+
+ def check_process(self):
+ process = self._process
+ if process is None:
+ return
+ if process.stdout is not None:
+ try:
+ ready, _, _ = select.select([process.stdout], [], [], 0)
+ if ready:
+ line = process.stdout.readline()
+ if line.startswith("failed "):
+ self._fail()
+ except (OSError, ValueError):
+ pass
+ if process.poll() is not None:
+ self._fail()
+
+ def _send(self, op, check=True, **values):
+ if self._failed:
+ return
+ if self._process is None:
+ try:
+ env = dict(os.environ, QT_QPA_PLATFORM="xcb")
+ self._process = self._popen(
+ [sys.executable, str(Path(__file__).with_name("effect_overlay_x11.py"))],
+ stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL,
+ text=True, bufsize=1, env=env,
+ )
+ try:
+ from PySide6.QtWidgets import QApplication
+
+ app = QApplication.instance()
+ except ImportError:
+ app = None
+ if app is not None:
+ from PySide6.QtCore import QTimer
+
+ self._timer = QTimer()
+ self._timer.setInterval(100)
+ self._timer.timeout.connect(self.check_process)
+ self._timer.start()
+ except OSError:
+ self._fail()
+ return
+ if check:
+ self.check_process()
+ if self._failed:
+ return
+ try:
+ self._process.stdin.write(json.dumps({"op": op, **values}, separators=(",", ":")) + "\n")
+ self._process.stdin.flush()
+ except (BrokenPipeError, OSError, ValueError):
+ self._fail()
+
+ def _fail(self):
+ if self._failed:
+ return
+ self._failed = True
+ if self._timer is not None:
+ self._timer.stop()
+ process, self._process = self._process, None
+ if process is not None:
+ try:
+ process.stdin.close()
+ except (AttributeError, OSError, ValueError):
+ pass
+ if process.poll() is None:
+ process.terminate()
+ try:
+ process.wait(timeout=0.5)
+ except subprocess.TimeoutExpired:
+ process.kill()
+ process.wait()
+ if self._on_failure is not None:
+ self._on_failure()
+
+
+def run_helper():
+ from PySide6.QtCore import QPointF, QSocketNotifier, Qt
+ from PySide6.QtWidgets import QApplication
+ from edge_glow import EdgeGlow
+ from effect_overlay import EffectOverlay, desktop_box
+
+ app = QApplication(sys.argv)
+ overlay = EffectOverlay(on_failure=lambda: print("failed effect", flush=True), fixed_geometry=True)
+ glow = EdgeGlow()
+ overlay.setWindowFlag(Qt.WindowType.X11BypassWindowManagerHint, True)
+ glow.setWindowFlag(Qt.WindowType.X11BypassWindowManagerHint, True)
+ box = desktop_box()
+ notifier = QSocketNotifier(0, QSocketNotifier.Type.Read)
+ pending = bytearray()
+
+ def read_input():
+ try:
+ data = os.read(0, 65536)
+ except OSError:
+ data = b""
+ if not data:
+ # End of input stays readable, so the notifier would fire until the loop exits.
+ notifier.setEnabled(False)
+ app.quit()
+ return
+ pending.extend(data)
+ while b"\n" in pending:
+ line, _, rest = pending.partition(b"\n")
+ pending[:] = rest
+ try:
+ if not dispatch(json.loads(line), overlay, glow, box, QPointF):
+ app.quit()
+ return
+ except Exception as exc:
+ print(f"failed {type(exc).__name__}", flush=True)
+ app.quit()
+ return
+
+ notifier.activated.connect(read_input)
+ return app.exec()
+
+
+if __name__ == "__main__":
+ raise SystemExit(run_helper())
diff --git a/win_app/effect_previews.py b/win_app/effect_previews.py
index 9728438..45af7d9 100644
--- a/win_app/effect_previews.py
+++ b/win_app/effect_previews.py
@@ -8,12 +8,13 @@ import logging
import time
import math
-from PySide6.QtCore import QEvent, QObject, QRectF, QSize, Qt, QTimer
-from PySide6.QtGui import QColor, QImage, QPainter, QPainterPath, QPen
+from PySide6.QtCore import QEvent, QObject, QPointF, QRectF, QSize, Qt
+from PySide6.QtGui import QColor, QImage, QLinearGradient, QPainter, QPainterPath, QPen
from PySide6.QtWidgets import QSizePolicy, QWidget
import edge_glow
from core import effects
+from frame_clock import PREVIEW_MAX_RATE, frame_timer, start_paced
import motion
import theme
import tokens
@@ -21,36 +22,21 @@ from effect_overlay import replay, system_reduced_motion
LOGGER = logging.getLogger(__name__)
-# Part way into the push, where every style shows.
-STILL_AT_S = 1.7
# One effect layer, reused while the preview's size holds, rather than a new image every frame.
_LAYERS = {}
+_SHADOWS = {}
STILL_HEIGHT = 56
-# A tile shows where the style plays rather than the whole scene too small to see: this many scene
-# points across, centred on the crossing at each place, the corner framed with room above the screens.
-STILL_VIEW_W = 240.0
-STILL_CENTRE = {"edge": (effects.PREVIEW_SCREEN[0] + effects.PREVIEW_GAP / 2.0, effects.PREVIEW_SCREEN[1] * 0.45),
- "corner": (effects.PREVIEW_SCREEN[0] + effects.PREVIEW_GAP / 2.0, 40.0)}
-# A switch plays round a still pointer on one screen: its tile shows that part of the scene part-way
-# through, and the stage the screen less the empty strips above and below, as the Mac's do.
-SWITCH_STILL_AT_S = 0.6
-SWITCH_STILL_VIEW = QRectF(248.0, 138.0, 240.0, 120.0)
_SCREEN_NAMES = {"mac": "MAC", "windows": "PC"}
-FRAME_MS = 16
+# A specimen tile: the share of each side its marks fade over, how far below them their shadow
+# falls and how much darker than the card it is (QColor.darker), and the seam tick's length, in px.
+FEATHER = 0.1
+SHADOW_DROP = 1.0
+SHADOW_DEPTH = 125
+SEAM_TICK = 10
# A pointer passing over tiles on its way elsewhere leaves the tiles it crosses still.
HOVER_INTENT_S = 0.1
-def frame_timer(parent: QObject, tick) -> QTimer:
- """A timer for one frame of animation. Precise: a coarse timer may fire up to 5% either side,
- which on Windows' clock lands frames unevenly."""
- timer = QTimer(parent)
- timer.setTimerType(Qt.TimerType.PreciseTimer)
- timer.setInterval(FRAME_MS)
- timer.timeout.connect(tick)
- return timer
-
-
def on_screen(widget: QWidget) -> bool:
"""Whether any of `widget` can be seen: shown in a window that is not minimised, and not
scrolled out of its page."""
@@ -59,10 +45,9 @@ def on_screen(widget: QWidget) -> bool:
def _pointer_path(size: float) -> QPainterPath:
"""An arrow pointer `size` tall with its tip at the origin."""
- k = size / 16.0
path = QPainterPath()
- for index, (x, y) in enumerate(((0, 0), (0, 14), (3.6, 10.8), (6.2, 16), (8.4, 15), (5.9, 9.9), (10.4, 9.9))):
- (path.lineTo if index else path.moveTo)(x * k, y * k)
+ for index, (x, y) in enumerate(effects.PREVIEW_POINTER):
+ (path.lineTo if index else path.moveTo)(x * size, y * size)
path.closeSubpath()
return path
@@ -85,7 +70,8 @@ def paint_scene(painter: QPainter, rect: QRectF, view: QRectF, scene: dict, poin
radius = tokens.RADIUS["field"] / scale
for x, y, w, h, os_name in scene["screens"]:
painter.setPen(QPen(QColor(theme.colour("rule")), 1.0 / scale))
- painter.setBrush(QColor(theme.colour("well")))
+ ground = theme.colour("ground") if "seam" in scene else effects.PREVIEW_TILE_GROUND
+ painter.setBrush(QColor(ground))
screen = QRectF(x, y, w, h)
if not labels:
screen = screen.intersected(view).adjusted(1 / scale, 1 / scale, -1 / scale, -1 / scale)
@@ -101,6 +87,8 @@ def paint_scene(painter: QPainter, rect: QRectF, view: QRectF, scene: dict, poin
corner = QRectF(10, shown.height() * scale - 26, shown.width() * scale - 20, 18)
painter.drawText(corner, Qt.AlignmentFlag.AlignBottom | Qt.AlignmentFlag.AlignLeft, _SCREEN_NAMES.get(os_name, ""))
painter.restore()
+ if scene.get("seam") is not None:
+ _paint_scene_seam(painter, scene["seam"], view, scale)
# The effects draw on their own layer, as the overlay does over the desktop, so "lighter"
# adds to the effect's own light rather than to the screens drawn under it.
if not scene["pens"]:
@@ -126,12 +114,82 @@ def paint_scene(painter: QPainter, rect: QRectF, view: QRectF, scene: dict, poin
painter.save()
painter.setTransform(local_transform)
painter.translate(left, top)
+ if "seam" in scene:
+ _feather(layer, width * scale, height * scale)
+ painter.drawImage(0, SHADOW_DROP, _shadow(layer))
painter.drawImage(0, 0, layer)
+ if scene.get("seam") is not None:
+ painter.translate(-left, -top)
+ _paint_seam_tick(painter, scene["seam"], view, scale, QPointF(left, top))
painter.restore()
_paint_pointer_and_notch(painter, scene, scale, pointer_size)
painter.restore()
+def _feather(layer: QImage, width: float, height: float) -> None:
+ """Fades `layer` out over FEATHER of each side, so a specimen whose marks run past its view
+ thins away into the card rather than stopping at a cut edge."""
+ painter = QPainter(layer)
+ painter.setCompositionMode(QPainter.CompositionMode.CompositionMode_DestinationIn)
+ for end in (QPointF(width, 0), QPointF(0, height)):
+ ramp = QLinearGradient(QPointF(0, 0), end)
+ ramp.setColorAt(0.0, QColor(0, 0, 0, 0))
+ ramp.setColorAt(FEATHER, QColor(0, 0, 0, 255))
+ ramp.setColorAt(1.0 - FEATHER, QColor(0, 0, 0, 255))
+ ramp.setColorAt(1.0, QColor(0, 0, 0, 0))
+ painter.fillRect(QRectF(0, 0, width, height), ramp)
+ painter.end()
+
+
+def _shadow(layer: QImage) -> QImage:
+ """The faint shadow a specimen casts on its card: the marks' shape, softened by a pixel, in the
+ card colour taken a step down, so the marks lift off the card in Light. On the near-black Dark
+ card it all but vanishes, as additive light needs nothing under it."""
+ key = (layer.width(), layer.height(), layer.devicePixelRatio())
+ shadow = _SHADOWS.get(key)
+ if shadow is None:
+ _SHADOWS.clear()
+ shadow = _SHADOWS[key] = QImage(layer.size(), QImage.Format.Format_ARGB32_Premultiplied)
+ shadow.setDevicePixelRatio(layer.devicePixelRatio())
+ shadow.fill(Qt.GlobalColor.transparent)
+ painter = QPainter(shadow)
+ painter.setOpacity(0.35)
+ for dx, dy in ((-1, 0), (1, 0), (0, -1), (0, 1), (0, 0)):
+ painter.drawImage(QPointF(dx * 0.75, dy * 0.75), layer)
+ painter.setOpacity(1.0)
+ painter.setCompositionMode(QPainter.CompositionMode.CompositionMode_SourceIn)
+ painter.fillRect(shadow.rect(), QColor(theme.colour("ground")).darker(SHADOW_DEPTH))
+ painter.end()
+ return shadow
+
+
+def _paint_seam_tick(painter: QPainter, seam, view: QRectF, scale: float, origin: QPointF) -> None:
+ """The crossing as one short rule where the seam leaves the bottom of the view (the left, for
+ the notch's level seam), in the card's quietest ink, on whole pixels so it stays a hairline."""
+ x0, y0, x1, _y1 = seam
+ painter.setPen(QPen(QColor(theme.colour("ink_2")), 1.0))
+ if x0 == x1:
+ x = math.floor(origin.x() + (x0 - view.x()) * scale) + 0.5
+ bottom = math.floor(origin.y() + view.height() * scale)
+ painter.drawLine(QPointF(x, bottom - SEAM_TICK), QPointF(x, bottom - 1))
+ else:
+ y = math.floor(origin.y() + (y0 - view.y()) * scale) + 0.5
+ left = math.ceil(origin.x())
+ painter.drawLine(QPointF(left, y), QPointF(left + SEAM_TICK - 1, y))
+
+
+def _paint_scene_seam(painter: QPainter, seam, view: QRectF, scale: float) -> None:
+ """Draw the quiet screen boundary through the visible part of the crossing seam."""
+ x0, y0, x1, y1 = seam
+ painter.setPen(QPen(QColor(theme.colour("rule")), 1.0 / scale))
+ if x0 == x1:
+ x = view.x() + (math.floor((x0 - view.x()) * scale) + 0.5) / scale
+ painter.drawLine(QPointF(x, view.y()), QPointF(x, view.bottom()))
+ else:
+ y = view.y() + (math.floor((y0 - view.y()) * scale) + 0.5) / scale
+ painter.drawLine(QPointF(view.x(), y), QPointF(view.right(), y))
+
+
def _paint_pointer_and_notch(painter: QPainter, scene: dict, scale: float, pointer_size: float) -> None:
if scene["pointer"] is not None:
px, py, _os = scene["pointer"]
@@ -139,7 +197,8 @@ def _paint_pointer_and_notch(painter: QPainter, scene: dict, scale: float, point
painter.translate(px, py)
painter.scale(1.0 / scale, 1.0 / scale)
arrow = _pointer_path(pointer_size)
- painter.setPen(QPen(QColor("#000000"), 1.0))
+ painter.setPen(QPen(QColor("#000000"), 1.2 * pointer_size / 18.0,
+ Qt.PenStyle.SolidLine, Qt.PenCapStyle.FlatCap, Qt.PenJoinStyle.RoundJoin))
painter.setBrush(QColor("#ffffff"))
painter.drawPath(arrow)
painter.restore()
@@ -153,10 +212,7 @@ def _paint_pointer_and_notch(painter: QPainter, scene: dict, scale: float, point
class EffectStill(QWidget):
- """A tile's picture: its effect part-way through a push, in the chosen colour. While TileHover
- has it playing it draws each frame on from that still instead of its cached image."""
-
- STILL_AT = STILL_AT_S
+ """A crossing tile holds its canonical mid-crossing frame, then plays the full timeline on hover."""
def __init__(self, effect_id: str, palette, parent: QWidget | None = None) -> None:
super().__init__(parent)
@@ -165,6 +221,7 @@ class EffectStill(QWidget):
self.place = "edge"
self.pace = 1.0
self.effect_size = "medium"
+ self.effect_size_fraction = None
self._image = None
self.playing_since = None
policy = QSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Preferred)
@@ -194,14 +251,15 @@ class EffectStill(QWidget):
self.update()
def set_pace(self, pace: float) -> None:
- if pace != self.pace:
- self.pace = pace
- self._image = None
- self.update()
+ # The still is the same frame of the effect at every Length (effects.still_time), so its
+ # picture stands; only playing it reads the pace, and redrawing every tile at each step of
+ # the slider was most of the page's lag.
+ self.pace = pace
- def set_effect_size(self, size: str) -> None:
- if size != self.effect_size:
+ def set_effect_size(self, size: str, fraction: float | None = None) -> None:
+ if (size, fraction) != (self.effect_size, self.effect_size_fraction):
self.effect_size = size
+ self.effect_size_fraction = fraction
self._image = None
self.update()
@@ -211,10 +269,15 @@ class EffectStill(QWidget):
self._image = None
def paintEvent(self, _event) -> None:
- if self.playing_since is not None:
+ elapsed = None if self.playing_since is None else time.monotonic() - self.playing_since
+ reduced = system_reduced_motion()
+ live = elapsed is not None and elapsed >= 0.0 and not reduced
+ t = effects.preview_time(self._still_time(), elapsed, reduced=reduced,
+ switch=isinstance(self, SwitchStill))
+ if live:
painter = QPainter(self)
try:
- self._paint_still(painter, self.STILL_AT + max(0.0, time.monotonic() - self.playing_since))
+ self._paint_still(painter, t, still=False)
except Exception:
LOGGER.exception("Could not draw crossing effect %s", self.effect_id)
self.playing_since = None
@@ -228,7 +291,7 @@ class EffectStill(QWidget):
self._image.fill(Qt.GlobalColor.transparent)
image_painter = QPainter(self._image)
try:
- self._paint_still(image_painter, self.STILL_AT)
+ self._paint_still(image_painter, t, still=True)
except Exception:
LOGGER.exception("Could not draw the still of crossing effect %s", self.effect_id)
finally:
@@ -237,29 +300,24 @@ class EffectStill(QWidget):
painter.drawImage(0, 0, self._image)
painter.end()
- def _paint_still(self, painter: QPainter, t: float) -> None:
- if self.playing_since is None and self.effect_id == "beam" and self.place == "edge":
- t = 1.45
- scene = effects.preview_scene(effects.preview_effect(self.effect_id), t, self.place, self.palette,
- system_reduced_motion(), theme.is_dark(), self.pace, self.effect_size)
- if self.playing_since is None and self.effect_id not in ("glow", "beam"):
- # A representative still includes the landing; hover keeps the real timed loop.
- arrival = effects.preview_scene(effects.preview_effect(self.effect_id), 2.35, self.place, self.palette,
- system_reduced_motion(), theme.is_dark(), self.pace, self.effect_size)
- scene["pens"] += arrival["pens"][1:]
- width = STILL_VIEW_W
- view_h = min(effects.PREVIEW_SCREEN[1], width * self.height() / max(1, self.width()))
- centre = STILL_CENTRE[self.place]
- view = QRectF(centre[0] - width / 2.0, centre[1] - view_h / 2.0, width, view_h)
- paint_scene(painter, QRectF(self.rect()), view, scene, 10.0, labels=False)
+ def _paint_still(self, painter: QPainter, t: float, still: bool = False) -> None:
+ view = QRectF(*effects.still_view(self.effect_id, self.place, self.effect_size, self.pace,
+ self.effect_size_fraction))
+ scene = effects.preview_still_scene(effects.preview_effect(self.effect_id), t, self.place, self.palette,
+ system_reduced_motion(), theme.is_dark(), self.pace, self.effect_size,
+ live=not still, view_width=view.width(),
+ effect_size_fraction=self.effect_size_fraction)
+ paint_scene(painter, QRectF(self.rect()), view, scene, 11.0, labels=False)
+
+ def _still_time(self) -> float:
+ return effects.still_time(self.effect_id, self.place, self.effect_size, self.pace,
+ self.effect_size_fraction)
class SwitchStill(EffectStill):
"""A Switch tile's picture: what a switch plays for `choice` beside the crossing style, round a
still pointer, part-way through."""
- STILL_AT = SWITCH_STILL_AT_S
-
def __init__(self, choice: str, crossing_style: str, palette, parent: QWidget | None = None) -> None:
super().__init__(choice, palette, parent)
self.crossing_style = crossing_style
@@ -270,11 +328,19 @@ class SwitchStill(EffectStill):
self._image = None
self.update()
- def _paint_still(self, painter: QPainter, t: float) -> None:
+ def _paint_still(self, painter: QPainter, t: float, still: bool = False) -> None:
fx = effects.switch_effect(self.effect_id, self.crossing_style)
- scene = effects.preview_switch_scene(fx, t, self.palette, "windows", system_reduced_motion(), theme.is_dark(),
- self.pace, self.effect_size)
- paint_scene(painter, QRectF(self.rect()), SWITCH_STILL_VIEW, scene, 10.0, labels=False)
+ view = QRectF(*effects.still_view(fx, "switch", self.effect_size, self.pace,
+ self.effect_size_fraction))
+ scene = effects.preview_still_scene(fx, t, "switch", self.palette, reduced=system_reduced_motion(),
+ dark=theme.is_dark(), pace=self.pace, effect_size=self.effect_size,
+ live=not still, view_width=view.width(),
+ effect_size_fraction=self.effect_size_fraction)
+ paint_scene(painter, QRectF(self.rect()), view, scene, 11.0, labels=False)
+
+ def _still_time(self) -> float:
+ return effects.still_time(effects.switch_effect(self.effect_id, self.crossing_style), "switch",
+ self.effect_size, self.pace, self.effect_size_fraction)
class TileHover(QObject):
@@ -287,7 +353,7 @@ class TileHover(QObject):
self.loop = loop
self._pictures: dict = {}
self.current = None
- self._timer = frame_timer(self, self._tick)
+ self._timer = frame_timer(self, self._tick, max_rate=PREVIEW_MAX_RATE)
def track(self, tile: QWidget, picture: QWidget) -> None:
self._pictures[tile] = picture
@@ -312,7 +378,7 @@ class TileHover(QObject):
self.loop.hover(picture)
return
picture.playing_since = time.monotonic() + HOVER_INTENT_S
- self._timer.start()
+ start_paced(self._timer, picture, PREVIEW_MAX_RATE)
def stop(self) -> None:
picture, self.current = self.current, None
diff --git a/win_app/frame_clock.py b/win_app/frame_clock.py
new file mode 100644
index 0000000..3fdb98b
--- /dev/null
+++ b/win_app/frame_clock.py
@@ -0,0 +1,36 @@
+"""Qt timer intervals matched to the screen displaying a widget."""
+
+from PySide6.QtCore import QObject, Qt, QTimer
+from PySide6.QtGui import QGuiApplication
+
+
+def refresh_rate(widget=None) -> float:
+ """`widget`'s screen's refresh rate, or with no widget the fastest screen's: an overlay is
+ started before it moves to the display the crossing is at."""
+ screen = widget.screen() if widget is not None else None
+ screens = [screen] if screen is not None else QGuiApplication.screens()
+ rate = max((float(each.refreshRate()) for each in screens), default=0.0)
+ return rate if rate >= 1.0 else 60.0
+
+
+# The Design page's tiles are thumbnails: at a 120Hz panel's rate their hover doubled the page's
+# work for nothing anyone can see, so they play at 60 at most.
+PREVIEW_MAX_RATE = 60
+
+
+def frame_interval_ms(widget=None, max_rate=None) -> int:
+ rate = refresh_rate(widget)
+ return max(1, int(1000.0 / (min(rate, max_rate) if max_rate else rate)))
+
+
+def frame_timer(parent: QObject, tick, widget=None, max_rate=None) -> QTimer:
+ timer = QTimer(parent)
+ timer.setTimerType(Qt.TimerType.PreciseTimer)
+ timer.setInterval(frame_interval_ms(widget, max_rate))
+ timer.timeout.connect(tick)
+ return timer
+
+
+def start_paced(timer: QTimer, widget=None, max_rate=None) -> None:
+ timer.setInterval(frame_interval_ms(widget, max_rate))
+ timer.start()
diff --git a/win_app/inject_portal.py b/win_app/inject_portal.py
index 8c0729f..686653a 100644
--- a/win_app/inject_portal.py
+++ b/win_app/inject_portal.py
@@ -72,8 +72,8 @@ PIXELS_PER_CLICK = 40.0
NO_PORTAL = ("This desktop does not let apps control the keyboard and mouse (it has no RemoteDesktop "
"portal with libei), so another machine cannot drive this one and the clipboard is not shared.")
-REFUSED = ("Beamer was not allowed to control this machine, so another machine cannot drive it and the "
- "clipboard is not shared. Restart Beamer to be asked again.")
+REFUSED = ("The desktop did not allow Beamer to control this PC. Choose Ask again and allow the requested "
+ "keyboard and pointer access in the desktop prompt.")
ENDED = "The desktop stopped letting Beamer control this machine: {detail}"
CLOSED = ("Remote control was stopped from the desktop, so another machine cannot drive this one and the "
"clipboard is not shared until Beamer restarts.")
@@ -81,6 +81,15 @@ MISSING = "Beamer cannot control this machine: {detail}"
# Called with one of the sentences above when the session cannot start or ends; set by the app.
on_problem: Optional[Callable[[str], None]] = None
+on_permission: Optional[Callable[[str, str, bool], None]] = None
+
+
+def _report_permission(status: str, detail: str = "", retryable: bool = False) -> None:
+ if on_permission is not None:
+ try:
+ on_permission(status, detail, retryable)
+ except Exception:
+ LOGGER.exception("Could not report RemoteDesktop permission state")
class WaylandLayout(Layout):
@@ -220,6 +229,20 @@ class Remote:
self._thread = threading.Thread(target=self._run, name="Beamer-remote", daemon=True)
self._thread.start()
+ def request_again(self) -> None:
+ thread = self._thread
+ if thread is not None and thread.is_alive():
+ thread.join(timeout=2.0)
+ if thread.is_alive():
+ raise RuntimeError("The last RemoteDesktop session has not stopped yet")
+ with self._lock:
+ if self._closed:
+ return
+ self._terminal = False
+ self.problem = None
+ self._retry_at = 0.0
+ self.start()
+
def stop(self) -> None:
"""For good: nothing after it opens the session again."""
with self._lock:
@@ -300,11 +323,20 @@ class Remote:
ended = not problem.terminal
self._terminal = problem.terminal
self._report(problem.sentence)
+ _report_permission("refused" if problem.sentence == REFUSED else "unavailable", problem.sentence,
+ problem.sentence == CLOSED)
+ except portal.Refused:
+ self._tokens.write("")
+ self._terminal = True
+ self._report(REFUSED)
+ _report_permission("refused", REFUSED)
except Exception as exc:
if not self._stopping.is_set():
LOGGER.exception("Remote control stopped")
ended = True
- self._report(ENDED.format(detail=exc))
+ sentence = ENDED.format(detail=exc)
+ self._report(sentence)
+ _report_permission("unavailable", sentence)
finally:
if ended:
if self._tokens.read():
@@ -351,6 +383,9 @@ class Remote:
except portal.Refused:
self._tokens.write("")
raise _Problem(REFUSED, terminal=True) from None
+ if started.get("devices", 0) & (DEVICE_KEYBOARD | DEVICE_POINTER) != DEVICE_KEYBOARD | DEVICE_POINTER:
+ self._tokens.write("")
+ raise _Problem(REFUSED, terminal=True)
self._tokens.write(started.get("restore_token", ""))
self.clipboard_enabled = bool(started.get("clipboard_enabled"))
fd = portal_.call(INTERFACE, "ConnectToEIS", "oa{sv}", (self.handle, {}))[0]
@@ -363,6 +398,7 @@ class Remote:
self._eis_at = time.monotonic()
self.problem = None
self.ready.set()
+ _report_permission("ready")
desktop_portal.set_mover(lambda x, y: self.submit(lambda remote: remote.place(x, y)))
def _wait(self) -> None:
@@ -699,6 +735,10 @@ def start() -> None:
remote().start()
+def request_again() -> None:
+ remote().request_again()
+
+
def stop() -> None:
if _remote is not None:
_remote.stop()
diff --git a/win_app/inject_x11.py b/win_app/inject_x11.py
index ee5f4f5..22d1194 100644
--- a/win_app/inject_x11.py
+++ b/win_app/inject_x11.py
@@ -195,6 +195,8 @@ def plan_key(name: str, down: bool, us: Optional[str], state: KeyState, layout:
bits as they are. Updates `state`. Empty for a name this machine cannot press, and for the
peer's repeat of a key the server is already repeating."""
lowered = name.lower() if len(name) > 1 else name
+ if lowered in ("search", "spotlight"):
+ lowered = "cmd"
if lowered in MODIFIER_KEYS:
if down:
state.mods_down.add(lowered)
diff --git a/win_app/input_injector.py b/win_app/input_injector.py
index 3809dda..8a43950 100644
--- a/win_app/input_injector.py
+++ b/win_app/input_injector.py
@@ -190,6 +190,15 @@ VK_MAP = {
"volume_up": 0xAF,
"browser_back": 0xA6,
"browser_forward": 0xA7,
+ "browser_refresh": 0xA8,
+ "browser_stop": 0xA9,
+ "browser_search": 0xAA,
+ "browser_favourites": 0xAB,
+ "browser_home": 0xAC,
+ "mail": 0xB4,
+ "media_select": 0xB5,
+ "launch_app1": 0xB6,
+ "launch_app2": 0xB7,
}
for _index in range(1, 13):
@@ -225,6 +234,15 @@ EXTENDED_KEYS = {
"volume_up",
"browser_back",
"browser_forward",
+ "browser_refresh",
+ "browser_stop",
+ "browser_search",
+ "browser_favourites",
+ "browser_home",
+ "mail",
+ "media_select",
+ "launch_app1",
+ "launch_app2",
}
# Modifier key names that participate in chording with character keys.
@@ -394,6 +412,20 @@ def _locked(function):
def inject_key(name: str, down: bool, us: Optional[str] = None) -> None:
LOGGER.debug("key %s %s (mods held: %s)", name, "down" if down else "up", sorted(_mods_down))
lowered = name.lower()
+ chords = {"search": (0x5B, 0x53), "dictation": (0x5B, 0x48), "mic_mute": (0x5B, 0x12, 0x4B)}
+ if lowered in chords:
+ if down:
+ sequence = chords[lowered]
+ plan = [(vk, 0, 0) for vk in sequence]
+ plan += [(vk, 0, KEYEVENTF_KEYUP) for vk in reversed(sequence)]
+ _send_input(*(_keybd_input(vk, scan, flags) for vk, scan, flags in plan))
+ return
+ if lowered in ("brightness_up", "brightness_down"):
+ from brightness_worker import submit
+
+ if down:
+ submit(1 if lowered == "brightness_up" else -1)
+ return
held = _named_down.get(lowered) if lowered in VK_MAP and lowered not in MODIFIER_KEYS else None
if held is not None:
vk, scan, flags = held
diff --git a/win_app/kvm_bridge_win.py b/win_app/kvm_bridge_win.py
index e2c4661..b933f0f 100644
--- a/win_app/kvm_bridge_win.py
+++ b/win_app/kvm_bridge_win.py
@@ -1,21 +1,29 @@
+import time
+
+PROCESS_STARTED = time.perf_counter()
+
import argparse
import ctypes
+import copy
from dataclasses import replace
import functools
+import json
import logging
from logging.handlers import RotatingFileHandler
import os
+import platform
from pathlib import Path
import sys
import tempfile
import threading
-import time
from typing import Optional
-from PySide6.QtCore import QEvent, QObject, QRectF, QSize, QTimer, Qt, QUrl, Signal
+from PySide6.QtCore import QEvent, QObject, QPointF, QRectF, QSize, QStandardPaths, QTimer, Qt, QUrl, Signal
from PySide6.QtGui import QAction, QColor, QDesktopServices, QIcon, QKeySequence, QPainter, QPixmap, QShortcut, QStandardItem, QStandardItemModel
+from PySide6.QtNetwork import QLocalServer, QLocalSocket
from PySide6.QtWidgets import (
QApplication,
+ QBoxLayout,
QCheckBox,
QComboBox,
QFrame,
@@ -28,6 +36,7 @@ from PySide6.QtWidgets import (
QMessageBox,
QPushButton,
QScrollArea,
+ QSizePolicy,
QStackedWidget,
QStyle,
QSystemTrayIcon,
@@ -53,10 +62,12 @@ from app_config import (
save_config,
)
from core import crash_log
+from core.capture_types import DeadKey, TextInput
from core import effects
-from diagram import ArrangementDiagram, PushStrip
+from diagram import AtlasCanvas, PushStrip
from edge_glow import EdgeGlow, PreviewLoop
-from effect_overlay import EffectOverlay, logical_point
+from effect_overlay import EffectOverlay, desktop_box, logical_point
+from effect_overlay_x11 import EffectOverlayX11Proxy, available as xwayland_available
from effect_previews import EffectStill, SwitchStill, TileHover
from core import ignored
import motion
@@ -65,17 +76,19 @@ from core import keytable
from core import peerlist
from core.pairing import PairingService, local_address_towards
import machines_win
+import linux_desktop
import pages_win
import hardware_win
import peers_view
import platform_parts
import qr_code
from core import protocol
+from core import settings_sync
from core import receiver
from core.receiver import LinkResponder, ServerState
from core import return_edge
from core import settings_sync
-from core import ways
+from core import ways, crossing_state
from sender import OWN_PLATFORM, LinkSender
import theme
import tokens
@@ -151,6 +164,10 @@ def asset_path(name: str) -> Path:
return base / name
+def xwayland_effects_available() -> bool:
+ return xwayland_available(platform_parts.WAYLAND, os.environ)
+
+
ICON_PATH = asset_path("Beamer.ico")
# The OS parts keep their Windows names so the code and its tests read as before; on Linux they are
@@ -222,6 +239,31 @@ def page_column_width(free: float) -> float:
return min(880, max(1, free - 48))
+class _ElidedLabel(QLabel):
+ def __init__(self, parent=None):
+ super().__init__(parent)
+ self.full_text = ""
+ self.setWordWrap(False)
+ self.setMinimumWidth(0)
+ self.setSizePolicy(QSizePolicy.Policy.Ignored, QSizePolicy.Policy.Preferred)
+
+ def setText(self, text: str) -> None:
+ self.full_text = str(text)
+ self.setToolTip(self.full_text)
+ self.setAccessibleName(self.full_text)
+ self._refresh_elided_text()
+
+ def resizeEvent(self, event) -> None:
+ super().resizeEvent(event)
+ self._refresh_elided_text()
+
+ def _refresh_elided_text(self) -> None:
+ shown = self.fontMetrics().elidedText(
+ self.full_text, Qt.TextElideMode.ElideRight, self.contentsRect().width()
+ )
+ QLabel.setText(self, shown)
+
+
class ColumnFit(QObject):
"""Keeps a page's column at page_column_width() of the free width, on every resize of its scroll
area. The free width is the scroll area less a scrollbar's width whether or not one shows: the
@@ -238,7 +280,9 @@ class ColumnFit(QObject):
scroll.installEventFilter(self)
def fit(self) -> None:
- self.column.setFixedWidth(round(page_column_width(self.scroll.width() - 16)))
+ width = round(page_column_width(self.scroll.width() - 16))
+ if self.column.minimumWidth() != width or self.column.maximumWidth() != width:
+ self.column.setFixedWidth(width)
def eventFilter(self, watched, event) -> bool:
if event.type() in (QEvent.Type.Resize, QEvent.Type.Show):
@@ -253,6 +297,7 @@ class StatusBridge(QObject):
changed = Signal(object, str)
# The fourth names which third of the edge a Part of the edge push is in, else None.
pressure = Signal(str, float, bool, object)
+ local_pressure = Signal(str, float, bool, object)
# (method, edge, x, y): the pointer landed on this PC at desktop pixel (x, y).
arrived = Signal(str, str, float, float)
firewall = Signal(object)
@@ -276,9 +321,176 @@ class StatusBridge(QObject):
update = Signal(object)
# The firewall rules are in place (or could not be), so the sockets may open.
rules_ready = Signal()
+ permission = Signal(str, str, str, bool)
+
+
+def _instance_server_name() -> str:
+ if sys.platform == "win32":
+ kernel32 = _windows_kernel32()
+ session = ctypes.c_ulong()
+ if not kernel32.ProcessIdToSessionId(kernel32.GetCurrentProcessId(), ctypes.byref(session)):
+ raise OSError("Beamer could not identify its Windows session")
+ return f"Beamer.Receiver.{session.value}"
+ suffix = f"Beamer.Receiver.{os.getuid()}"
+ if sys.platform.startswith("linux"):
+ runtime_location = QStandardPaths.writableLocation(QStandardPaths.StandardLocation.RuntimeLocation)
+ directory = Path(runtime_location) if runtime_location else Path(tempfile.gettempdir())
+ directory.mkdir(parents=True, exist_ok=True)
+ return str(directory / f"{suffix}.sock")
+ return suffix
+
+
+def send_instance_activation(name: Optional[str] = None, activation_token: Optional[str] = None,
+ timeout_ms: int = 2000) -> bool:
+ name = name or _instance_server_name()
+ deadline = time.monotonic() + timeout_ms / 1000
+ while True:
+ socket = QLocalSocket()
+ socket.connectToServer(name)
+ if socket.waitForConnected(100):
+ payload = json.dumps({"activation_token": activation_token or ""}).encode("utf-8") + b"\n"
+ socket.write(payload)
+ return socket.waitForBytesWritten(max(1, int((deadline - time.monotonic()) * 1000)))
+ socket.abort()
+ if time.monotonic() >= deadline:
+ return False
+ time.sleep(0.05)
+
+
+class InstanceSignal(QObject):
+ def __init__(self, activate, name: Optional[str] = None, parent=None):
+ super().__init__(parent)
+ self.name = name or _instance_server_name()
+ self.activate = activate
+ QLocalServer.removeServer(self.name)
+ self.server = QLocalServer(self)
+ self.server.setSocketOptions(QLocalServer.SocketOption.UserAccessOption)
+ self.server.newConnection.connect(self._accept)
+ self.listening = self.server.listen(self.name)
+
+ def _accept(self) -> None:
+ while self.server.hasPendingConnections():
+ connection = self.server.nextPendingConnection()
+ connection.readyRead.connect(lambda socket=connection: self._read(socket))
+
+ def _read(self, connection) -> None:
+ if not connection.canReadLine():
+ return
+ try:
+ request = json.loads(bytes(connection.readLine()).decode("utf-8"))
+ except (UnicodeDecodeError, json.JSONDecodeError):
+ request = {}
+ self.activate(request.get("activation_token") or None)
+ connection.disconnectFromServer()
+
+ def close(self) -> None:
+ self.server.close()
+ QLocalServer.removeServer(self.name)
+
+
+def ways_summary_for_label(label: QLabel, *args) -> str:
+ """Build the Crossing sentence with its peer name elided to the label's line width."""
+ summary_args = list(args)
+ width = label.contentsRect().width()
+ # Before the first layout the label has no width yet; the resize that follows elides it.
+ if width > 0:
+ summary_args[6] = label.fontMetrics().elidedText(summary_args[6], Qt.TextElideMode.ElideRight, width)
+ return pages_win.ways_summary(*summary_args)
+
+
+def _crossing_refresh(method):
+ @functools.wraps(method)
+ def refresh(self, *args, **kwargs):
+ document = getattr(self, "crossing_document", None)
+ depth = getattr(self, "_crossing_update_depth", 0)
+ enabled = document.updatesEnabled() if document is not None else False
+ if document is not None and depth == 0:
+ document.setUpdatesEnabled(False)
+ self._crossing_update_depth = depth + 1
+ try:
+ return method(self, *args, **kwargs)
+ finally:
+ self._crossing_update_depth = depth
+ if document is not None and depth == 0:
+ document.setUpdatesEnabled(enabled)
+ return refresh
+
+
+class _OnResize(QObject):
+ def __init__(self, widget, callback) -> None:
+ super().__init__(widget)
+ self._callback = callback
+ widget.installEventFilter(self)
+
+ def eventFilter(self, watched, event) -> bool:
+ if event.type() == QEvent.Type.Resize:
+ self._callback()
+ return False
+
+
+def design_readout():
+ label = widgets.label("", "key")
+ label.setFixedWidth(effects.DESIGN_READOUT_WIDTH)
+ label.setAlignment(Qt.AlignmentFlag.AlignRight | Qt.AlignmentFlag.AlignVCenter)
+ return label
+
+
+class _DesignChoiceSlider:
+ def __init__(self, name, minimum, maximum, step, scale, stops, preset_names):
+ self.scale = scale
+ self.stops = stops
+ self.preset_names = preset_names
+ self.description = ("Sets the effect's playback time." if name == "Length"
+ else "Sets effect depth relative to the shorter screen edge.")
+ self.slider = widgets.Ruler(name, maximum, minimum, step=step, page_step=step * 5)
+ self.slider.setMaximumWidth(240)
+ self.view = self.slider
+ self.slider.setAccessibleDescription(self.description)
+ self.slider.sliderMoved.connect(self._snap)
+
+ @property
+ def value(self):
+ numeric = self.slider.value() / self.scale
+ return effects.length_preset(numeric) if self.slider.accessibleName() == "Length" else effects.size_preset(numeric)
+
+ def set_value(self, preset):
+ index = next((i for i, (key, _name) in enumerate(self.preset_names) if key == preset), 1)
+ self.set_numeric(self.stops[index])
+
+ def numeric_value(self):
+ return self.slider.value() / self.scale
+
+ def set_numeric(self, value):
+ # Like the choice controls, only the user's own move reaches the change path: a value shown
+ # from the config or a followed design must not save back and announce itself.
+ blocked = self.slider.blockSignals(True)
+ try:
+ self.slider.setValue(round(value * self.scale))
+ finally:
+ self.slider.blockSignals(blocked)
+
+ def set_accessible_value(self, value):
+ self.slider.setAccessibleDescription(f"{self.description} Current value: {value}.")
+
+ def set_enabled(self, enabled: bool) -> None:
+ self.slider.setEnabled(bool(enabled))
+ widgets.set_dimmed(self.slider, not enabled)
+
+ def _snap(self, value):
+ snapped = effects.snap_detent(value, self.slider.minimum(), self.slider.maximum(),
+ tuple(round(stop * self.scale) for stop in self.stops))
+ if snapped != value:
+ self.slider.setValue(round(snapped))
class WindowsApplication(QWidget):
+ def paintEvent(self, event) -> None:
+ super().paintEvent(event)
+ if self._start_after_first_paint and not self._startup_painted:
+ self._startup_painted = True
+ LOGGER.info("Window painted %.3f seconds after process start", time.perf_counter() - PROCESS_STARTED)
+ QTimer.singleShot(0, self.start)
+
def resizeEvent(self, event):
super().resizeEvent(event)
if hasattr(self, "sidebar"):
@@ -286,20 +498,30 @@ class WindowsApplication(QWidget):
if hasattr(self, "footer_note"):
self.footer_note.setVisible(self.width() >= 640)
- def __init__(self, config_path: Path) -> None:
+ def __init__(self, config_path: Path, start_after_first_paint: bool = False) -> None:
super().__init__()
widgets.install_text_localisation()
self.config_path = config_path
self._status_lock = threading.RLock()
self._status = ServerState.STOPPED
self._status_detail = "Initialising"
+ self._last_refusal = ""
+ self._refusal_notices = peerlist.RefusalThrottle()
self._config = None
self._closing = False
+ self.tray_available = QSystemTrayIcon.isSystemTrayAvailable()
+ self._start_after_first_paint = start_after_first_paint
+ self._startup_painted = False
self._page = "overview"
self._apply_serial = 0
self.bridge = StatusBridge()
+ self.permission_state = None
+ if pages_win.linux_permissions_visible(sys.platform, platform_parts.WAYLAND):
+ self.permission_state = pages_win.LinuxPermissionState()
+ self.permission_state.on_change = self.bridge.permission.emit
self.bridge.changed.connect(self._on_status)
self.bridge.pressure.connect(self._on_pressure)
+ self.bridge.local_pressure.connect(self._on_local_pressure)
self.bridge.arrived.connect(self._on_arrival)
self.bridge.firewall.connect(self._on_firewall)
self.bridge.paired.connect(self._on_paired)
@@ -312,6 +534,7 @@ class WindowsApplication(QWidget):
self.bridge.settings.connect(self._on_settings)
self.bridge.update.connect(self._on_update)
self.bridge.rules_ready.connect(self._listen)
+ self.bridge.permission.connect(self._on_permission)
self._update = None
self._effects_failed = False
self._code_shown = False
@@ -325,7 +548,6 @@ class WindowsApplication(QWidget):
# The machine the Crossing page shows and edits, by id; the first paired one until a choice.
self._chosen: Optional[str] = None
self._crossing_seen = None
- self._machine_items: tuple = ()
self.machine_actions: dict = {}
self._labels_by_id: dict = {}
self._peers_tick = 0
@@ -379,14 +601,24 @@ class WindowsApplication(QWidget):
zones=self._zones,
status_callback=self.bridge.sending.emit,
redirect_callback=self.bridge.redirecting.emit,
- pressure_callback=self.bridge.pressure.emit,
+ pressure_callback=self._relay_sender_pressure,
arrival_callback=lambda edge, x, y: self.bridge.arrived.emit(
"switch" if edge is None else "edge", edge or "", float(x), float(y)
),
desktop=platform_parts.desktop,
clipboard=platform_parts.clipboard,
)
+ self._own_display_map = {}
+ app = QApplication.instance()
+ for screen in app.screens():
+ screen.geometryChanged.connect(self._displays_changed)
+ app.screenAdded.connect(self._screen_added)
+ app.screenRemoved.connect(self._displays_changed)
+ self._refresh_own_displays()
self.sender.driven = lambda: self.server.driven
+ self.resistance_pressure_timer = QTimer(self)
+ self.resistance_pressure_timer.setInterval(33)
+ self.resistance_pressure_timer.timeout.connect(self._refresh_local_pressure)
self.sender.send_peer_home = self.server.send_home
# Same on all machines, over either link: applied on the GUI thread, and announced with
# this PC's own arrangement the moment a link comes up.
@@ -410,7 +642,16 @@ class WindowsApplication(QWidget):
self.server.edges_held = lambda: self.sender.edges_held
self.sender.on_alert = self.bridge.alert.emit
self.bridge.alert.connect(self._on_alert)
- self.hooks = capture_win.Hooks(self._on_hook_key, self._on_hook_mouse, self.sender.on_motion)
+ hook_callbacks = (self._on_hook_key, self._on_hook_mouse, self.sender.on_motion)
+ if sys.platform.startswith("win"):
+ self.hooks = capture_win.Hooks(*hook_callbacks, on_seam=self.sender.seam_clip_position)
+ else:
+ self.hooks = capture_win.Hooks(*hook_callbacks)
+ if self.permission_state is not None and hasattr(self.hooks, "on_permission"):
+ self.hooks.on_permission = lambda status, detail="", retryable=False: self.permission_state.report(
+ "capture", status, detail, retryable,
+ )
+ self.permission_state.bind_requester("capture", self.hooks.request_again)
# X11 cannot swallow one event, only grab the devices; the capture thread holds the grab
# for as long as input is away.
grab_while = getattr(self.hooks, "grab_while", None)
@@ -425,6 +666,11 @@ class WindowsApplication(QWidget):
self.sender.input_held = lambda: self.hooks.holding
if hasattr(platform_parts.injector, "on_problem"):
platform_parts.injector.on_problem = lambda sentence: self.bridge.alert.emit("Beamer", sentence)
+ if self.permission_state is not None and hasattr(platform_parts.injector, "on_permission"):
+ platform_parts.injector.on_permission = lambda status, detail="", retryable=False: self.permission_state.report(
+ "remote", status, detail, retryable,
+ )
+ self.permission_state.bind_requester("remote", platform_parts.injector.request_again)
self._trigger = capture_win.Trigger()
self._sending_detail = "Not connected"
self.update_checker = updates.Checker(
@@ -477,7 +723,7 @@ class WindowsApplication(QWidget):
self.refresh_timer = QTimer(self)
self.refresh_timer.setInterval(250)
- self.refresh_timer.timeout.connect(self._refresh_window)
+ self.refresh_timer.timeout.connect(lambda: self._refresh_window(skip_hidden=True))
self.refresh_timer.start()
self.full_screen_timer = QTimer(self)
self.full_screen_timer.setInterval(FULL_SCREEN_CHECK_MS)
@@ -521,8 +767,15 @@ class WindowsApplication(QWidget):
footer_layout.setContentsMargins(16, 10, 16, 10)
self.footer_note = widgets.label(pages_win.footer("overview"), "note", wrap=True)
footer_layout.addWidget(self.footer_note)
+ footer_layout.addStretch(1)
+ self.quit_button = QPushButton("Quit Beamer")
+ self.quit_button.clicked.connect(self.quit)
+ footer_layout.addWidget(self.quit_button)
outer.addWidget(footer)
+ self.quit_shortcut = QShortcut(QKeySequence("Ctrl+Q"), self)
+ self.quit_shortcut.activated.connect(self.quit)
+
current = self._config or default_config()
builders = {
"overview": self._overview_page,
@@ -572,11 +825,12 @@ class WindowsApplication(QWidget):
layout = QVBoxLayout(content)
layout.setContentsMargins(0, 24, 0, 24)
layout.setSpacing(20)
- heading = widgets.label(title.upper(), "heading")
+ heading = widgets.label(title if key == "crossing" else title.upper(), "heading")
heading.setFont(theme.font(theme.HEADING, 700))
layout.addWidget(heading)
- layout.addWidget(widgets.label(purpose, "note", wrap=True))
- if scope is not None:
+ if key != "crossing":
+ layout.addWidget(widgets.label(purpose, "note", wrap=True))
+ if scope is not None and key != "crossing":
# Whose settings these are, not something happening now, so not signal: on light,
# signal reads as a link.
self.scope_labels[key] = widgets.label(scope, "note-quiet", wrap=True)
@@ -596,16 +850,20 @@ class WindowsApplication(QWidget):
self.ignored_recorder.cancel()
if key != "crossing":
self.trigger_recorder.cancel()
- self.jump_recorder.cancel()
+ self.crossing_ledger.cancel_recording()
self._run_previews()
# -- Overview ---------------------------------------------------------------------------
def _overview_page(self, layout, current) -> None:
self.machines = machines_win.MachinesModule(
- self._set_peer_send, self._set_peer_allow, self._set_peer_in_use, self._remove_peer, self._toggle_pairing_sheet
+ self._set_peer_send, self._set_peer_allow, self._set_peer_in_use, self._set_peer_left_out,
+ self._remove_peer, self._toggle_pairing_sheet, self._rename_peer,
+ on_cycle=self._set_shortcut_cycle,
+ on_repair=self._re_pair,
)
layout.addWidget(self.machines)
+ layout.addWidget(self._name_module(current))
self.sheet = machines_win.PairingSheet(
self._show_code, self._cancel_code, self._pair_clicked, self._pick_machine
)
@@ -615,11 +873,139 @@ class WindowsApplication(QWidget):
layout.addWidget(self.link_module)
layout.addWidget(self._input_module())
layout.addWidget(self._same_module(current))
+ self.permissions_module = None
+ if pages_win.linux_permissions_visible(sys.platform, platform_parts.WAYLAND):
+ self.permissions_module = self._permissions_module()
+ layout.addWidget(self.permissions_module)
self.sign_in_module = self._sign_in_module()
layout.addWidget(self.sign_in_module)
layout.addWidget(self._updates_module(current))
self._refresh_peers()
+ def _name_module(self, current: Config) -> QWidget:
+ module = widgets.Module("This machine")
+ line = QHBoxLayout()
+ self.own_name_label = widgets.label(current.name or platform.node(), "readout", wrap=True)
+ self.own_name_label.setMinimumWidth(0)
+ self.own_name_label.setSizePolicy(QSizePolicy.Policy.Ignored, QSizePolicy.Policy.Preferred)
+ line.addWidget(self.own_name_label, 1)
+ self.own_name_rename = widgets.ActionButton("Rename")
+ self.own_name_rename.setProperty("vernier", "small")
+ self.own_name_rename.setMinimumWidth(self.own_name_rename.sizeHint().width())
+ self.own_name_rename.clicked.connect(self._begin_own_rename)
+ line.addWidget(self.own_name_rename)
+ module.body.addLayout(line)
+ self.own_name_edit = machines_win.RenameEdit()
+ self.own_name_edit.setMaxLength(protocol.MAX_NAME_CHARS)
+ self.own_name_edit.setText(current.name)
+ self.own_name_edit.saved.connect(self._save_own_rename)
+ self.own_name_edit.cancelled.connect(self._cancel_own_rename)
+ self.own_name_edit.setVisible(False)
+ module.body.addWidget(self.own_name_edit)
+ self.own_name_note = widgets.label("", "note-quiet", wrap=True)
+ self.own_name_note.setVisible(False)
+ module.body.addWidget(self.own_name_note)
+ return module
+
+ def _begin_own_rename(self) -> None:
+ self.own_name_edit.setText(self._config.name)
+ self.own_name_label.setVisible(False)
+ self.own_name_rename.setVisible(False)
+ self.own_name_edit.setVisible(True)
+ self.own_name_note.setText("Only on this computer" if sys.platform.startswith("linux") else "Only on this PC")
+ self.own_name_note.setVisible(not settings_sync.group_on(self._config, "names"))
+ self.own_name_edit.setFocus()
+ self.own_name_edit.selectAll()
+
+ def _save_own_rename(self, text: str) -> None:
+ label = text.strip()[:protocol.MAX_NAME_CHARS]
+ settings = app_config.load_settings(self.config_path)
+ settings["name"] = label
+ settings["name_set_at"] = settings_sync.next_stamp(settings.get("name_set_at", 0), time.time())
+ settings["name_by"] = settings["machine_id"]
+ try:
+ app_config.write_settings(self.config_path, settings)
+ except (ConfigError, OSError) as exc:
+ LOGGER.exception("This PC's name could not be saved")
+ self.footer_note.setText(f"Could not save this PC's name: {exc}")
+ self._cancel_own_rename()
+ return
+ self._config = replace(self._config, name=label)
+ self.own_name_label.setText(label or platform.node())
+ if settings_sync.group_on(self._config, "names"):
+ self._send_same()
+ self._cancel_own_rename()
+
+ def _cancel_own_rename(self) -> None:
+ self.own_name_edit.setVisible(False)
+ self.own_name_note.setVisible(False)
+ self.own_name_label.setVisible(True)
+ self.own_name_rename.setVisible(True)
+
+ def _rename_peer(self, token: str, text: str) -> None:
+ settings = app_config.load_settings(self.config_path)
+ entry = next((item for item in settings["peers"] if item.get("token") == token), None)
+ if entry is None:
+ return
+ entry.update(settings_sync.rename_peer(entry, text, settings["machine_id"], time.time()))
+ try:
+ app_config.write_settings(self.config_path, settings)
+ except (ConfigError, OSError) as exc:
+ LOGGER.exception("A machine's name could not be saved")
+ self.footer_note.setText(f"Could not save the machine's name: {exc}")
+ return
+ self._refresh_peers()
+ if settings_sync.group_on(self._config, "names"):
+ self._send_same()
+
+ def _permissions_module(self) -> QWidget:
+ module = widgets.Module("Linux permissions")
+ module.body.addWidget(widgets.label(
+ "Beamer requests keyboard and pointer access when each Wayland session starts.", "note", wrap=True,
+ ))
+ self.permission_rows = {}
+ titles = {"capture": "Send input — Input Capture", "remote": "Receive input — Remote Desktop"}
+ for direction, title in titles.items():
+ row = QVBoxLayout()
+ line = QHBoxLayout()
+ line.setSpacing(10)
+ name = widgets.label(title, "body", wrap=True)
+ name.setMinimumWidth(0)
+ line.addWidget(name, 1)
+ status = widgets.label("Not requested", "note")
+ status.setMinimumWidth(92)
+ line.addWidget(status)
+ retry = QPushButton("Ask again")
+ retry.clicked.connect(lambda _checked=False, key=direction: self._ask_permission_again(key))
+ line.addWidget(retry)
+ row.addLayout(line)
+ detail = widgets.label("", "note", wrap=True)
+ detail.setVisible(False)
+ row.addWidget(detail)
+ module.body.addLayout(row)
+ self.permission_rows[direction] = (status, detail, retry)
+ self._on_permission(direction, *self.permission_state.status(direction),
+ self.permission_state.can_ask_again(direction))
+ return module
+
+ def _on_permission(self, direction: str, status: str, detail: str, retryable: bool) -> None:
+ rows = getattr(self, "permission_rows", {})
+ if direction not in rows:
+ return
+ status_label, detail_label, retry = rows[direction]
+ status_label.setText({
+ "not_requested": "Not requested", "ready": "Ready", "refused": "Refused", "unavailable": "Unavailable",
+ }[status])
+ detail_label.setText(detail)
+ detail_label.setVisible(bool(detail))
+ retry.setVisible(retryable)
+
+ def _ask_permission_again(self, direction: str) -> None:
+ try:
+ self.permission_state.ask_again(direction)
+ except Exception as exc:
+ self.permission_state.report(direction, "unavailable", str(exc))
+
def _updates_module(self, current: Config) -> QWidget:
module = widgets.Module("Updates")
self.updates_switch = widgets.Switch("Check for updates")
@@ -700,7 +1086,7 @@ class WindowsApplication(QWidget):
"""The everyday buttons: send input across without the shortcut or an edge, and hold the
edges for a while."""
module = widgets.Module("Keyboard and mouse")
- self.redirect_button = widgets.ActionButton("Send input across")
+ self.redirect_button = widgets.ElidingActionButton("Send input across")
self.redirect_button.setProperty("vernier", "primary")
self.redirect_button.setCursor(Qt.CursorShape.PointingHandCursor)
self.redirect_button.clicked.connect(self.toggle_redirect)
@@ -785,23 +1171,62 @@ class WindowsApplication(QWidget):
def _on_alert(self, title: str, message: str) -> None:
if self._closing:
return
+ if message.startswith("Can't cross to"):
+ self._last_refusal = message
+ self._refresh_tray_state()
+ if not self._refusal_notices.allow(message):
+ return
if message.startswith("Cannot switch"):
QApplication.beep()
self.tray.showMessage(title, self._shown(message), QIcon(str(ICON_PATH)), 4000)
def _same_module(self, current: Config) -> QWidget:
module = widgets.Module("Settings")
- self.same_switch = widgets.Switch("Same on all machines")
- self.same_switch.setFont(theme.font(theme.TYPE["body"]))
- self.same_switch.setChecked(current.same_on_both)
- self.same_switch.toggled.connect(self._set_same)
- module.body.addWidget(self.same_switch)
+ module.body.addWidget(widgets.label("Same on all machines", "body"))
+ self.same_checks = {}
+ for key, title in (("crossing", "Crossing"), ("design", "Design"),
+ ("shortcut", "Shortcut"), ("names", "Names")):
+ check = widgets.QCheckBox(title)
+ check.setFont(theme.font(theme.TYPE["body"]))
+ check.setChecked(key in current.same_groups if key != "everything" else len(current.same_groups) == 4)
+ check.toggled.connect(lambda on, name=key: self._same_group_toggled(name, on))
+ module.body.addWidget(check)
+ self.same_checks[key] = check
+ self.same_content_note = widgets.label(
+ "Crossing shares resistance and drag protection. Design shares effects, colour, length, size and arrival animation. "
+ "Shortcut shares shortcut on/off, trigger key and style, and destination. Names shares this machine's name and paired-machine labels.",
+ "note", wrap=True)
+ module.body.addWidget(self.same_content_note)
+ check = widgets.QCheckBox("Everything")
+ check.setFont(theme.font(theme.TYPE["body"]))
+ check.setChecked(len(current.same_groups) == 4)
+ check.toggled.connect(lambda on: self._same_group_toggled("everything", on))
+ module.body.addWidget(check)
+ self.same_checks["everything"] = check
+ self.same_everything_note = widgets.label(
+ "Shares every group and can replace local values on this machine.", "note", wrap=True)
+ module.body.addWidget(self.same_everything_note)
+ self.same_old_note = widgets.label(
+ "Older Beamer versions share known Crossing and Design settings without group choices.", "note-amber", wrap=True)
+ module.body.addWidget(self.same_old_note)
+ self.same_revert = QPushButton("Revert")
+ self.same_revert.setProperty("vernier", "small")
+ self.same_revert.clicked.connect(self._revert_same)
+ module.body.addWidget(self.same_revert)
self.same_note = widgets.label("", "note", wrap=True)
module.body.addWidget(self.same_note)
- if self._config is None or not self._paired:
- self.same_switch.setEnabled(False)
return module
+ def _same_group_toggled(self, group: str, on: bool) -> None:
+ groups = set(self._config.same_groups)
+ if group == "everything":
+ groups = set(settings_sync.groups_for_choice(["everything"] if on else []))
+ elif on:
+ groups.add(group)
+ else:
+ groups.discard(group)
+ self._set_same_groups(groups)
+
def _own_note(self) -> QWidget:
"""A note on a row this PC keeps to itself, shown only while the pages are kept in step."""
note = widgets.label(pages_win.OWN_ROW, "note", wrap=True)
@@ -812,46 +1237,138 @@ class WindowsApplication(QWidget):
def _show_same(self) -> None:
if self._config is None:
return
- old = any("settings" not in caps for caps in self._peer_caps().values())
- on = self._config.same_on_both and not old
- if self.same_switch.isChecked() != on:
- self.same_switch.blockSignals(True)
- self.same_switch.setChecked(on)
- self.same_switch.blockSignals(False)
+ old = any("layout" not in caps for caps in self._peer_caps().values())
+ groups = settings_sync.normalise_groups(self._config.same_groups)
+ stored = self._window_settings()
+ revert = settings_sync.snapshot_available(stored.get("same_before_sync"))
desktops = peerlist.desktops(self._peer_entries)
- self.same_switch.setEnabled(self._paired and bool(desktops) and not old)
+ on = self._config.same_on_both
who = settings_sync.who([self._shown(label) for label in peerlist.labels(desktops).values()])
- self.same_note.setText(settings_sync.switch_note(who, self._config.same_on_both, old))
+ self._refresh_design_follow()
+ seen = (tuple(groups), old, revert, on, who, self._paired)
+ if seen == getattr(self, "_same_controls_seen", None):
+ return
+ self._same_controls_seen = seen
+ for key in settings_sync.ALL_GROUPS:
+ self.same_checks[key].blockSignals(True)
+ self.same_checks[key].setChecked(key in groups)
+ self.same_checks[key].blockSignals(False)
+ self.same_checks[key].setEnabled(self._paired)
+ self.same_checks["everything"].blockSignals(True)
+ self.same_checks["everything"].setChecked(len(groups) == len(settings_sync.ALL_GROUPS))
+ self.same_checks["everything"].blockSignals(False)
+ self.same_checks["everything"].setEnabled(self._paired)
+ self.same_everything_note.setVisible(len(groups) == len(settings_sync.ALL_GROUPS))
+ self.same_old_note.setVisible(old)
+ self.same_revert.setVisible(revert)
+ self.same_note.setText(settings_sync.group_note(groups, on))
self.same_note.setToolTip(settings_sync.switch_detail())
- widgets.set_role(self.same_note, "note-amber" if old else "note")
+ widgets.set_role(self.same_note, "note")
for key, label in self.scope_labels.items():
- text = settings_sync.scope(key, who, on, pages_win.SCOPE.get(key))
+ text = settings_sync.scope(key, who, on, pages_win.SCOPE.get(key), groups=groups)
if label.text() != text:
label.setText(text)
for note in self.own_notes:
if motion.target_shown(note) != on:
motion.set_shown(note, on)
- self._refresh_design_follow()
- def _same_fields(self) -> tuple:
- return tuple(settings_sync.pc_values(self._config).values())
+ def _set_same_groups(self, groups) -> None:
+ if self._config is None:
+ return
+ groups = list(settings_sync.normalise_groups(groups))
+ config = self._config
+ # Each value keeps the stamp it held, never the new one: a choice of groups changes no value.
+ held = settings_sync.held_stamps(config.same_stamps, config.same_set_at, config.same_by)
+ config.same_stamps = settings_sync.stored_stamps(held)
+ config.same_groups = groups
+ config.same_on_both = bool(groups)
+ config.same_set_at = settings_sync.next_stamp(config.same_set_at, time.time())
+ config.same_by = config.machine_id
+ if self._persist():
+ self._send_same()
+ if not settings_sync.group_on(self._config, "design"):
+ self._apply_followed_design(force=True)
+ self._show_same()
+
+ def _revert_same(self) -> None:
+ settings = app_config.load_settings(self.config_path)
+ restored = settings_sync.restore_snapshot(settings.get("same_before_sync"))
+ if restored is None:
+ return
+ config = replace(self._config)
+ values, conflict = ways.shared_trigger_values(settings, restored["values"])
+ if conflict:
+ self._show_trigger_conflict(conflict)
+ held = settings_sync.held_stamps(config.same_stamps, config.same_set_at, config.same_by)
+ before = settings_sync.pc_values(config)
+ design_stamp = settings_sync.design_change_stamp(before, values,
+ config.design_set_at, None, config.machine_id)
+ settings_sync.apply_pc(config, values)
+ if design_stamp is not None:
+ config.design_set_at, config.design_by = design_stamp["set_at"], design_stamp["by"]
+ # The values put back are a change made here: each is stamped, and nothing else is.
+ held, _stamp = settings_sync.stamp_changes(held, before, settings_sync.pc_values(config), config.machine_id,
+ floor=max(config.same_set_at, config.design_set_at))
+ config.same_stamps = settings_sync.stored_stamps(held)
+ names = settings_sync.restamp_names(settings, restored.get("names", {}), config.machine_id)
+ settings_sync.apply_names(settings, names)
+ config.name = settings.get("name", config.name)
+ config.same_groups = settings_sync.revert_groups(settings["same_before_sync"], config.same_groups)
+ config.same_on_both = bool(config.same_groups)
+ config.same_set_at = settings_sync.next_stamp(max(config.same_set_at, config.design_set_at), time.time())
+ config.same_by = config.machine_id
+ settings.pop("same_before_sync", None)
+ settings.update(app_config.config_to_dict(config))
+ try:
+ app_config.write_settings(self.config_path, settings)
+ except (ConfigError, OSError):
+ LOGGER.exception("Same settings could not be reverted")
+ return
+ self._config = config
+ self._apply_config(config)
+ self._reflect_config(config)
+ self.own_name_label.setText(config.name or platform.node())
+ self._send_same()
+ self._show_same()
+
+ def _same_fields(self) -> dict:
+ return settings_sync.pc_values(self._config)
def _design_fields(self) -> tuple:
values = settings_sync.pc_values(self._config)
return tuple(values.get(key) for key in settings_sync.DESIGN_KEYS)
def _same_state(self) -> dict:
+ import sys
+
config = self._config
+ settings = app_config.load_settings(self.config_path)
+ configure_seams = getattr(self, "_configure_capture_seams", None)
+ if callable(configure_seams):
+ configure_seams(config)
values = settings_sync.pc_values(config)
design_state = {
"set_at": config.design_set_at,
"by": config.design_by or config.machine_id,
- "values": {key: values[key] for key in settings_sync.DESIGN_KEYS},
+ "values": {key: values[key] for key in settings_sync.DESIGN_KEYS if key in values},
"path": (self._design_path or [config.machine_id])
- if config.design_follow_peer and not config.same_on_both else [config.machine_id],
+ if config.design_follow_peer and not settings_sync.group_on(config, "design") else [config.machine_id],
}
+ current_settings = app_config.load_settings(self.config_path)
+ layout_tiles = copy.deepcopy(config.layout)
+ for entry in peerlist.desktops(current_settings.get("peers", [])):
+ tile = layout_tiles.get(entry.get("id"))
+ name = entry.get("name", "")
+ if isinstance(tile, dict) and isinstance(name, str) and name.strip():
+ tile["name"] = name.strip()[:64]
+ layout_state = {"set_at": config.layout_set_at, "by": config.layout_by or config.machine_id,
+ "tiles": layout_tiles}
return settings_sync.message_data(
- config.same_on_both, config.same_set_at, values, by=config.same_by, design_state=design_state
+ config.same_on_both, config.same_set_at, values, by=config.same_by, design_state=design_state,
+ names=settings_sync.names_from_settings(current_settings),
+ layout_state=layout_state,
+ groups=config.same_groups,
+ stamps=settings_sync.held_stamps(config.same_stamps, config.same_set_at, config.same_by),
)
def _live(self, peer: str) -> bool:
@@ -867,28 +1384,7 @@ class WindowsApplication(QWidget):
return entry is not None and self.sender.links.kind(entry.get("token")) == "forgotten"
def _settle_presence(self) -> None:
- """Puts back the zones set aside for a machine that has connected since, and keeps off for good,
- and says so, those of one that has removed this pairing (core/ways.py settle_presence)."""
- if self._config is None or not ways.presence_due(self._crossing_settings(), self._live, self._gone):
- return
- self._read_crossing()
- before = ways.way_back_state(self._crossing_settings())
- try:
- changed, notices = app_config.settle_presence(self.config_path, self._live, self._gone)
- except (ConfigError, OSError):
- LOGGER.exception("The zones set aside could not be settled")
- return
- if not changed:
- return
- for notice in notices:
- self._on_alert("Beamer", notice)
- self._pull_peer_fields()
- self.sender.refresh()
- self.server.peers_changed()
- self._read_crossing()
- for target, state in ways.way_back_state(self._crossing_settings()).items():
- if before.get(target) != state:
- self._tell(target)
+ return
def _design_peer_caps(self) -> dict:
desktops = {entry.get("id") for entry in peerlist.desktops(self._peer_entries)}
@@ -903,16 +1399,22 @@ class WindowsApplication(QWidget):
if not hasattr(self, "design_follow_choice") or self._config is None:
return
choice = self.design_follow_choice
+ caps = self._design_peer_caps()
+ desktops = [entry for entry in peerlist.desktops(self._peer_entries) if protocol.read_id(entry.get("id")) is not None]
+ seen = repr((desktops, caps, self._design_states, self._config.design_follow_peer,
+ settings_sync.group_on(self._config, "design"), self._config.hide_addresses))
+ if seen == getattr(self, "_design_follow_seen", None):
+ return
+ self._design_follow_seen = seen
choice.blockSignals(True)
model = QStandardItemModel(choice)
none = QStandardItem("None")
none.setData("", Qt.ItemDataRole.UserRole)
model.appendRow(none)
- caps = self._design_peer_caps()
- desktops = [entry for entry in peerlist.desktops(self._peer_entries) if protocol.read_id(entry.get("id")) is not None]
rows = settings_sync.follow_rows(desktops, caps, self._design_states, self._config.design_follow_peer)
for entry, why_not in rows:
- name = self._shown(entry.get("name") or entry.get("platform") or "Paired machine")
+ name = self._shown(peerlist.label_for(desktops, peer_id=entry.get("id") or "")
+ or entry.get("platform") or "Paired machine")
item = QStandardItem(f"{name} — {why_not}" if why_not == settings_sync.NEEDS_DESIGN_SYNC else name)
item.setData(entry["id"], Qt.ItemDataRole.UserRole)
if why_not is not None:
@@ -925,9 +1427,9 @@ class WindowsApplication(QWidget):
choice.blockSignals(False)
desktops = peerlist.desktops(self._peer_entries)
peer = next((item for item in desktops if item.get("id") == self._config.design_follow_peer), None)
- name = self._shown(peer.get('name') or 'that machine') if peer else ""
+ name = self._shown(peerlist.label_for(desktops, peer_id=peer.get("id") or "") or "that machine") if peer else ""
if peer:
- if self._config.same_on_both:
+ if settings_sync.group_on(self._config, "design"):
note = f"Following {name}, paused while Same on all machines is on."
elif self._config.design_follow_peer not in caps:
note = f"Keeping the last design received from {name} until it reconnects."
@@ -938,7 +1440,7 @@ class WindowsApplication(QWidget):
self.design_follow_note.setText(note)
self.design_follow_note.setVisible(bool(note))
self._lock_followed_design(
- settings_sync.follow_lock(self._config.design_follow_peer, self._config.same_on_both, desktops), name)
+ settings_sync.follow_lock(self._config.design_follow_peer, settings_sync.group_on(self._config, "design"), desktops), name)
def _lock_followed_design(self, entry, name: str) -> None:
"""Followed controls dimmed and deaf while `entry` is followed; the local ones stay live."""
@@ -993,13 +1495,13 @@ class WindowsApplication(QWidget):
config = self._config
peer = config.design_follow_peer
state = self._design_states.get(peer)
- if not peer or state is None or config.same_on_both:
+ if not peer or state is None or settings_sync.group_on(config, "design"):
return
current = settings_sync.pc_values(config)
cursor = self._followed_version
stamp, author = cursor[1:] if cursor and cursor[0] == peer else (-1, "")
taken = settings_sync.followed_design(
- current, state, peer, peer, config.same_on_both, stamp,
+ current, state, peer, peer, settings_sync.group_on(config, "design"), stamp,
author, own_id=config.machine_id, force=force,
)
if taken is None:
@@ -1015,6 +1517,8 @@ class WindowsApplication(QWidget):
config.design_set_at = settings_sync.next_stamp(config.design_set_at, time.time())
config.design_by = config.machine_id
self._design_seen = tuple(getattr(config, key) for key in settings_sync.DESIGN_KEYS)
+ # A followed design is not a choice made here: no value of it is stamped, as on the Mac.
+ self._same_seen = self._same_fields()
self._reflect_config(config)
if not self._persist():
return
@@ -1024,14 +1528,14 @@ class WindowsApplication(QWidget):
self._send_same()
self._refresh_design_follow()
- def _send_same(self, source: Optional[bytes] = None, data: Optional[dict] = None) -> None:
+ def _send_same(self, source: Optional[bytes] = None, data: Optional[dict] = None, *, layout_only=False) -> None:
"""This PC's state, or `data` unchanged when a newer one arrived and goes on (section 10), to
every peer that takes it but the one it came from: on the link this PC opened when that is
up, else on the one the peer opened."""
- message = protocol.settings_msg(data if data is not None else self._same_state())
+ state = data if data is not None else self._same_state()
for peer, caps in self._peer_caps().items():
- if peer != source and "settings" in caps:
- self._send_to(peer, message)
+ if peer != source and ("layout" if layout_only else "settings") in caps:
+ self._send_to(peer, protocol.settings_msg(settings_sync.for_capabilities(state, caps)))
def _peer_caps(self) -> dict:
"""{peer id: capabilities} for every peer with a link up, in either direction."""
@@ -1048,33 +1552,46 @@ class WindowsApplication(QWidget):
"""What this PC tells a peer on every new link (section 3): the side it holds for the peer,
once one has been set; the peers it may send to, when it may send to this one; and its
Same on all machines state. On the link's thread."""
- config = self._config
- if config is None:
+ if self._config is None:
return []
- try:
- peers = self.book.peers()
- except Exception:
- LOGGER.exception("The peers could not be read for an announcement")
+ if any(protocol.read_id(item.get("id")) == peer and item.get("port") == 0 for item in self.book.peers()):
return []
+ with app_config.SETTINGS_LOCK:
+ settings = app_config.load_settings(self.config_path)
+ held_settings = copy.deepcopy(settings)
+ for entry in settings["peers"]:
+ known = self._peer_caps().get(protocol.read_id(entry.get("id")))
+ if known is not None:
+ entry["caps"] = sorted(known)
+ outcome = crossing_state.link_up(
+ settings, protocol.id_text(peer), platform="pc", own_displays=self._own_displays(),
+ now=time.time(), capable=self._layout_capable())
+ outcome["changed"] = outcome["settings"] != held_settings
+ # The opening link sends the returned list after this callback; sending its
+ # picture here would overtake the arrangement, especially for a gap peer.
+ carry = dict(outcome, tell=[ident for ident in outcome["tell"] if ident != protocol.id_text(peer)],
+ send_picture=False)
+ self._carry_crossing(carry, redraw=False)
+ if outcome["send_picture"]:
+ self._send_same(source=peer, layout_only=True)
+ peers = outcome["settings"]["peers"]
entry = next((item for item in peers if protocol.read_id(item.get("id")) == peer), None)
if entry is None:
return []
messages = []
- author = protocol.read_id(entry.get("side_by")) or protocol.read_id(config.machine_id)
- if entry.get("port") != 0 and entry.get("side") in return_edge.EDGES and entry.get("side_set_at") and author is not None:
- settings = {"machine_id": protocol.id_text(self._identity()["id"]), "peers": peers,
- "zones": self.book.zones()}
- way_back = ways.has_way(settings, entry["id"])
- holder = protocol.read_id(ways.way_back_by(settings, entry["id"]))
- messages.append(protocol.arrangement_v6(entry["side"], entry["side_set_at"], author,
- way_back=way_back, way_back_by=holder))
+ author = protocol.read_id(entry.get("side_by")) or protocol.read_id(self._config.machine_id)
+ if (entry["id"] in outcome["tell"] or entry["id"] in self._layout_capable()) and author is not None:
+ messages.append(protocol.arrangement_v6(
+ entry.get("side") or "right", int(entry.get("side_set_at", 0)), author,
+ way_back=ways.has_way(outcome["settings"], entry["id"]),
+ way_back_by=protocol.read_id(ways.way_back_by(outcome["settings"], entry["id"]))))
if entry.get("in_use", True) is True and entry.get("send"):
- others = [protocol.read_id(item.get("id")) for item in peers
- if item.get("in_use", True) is True
- and protocol.read_id(item.get("id")) not in (None, peer)]
- messages.append(protocol.paired_msg(others[: protocol.MAX_PEERS]))
- if entry.get("port") != 0 and "settings" in self._peer_caps().get(peer, ()):
- messages.append(protocol.settings_msg(self._same_state()))
+ others = [protocol.read_id(ident) for ident in peerlist.paired_ids(
+ peers, exclude=protocol.id_text(peer))]
+ messages.append(protocol.paired_msg(others))
+ if entry.get("port") != 0 and set(self._peer_caps().get(peer, ())) & {"settings", "layout"}:
+ messages.append(protocol.settings_msg(settings_sync.for_capabilities(
+ self._same_state(), self._peer_caps().get(peer, ()))))
return messages
def _driver_platform(self) -> str:
@@ -1096,7 +1613,7 @@ class WindowsApplication(QWidget):
"platform": OWN_PLATFORM,
"app": VERSION[:32] if VERSION.isascii() and VERSION.isprintable() else "dev",
# A swipe has no shortcut every Linux desktop shares, so Linux does not offer gestures.
- "caps": [cap for cap in ("clipboard", "clipboard_image", "gestures", "media_keys", "text", "settings", "design_sync")
+ "caps": [cap for cap in ("clipboard", "clipboard_image", "gestures", "media_keys", "text", "settings", "design_sync", "layout", "displays", "ping_rtt")
if not (cap == "gestures" and OWN_PLATFORM == "linux")],
"port": self._settings_port,
}
@@ -1108,13 +1625,22 @@ class WindowsApplication(QWidget):
return []
def _set_same(self, on: bool) -> None:
- """Turning it on carries this PC's Crossing and Design across; off, each end keeps what it
+ """Turning it on carries this PC's Crossing and Design across, each value under its own
+ stamp, so the latest choice of each wins wherever it was made; off, each end keeps what it
has. Either way the Mac follows, now if a link is up, else when one next comes up."""
if self._config is None:
return
- self._config.same_on_both = bool(on)
- self._config.same_set_at = settings_sync.next_stamp(self._config.same_set_at, time.time())
- self._config.same_by = self._config.machine_id
+ config = self._config
+ # Each value keeps the stamp it held, never the new one: turning it on or off changes no value.
+ held = settings_sync.held_stamps(config.same_stamps, config.same_set_at, config.same_by)
+ config.same_stamps = settings_sync.stored_stamps(held)
+ if on and not config.same_groups:
+ config.same_groups = list(settings_sync.ALL_GROUPS)
+ if not on:
+ config.same_groups = []
+ config.same_on_both = bool(on)
+ config.same_set_at = settings_sync.next_stamp(config.same_set_at, time.time())
+ config.same_by = config.machine_id
self._persist()
self._send_same()
if not on:
@@ -1127,27 +1653,91 @@ class WindowsApplication(QWidget):
that takes it, which stops the first time it meets a copy it already holds."""
if self._config is None or any(entry.get("id") == peer and entry.get("port") == 0 for entry in self.book.peers()):
return
- was_on = self._config.same_on_both
+ settings = app_config.load_settings(self.config_path)
+ config = self._config
+ taken = settings_sync.arrived(data, config.same_set_at, TRIGGER_KEYS, by_here=config.same_by,
+ current_groups=config.same_groups)
+ policy_groups = settings_sync.arrival_groups(data, config.same_groups) if taken is not None else config.same_groups
+ policy_on = taken[0] if taken is not None else config.same_on_both
+ current_names = settings_sync.names_from_settings(settings)
+ updates, own_name = settings_sync.names_arrived(
+ data, current_names, self._config.machine_id,
+ current_groups=config.same_groups, policy_groups=policy_groups if policy_on else (),
+ )
+ names_changed = settings_sync.apply_names(settings, updates)
+ name_snapshot = None
+ if names_changed:
+ labels_changed = any(current_names.get(ident, {}).get("label", "") != entry["label"]
+ for ident, entry in updates.items())
+ name_snapshot = settings_sync.same_snapshot(
+ self._config.same_groups, settings_sync.pc_values(self._config), value_groups=(), names=current_names,
+ ) if labels_changed else None
+ if name_snapshot is not None:
+ settings["same_before_sync"] = name_snapshot
+ app_config.write_settings(self.config_path, settings)
+ if own_name is not None:
+ self._config = replace(self._config, name=own_name)
+ self.own_name_label.setText(own_name or platform.node())
+ self._refresh_peers()
+ source_id = protocol.read_id(peer)
+ if source_id is not None and "layout" in self._peer_caps().get(source_id, ()):
+ layout_state = settings_sync.read_layout_state(data)
+ if layout_state is not None:
+ with app_config.SETTINGS_LOCK:
+ outcome = crossing_state.receive_picture(
+ app_config.load_settings(self.config_path), layout_state, source=peer,
+ own_displays=self._own_displays(), **self._crossing_event_args())
+ self._carry_crossing(outcome, source=peer, arrived=data)
+ was_design_on = settings_sync.group_on(self._config, "design")
state = settings_sync.read_design_state(data, TRIGGER_KEYS)
if state is not None:
held = self._design_states.get(peer)
if held is None or settings_sync.design_arrived(state, held["set_at"], held["by"]):
self._design_states[peer] = state
source = protocol.read_id(peer)
- taken = settings_sync.arrived(
- data, self._config.same_set_at, TRIGGER_KEYS, by_here=self._config.same_by
+ # Key by key (rc14, 10-10-2026): a value is taken only when its own stamp is newer than the
+ # one held here, and the whole state, newer or not, decides only on, off and the groups.
+ merged = settings_sync.merge(
+ data, self._config.same_stamps, self._config.same_set_at, TRIGGER_KEYS, by_here=self._config.same_by,
+ on_here=self._config.same_on_both, current_groups=self._config.same_groups,
)
- if taken is not None:
- on, set_at, values = taken
+ policy = merged["policy"] if merged is not None else None
+ values, taken = {}, False
+ if merged is not None and merged["values"]:
+ values, conflict = ways.shared_trigger_values({"peers": self.book.peers()}, merged["values"])
+ if conflict is not None:
+ self._show_trigger_conflict(conflict)
+ # A value kept here over a clash is not taken: counted, every copy of the message would be
+ # taken again and sent on, round three machines for ever.
+ taken = any(values.get(key) == value for key, value in merged["values"].items())
+ if merged is not None and (policy is not None or taken):
+ old_groups = settings_sync.normalise_groups(self._config.same_groups)
+ before_values = settings_sync.pc_values(self._config)
+ snapshot = settings_sync.snapshot_for_arrival(
+ data, self._config.same_set_at, TRIGGER_KEYS, self._config.same_by,
+ old_groups, before_values, applied_values=values, merged=merged,
+ )
+ if snapshot is not None:
+ if name_snapshot is not None:
+ snapshot["names"] = name_snapshot["names"]
+ snapshot.pop("selection_only", None)
+ settings = app_config.load_settings(self.config_path)
+ settings["same_before_sync"] = snapshot
+ app_config.write_settings(self.config_path, settings)
config = replace(self._config, crossing_methods=list(self._config.crossing_methods),
crossing_edge_parts=list(self._config.crossing_edge_parts))
- config.same_on_both = on
- config.same_set_at = set_at
- config.same_by = data.get("by", "") if isinstance(data.get("by"), str) else ""
- if on:
- values, conflict = ways.shared_trigger_values({"peers": self.book.peers()}, values)
- if conflict is not None:
- self._show_trigger_conflict(conflict)
+ # Every key's stamp is fixed before the whole state's moves; a value taken brings its own,
+ # unless the local trigger was kept over it.
+ held = settings_sync.held_stamps(config.same_stamps, config.same_set_at, config.same_by)
+ held.update({key: stamp for key, stamp in merged["stamps"].items()
+ if key in values and values[key] == merged["values"][key]})
+ config.same_stamps = settings_sync.stored_stamps(held)
+ if policy is not None:
+ config.same_groups = list(merged["groups"])
+ config.same_on_both = merged["on"]
+ config.same_set_at = policy[1]
+ config.same_by = data.get("by", "") if isinstance(data.get("by"), str) else ""
+ if values:
design_stamp = settings_sync.design_change_stamp(
settings_sync.pc_values(config), values, config.design_set_at,
state, config.machine_id,
@@ -1166,7 +1756,7 @@ class WindowsApplication(QWidget):
self._design_seen = self._design_fields()
if not self._persist():
return
- LOGGER.info("Settings from a peer applied (same on all machines %s)", "on" if on else "off")
+ LOGGER.info("Settings from a peer applied (same on all machines %s)", "on" if config.same_on_both else "off")
self.sender.update_config(config)
self._configure_trigger(config)
self._reflect_config(config)
@@ -1174,7 +1764,12 @@ class WindowsApplication(QWidget):
forwarded = dict(data)
forwarded["design_sync"] = self._same_state()["design_sync"]
self._send_same(source=source, data=forwarded)
- if taken is not None and was_on and not on:
+ elif names_changed:
+ self._send_same(source=source, data=data)
+ if merged is not None and merged["answer"]:
+ # This PC holds a value newer than the sender's: its own state is how the sender learns it.
+ self._send_same()
+ if policy is not None and was_design_on and not settings_sync.group_on(self._config, "design"):
self._apply_followed_design(force=True)
elif state is not None:
self._apply_followed_design()
@@ -1186,18 +1781,33 @@ class WindowsApplication(QWidget):
self.logon_switch = widgets.Switch("Start Beamer when you sign in")
self.logon_switch.setFont(theme.font(theme.TYPE["body"]))
exe = autostart_win.installed_exe()
+ account_known = True
try:
- self.logon_switch.setChecked(exe is not None and autostart_win.is_enabled())
+ can_start = exe is not None and autostart_win.can_run_for_current_user()
+ except OSError:
+ LOGGER.exception("Could not identify the signed-in account")
+ can_start = False
+ account_known = False
+ enabled = False
+ try:
+ enabled = exe is not None and autostart_win.is_enabled()
except OSError:
LOGGER.exception("Could not read the logon task")
- self.logon_switch.setEnabled(exe is not None)
+ self.logon_switch.setChecked(enabled)
+ self.logon_switch.setEnabled(exe is not None and (can_start or enabled))
self.logon_switch.toggled.connect(self._set_start_at_logon)
module.body.addWidget(self.logon_switch)
- self.logon_hint = widgets.label(
- "In the tray, with no window." if exe else "Only the installed app can start at sign-in.",
- "note",
- wrap=True,
- )
+ if exe and not account_known:
+ hint = "Windows could not identify the signed-in account, so start at sign-in is unavailable."
+ elif exe and not can_start:
+ hint = "Start at sign-in needs the same administrator account that runs Beamer."
+ elif enabled:
+ hint = "Starts elevated at sign-in without a UAC prompt, so Beamer can send input to administrator apps."
+ elif exe:
+ hint = "When enabled, a logon task starts Beamer elevated without a UAC prompt, so it can send input to administrator apps."
+ else:
+ hint = "Only the installed app can start at sign-in."
+ self.logon_hint = widgets.label(hint, "note", wrap=True)
module.body.addWidget(self.logon_hint)
return module
@@ -1219,7 +1829,25 @@ class WindowsApplication(QWidget):
# -- Crossing -----------------------------------------------------------------------------
def _crossing_page(self, layout, current: Config) -> None:
+ self.crossing_document = layout.parentWidget().parentWidget()
+ intro = widgets.label("Drag a machine on the map to where it sits. The ledger says how each one is reached; click a row to pick it on the map.", "note", wrap=True)
+ intro.setMaximumWidth(560)
+ # A VBox measures capped labels at the full column width, losing a wrapped line.
+ intro_line = QHBoxLayout()
+ intro_line.setContentsMargins(0, 0, 0, 0)
+ intro_line.addWidget(intro, 1)
+ intro_line.addStretch()
+ layout.addLayout(intro_line)
layout.addWidget(self._ways_module(current))
+ self.pointer_module = self._pointer_module(current)
+ layout.addWidget(self.pointer_module)
+ desktop = linux_desktop.desktop() if sys.platform.startswith("linux") else ""
+ note = ("On KDE Plasma, the tray uses the system tray. KWin virtual desktop shortcuts are separate "
+ "from Beamer's shortcut; check their bindings in System Settings → Shortcuts."
+ if desktop == "kde" else "On GNOME, the tray needs the AppIndicator extension.")
+ self.linux_tray_note = widgets.label(note, "note", wrap=True)
+ self.linux_tray_note.setVisible(desktop in ("kde", "gnome"))
+ layout.addWidget(self.linux_tray_note)
self.resistance_module = self._resistance_module(current)
layout.addWidget(self.resistance_module)
self.shortcut_module = self._shortcut_module(current)
@@ -1254,144 +1882,77 @@ class WindowsApplication(QWidget):
return row
def _ways_module(self, current: Config) -> QWidget:
- module = widgets.Module("Ways from this screen")
+ from crossing_ledger import CrossingLedger
+ module = widgets.Module("Machines", heading=True)
self.ways_module = module
- # Which machine everything below shows and edits; only there with more than one paired.
- holder = QWidget()
- holder.setProperty("vernier", "plain")
- self._machine_slot = QVBoxLayout(holder)
- self._machine_slot.setContentsMargins(0, 0, 0, 0)
- self.machine_choice = widgets.Choice((), 1, "")
- self._machine_slot.addWidget(self.machine_choice.view)
- self.machine_row = self._row(widgets.label("Machine", "key"), holder)
- # A wider step under the choice than between the rows it governs, so it reads as their heading.
- self.machine_row.layout().setContentsMargins(0, 0, 0, 8)
- self.machine_row.setVisible(False)
- module.body.addWidget(self.machine_row)
- self.ways_summary = widgets.label("", "note", wrap=True)
- module.body.addWidget(self.ways_summary)
- self.arrangement_diagram = ArrangementDiagram()
- # The diagram beside the ways it draws, once the column holds both; stacked below that.
- ways_list = QWidget()
- ways_list.setProperty("vernier", "plain")
- ways_column = QVBoxLayout(ways_list)
- ways_column.setContentsMargins(0, 0, 0, 0)
- ways_column.setSpacing(8)
- self.ways_pair = widgets.SideBySide(self.arrangement_diagram, ways_list)
- module.body.addWidget(self.ways_pair)
- self.way_boxes: dict = {}
- for value, text, detail in pages_win.WAY_ROWS:
- box = QCheckBox(text)
- box.toggled.connect(lambda on, v=value: self._ways_changed(v, on))
- self.way_boxes[value] = box
- if not detail:
- ways_column.addWidget(box)
- continue
- box.setAccessibleDescription(detail)
- ways_column.addWidget(box)
- ways_column.addWidget(widgets.label(detail, "small", wrap=True))
- ways_column.addStretch(1)
- # A way refused because it would share a stretch of this screen with another machine's.
- self.clash_note = widgets.label("", "note-amber", wrap=True)
- self.clash_note.setVisible(False)
- module.body.addWidget(self.clash_note)
- # What stops a way working, under the ways it is about: a side another machine's edge holds,
- # a machine that may drive this PC and is not paired with the chosen one, and the chosen one
- # saying none of its own ways leads back here.
- self.blocked_note = widgets.label("", "note-amber", wrap=True)
- self.missing_note = widgets.label("", "note", wrap=True)
- self.no_way_back_note = widgets.label("", "note", wrap=True)
- for note in (self.blocked_note, self.missing_note, self.no_way_back_note):
- note.setVisible(False)
- module.body.addWidget(note)
-
- self.edge_choice = widgets.Choice(EDGE_CHOICES, columns=4, current="", on_change=self._set_arrangement)
- self.edge_heading = widgets.label("", "key")
- self.edge_note = widgets.label("", "note", wrap=True)
- self.edge_unlearned = widgets.label(pages_win.not_learned_edge(), "note", wrap=True)
- self.crossing_rows = {
- "edge": self._row(self.edge_heading, self.edge_note, self.edge_choice.view, self.edge_unlearned),
- }
- # A group within Ways, never a panel of its own: a panel inside a panel reads as a second page.
- self.share_module = QWidget()
- self.share_module.body = QVBoxLayout(self.share_module)
- self.share_module.body.setContentsMargins(0, 0, 0, 0)
- self.share_module.body.setSpacing(8)
- self.share_module.eyebrow = widgets.Eyebrow("Share the edge")
- self.share_module.body.addWidget(self.share_module.eyebrow)
- self.share_sentence = widgets.label("", "note", wrap=True)
- self.share_module.body.addWidget(self.share_sentence)
- share_tiles = QHBoxLayout()
- share_tiles.setSpacing(4)
- self.share_tiles = {}
- for part in return_edge.PARTS:
- tile = widgets.ElidingButton()
- tile.setProperty("vernier", "choice")
- tile.setCheckable(True)
- tile.setMinimumHeight(48)
- tile.clicked.connect(lambda _on=False, part=part: self._share_part(part))
- share_tiles.addWidget(tile, 1)
- self.share_tiles[part] = tile
- self.share_module.body.addLayout(share_tiles)
- self.share_button = QPushButton("Share the edge")
- self.share_button.setProperty("vernier", "primary")
- self.share_button.clicked.connect(self._share_side)
- self.share_module.body.addWidget(self.share_button)
- self.share_module.setVisible(False)
-
- self.parts_choice = widgets.Choice([(part, name) for part, name in
- zip(return_edge.PARTS, ("Top", "Middle", "Bottom"))], 3, "", exclusive=False)
- self.part_buttons = self.parts_choice._buttons
- for part, button in self.part_buttons.items():
- button.clicked.connect(lambda on, p=part: self._set_part(p, on))
- self.parts_note = widgets.label("", "note", wrap=True)
- self.crossing_rows["parts"] = self._row(widgets.label("Parts", "key"), self.parts_choice.view, self.parts_note)
-
- self.corner_choice = widgets.Choice(CORNER_CHOICES, columns=2, current="", on_change=self._set_corner)
- self.corner_choice.set_names("Corner")
- self.crossing_rows["corner"] = self._row(widgets.label("Corner", "key"), self.corner_choice.view)
+ self.atlas_canvas = AtlasCanvas(
+ on_drop=self._layout_dropped, on_rename=self._rename_canvas_peer,
+ on_leave_out=self._canvas_left_out, on_cycle=self._set_shortcut_cycle,
+ on_select=self._choose_machine, on_third=self._canvas_third)
+ self.atlas_canvas.on_hint = self.atlas_canvas.announce
+ self.atlas_canvas.setMinimumHeight(260)
+ self.atlas_canvas.setMaximumHeight(260)
+ self.atlas_canvas.ledger_height = True
+ module.body.addWidget(self.atlas_canvas)
+ self.atlas_canvas_hint = widgets.label(
+ "Alt-click a display to split or group · drag to move · click a third of a lit edge to leave it out",
+ "note", wrap=True)
+ module.body.addWidget(self.atlas_canvas_hint)
+ if sys.platform.startswith("linux"):
+ module.body.addWidget(widgets.label("Seam crossings need X11 on Linux.", "note", wrap=True))
+ legend = QWidget()
+ legend.setProperty("vernier", "plain")
+ line = QHBoxLayout(legend)
+ line.setContentsMargins(0, 0, 0, 0)
+ line.setSpacing(6)
+ for tone, text in (("signal", "Crosses"), ("ink_3", "Offline, ways kept")):
+ dot = QLabel()
+ dot.setFixedSize(6, 6)
+ dot.setStyleSheet(f"background: {theme.colour(tone)}; border-radius: 3px")
+ line.addWidget(dot)
+ line.addWidget(widgets.label(text, "note"))
+ line.addSpacing(12)
+ line.addStretch()
+ module.body.addWidget(legend)
+ self.crossing_ledger = CrossingLedger(self)
+ module.body.addWidget(self.crossing_ledger)
+ module.body.addWidget(widgets.label(
+ "Three lit segments are the whole edge; click one to leave it out. "
+ "A corner is a diagonal push, shown as a square on the map.", "note", wrap=True))
+ return module
+ def _pointer_module(self, current: Config) -> QWidget:
+ module = widgets.Module("This machine's pointer", heading=True)
self.dragging_switch = widgets.Switch("Don't cross while dragging with this PC's pointer")
- self.dragging_switch.setToolTip("Applies when this physical pointer pushes through this screen's ways; visiting pointers are not protected by this switch.")
+ note = ("Applies when this physical pointer pushes through this screen's ways; "
+ "visiting pointers are not protected by this switch.")
+ self.dragging_switch.setToolTip(note)
self.dragging_switch.setFont(theme.font(theme.TYPE["body"]))
self.dragging_switch.setChecked(current.block_while_dragging)
self.dragging_switch.toggled.connect(self._set_block_while_dragging)
- self.crossing_rows["dragging"] = self._row(self.dragging_switch)
- for key in ("edge", "parts", "corner", "dragging"):
- module.body.addWidget(self.crossing_rows[key])
- if key == "edge":
- module.body.addWidget(self.share_module)
-
- self.jump_heading = widgets.Eyebrow("Jump to this machine")
- module.body.addWidget(self.jump_heading)
- jump_row = QVBoxLayout()
- jump_row.setSpacing(8)
- self.jump_recorder = widgets.JumpKeyRecorder(self._record_jump_key, self._jump_arming)
- jump_row.addWidget(self.jump_recorder, 1)
- self.jump_clear = widgets.ActionButton("Clear")
- self.jump_clear.setProperty("vernier", "plain")
- self.jump_clear.setAccessibleName("Clear jump key")
- self.jump_clear.clicked.connect(lambda: self._record_jump_key(""))
- jump_row.addWidget(self.jump_clear, 0, Qt.AlignmentFlag.AlignLeft)
- module.body.addLayout(jump_row)
- self.jump_note = widgets.label("", "note", wrap=True)
- module.body.addWidget(self.jump_note)
-
+ module.body.addWidget(self.dragging_switch)
+ module.body.addWidget(widgets.label(note, "note", wrap=True))
return module
# -- the machine the Crossing page shows --
def _crossing_settings(self) -> dict:
- """The peers and zones as last read, in the shape core.ways reads them."""
- own = self._config.machine_id if self._config is not None else ""
+ config = self._config or default_config()
desktops = peerlist.desktops(self._peer_entries)
ids = {entry.get("id") for entry in desktops}
- return {"machine_id": own, "peers": desktops,
- "zones": [zone for zone in self._zone_entries if zone.get("peer") in ids]}
+ return {"machine_id": config.machine_id, "peers": desktops,
+ "zones": [zone for zone in self._zone_entries if zone.get("peer") in ids],
+ "layout": config.layout, "layout_set_at": config.layout_set_at, "layout_by": config.layout_by}
+ @_crossing_refresh
def _read_crossing(self) -> None:
try:
self._peer_entries, self._zone_entries = self.book.peers(), self.book.zones()
+ if self._config is not None:
+ saved = app_config.load_settings(self.config_path)
+ self._config.layout = saved.get("layout", {})
+ self._config.layout_set_at = saved.get("layout_set_at", 0)
+ self._config.layout_by = saved.get("layout_by", "")
except (ConfigError, OSError):
LOGGER.exception("The peers could not be read")
@@ -1399,7 +1960,7 @@ class WindowsApplication(QWidget):
return [(ident, self._shown(label)) for ident, label in pages_win.crossing_machines(self._peer_entries)]
def _chosen_machine(self) -> Optional[str]:
- ids = [ident for ident, _label in self._crossing_machines()]
+ ids = [entry.get("id") for entry in peerlist.desktops(self._peer_entries)]
return self._chosen if self._chosen in ids else (ids[0] if ids else None)
def _ways_in(self) -> set:
@@ -1411,109 +1972,220 @@ class WindowsApplication(QWidget):
found.update(ways.ways(settings, ident)["methods"])
return found
- def _share_part(self, part: str) -> None:
- """Move an offered third to the next machine without saving until Share is pressed."""
- recipients = self._share_recipients
- current = recipients.index(self._share_thirds[part])
- self._share_thirds[part] = recipients[(current + 1) % len(recipients)]
+ @_crossing_refresh
+ def _choose_machine(self, peer: str) -> None:
+ self._chosen = peer
self._reflect_ways()
+ self._reflect_look()
+
+ @_crossing_refresh
+ def _layout_dropped(self, layout: dict, moved: str) -> bool:
+ if not self._config or moved == self._config.machine_id or moved not in layout:
+ self._reflect_ways()
+ return False
+ with app_config.SETTINGS_LOCK:
+ settings = app_config.load_settings(self.config_path)
+ outcome = crossing_state.drop(settings, layout, moved, snap_radius=12 / max(self.atlas_canvas._scale, 0.001),
+ **self._crossing_event_args())
+ if not outcome["accepted"]:
+ self._reflect_ways()
+ self.atlas_canvas.announce("That position cannot connect this machine.")
+ return False
+ self._carry_crossing(outcome)
+ return True
+
+ def _crossing_event_args(self) -> dict:
+ return dict(platform="pc", capable=self._layout_capable(), live=self._live, gone=self._gone, now=time.time())
+
+ def _layout_capable(self) -> set:
+ held = {entry.get("id") for entry in self._peer_entries
+ if "layout" in entry.get("caps", ()) or "caps" not in entry}
+ known = self._design_peer_caps()
+ return {self._config.machine_id} | (held - set(known)) | {
+ ident for ident, caps in known.items() if "layout" in caps}
+
+ def _own_displays(self) -> dict:
+ return copy.deepcopy(self._own_display_map)
+
+ def _refresh_own_displays(self) -> None:
+ if hasattr(self.sender, "_desktop_module") and platform.system() in ("Windows", "Linux"):
+ desktop = self.sender._desktop_module()
+ refresh = getattr(desktop, "refresh_qt_screens", None)
+ if callable(refresh):
+ refresh()
+ self._own_display_map = desktop.display_map()
+
+ def _screen_added(self, screen) -> None:
+ screen.geometryChanged.connect(self._displays_changed)
+ self._displays_changed()
+
+ def _carry_crossing(self, outcome, *, source=None, arrived=None, redraw=True) -> None:
+ if outcome["changed"]:
+ saved = outcome["settings"]
+ app_config.write_settings(self.config_path, saved)
+ self._config = replace(self._config, layout=saved.get("layout", {}),
+ layout_set_at=saved.get("layout_set_at", 0), layout_by=saved.get("layout_by", ""))
+ self._peer_entries, self._zone_entries = saved["peers"], saved["zones"]
+ self.sender.update_config(self._config)
+ self.sender.refresh()
+ self.server.peers_changed()
+ self.server.rearm()
+ for peer in outcome["tell"]:
+ self._tell(peer)
+ if outcome["send_picture"]:
+ self._send_same(layout_only=True)
+ if outcome["forward_picture"] and arrived is not None:
+ self._send_same(source=protocol.read_id(source), data=arrived, layout_only=True)
+ if redraw and outcome["changed"]:
+ self._reflect_ways()
+ self._reflect_look()
+
+ def _displays_changed(self) -> None:
+ self._refresh_own_displays()
+ self._reconcile_displays()
- def _share_side(self) -> None:
- """Save the offered split, rebuild the live zones and tell every affected machine."""
- side, thirds = self._share_identity[0], dict(self._share_thirds)
+ def _reconcile_displays(self) -> None:
+ if self._config is None:
+ return
+ settings = self._window_settings()
+ displays = self._own_displays()
+ capable = self._layout_capable()
+ seen = (getattr(self, "_window_settings_version", None), repr(displays), frozenset(capable))
+ if seen == getattr(self, "_displays_seen", None):
+ return
+ with app_config.SETTINGS_LOCK:
+ # Recheck under the write lock: a link may have saved since the first stat.
+ settings = self._window_settings()
+ outcome = crossing_state.displays_changed(
+ settings, platform="pc", own_displays=displays,
+ now=time.time(), capable=capable)
+ self._carry_crossing(outcome)
+ self._displays_seen = seen
+
+
+
+ def _rename_canvas_peer(self, peer: str, text: str) -> None:
+ entry = next((item for item in self._peer_entries if item.get("id") == peer), None)
+ if entry:
+ self._rename_peer(entry.get("token"), text)
+
+
+
+
+ @_crossing_refresh
+ def _canvas_left_out(self, peer: str, left_out: bool) -> None:
+ entry = next((item for item in self._peer_entries if item.get("id") == peer), None)
+ if entry:
+ self._set_peer_left_out(entry.get("token"), left_out)
+
+ def _open_atlas_pairing(self) -> None:
+ self._select_page("overview")
+ if not self._pairing_open:
+ self._toggle_pairing_sheet()
+ self.sheet.address.setFocus()
+
+ def _open_atlas_forget(self, peer: str) -> None:
+ entry = next((item for item in self._peer_entries if item.get("id") == peer), None)
+ if entry is not None:
+ self._select_page("overview")
+ self._refresh_peers()
+ row = self.machines.rows.get(entry.get("token"))
+ if row is not None:
+ row._ask(True)
+
+ @_crossing_refresh
+ def _set_shortcut_goes_to(self, mode: str) -> None:
+ if not self._config or mode not in ("last", "next", "ticked"):
+ return
+ self._config.shortcut_goes_to = mode
+ self._persist()
+ self._refresh_peers()
+ self._reflect_ways()
+
+ @_crossing_refresh
+ def _set_shortcut_cycle(self, peer: str, enabled: bool) -> None:
try:
- changed = app_config.share_side(self.config_path, side, thirds)
- except (ConfigError, OSError, ValueError):
- LOGGER.exception("The shared side could not be saved")
+ with app_config.SETTINGS_LOCK:
+ settings = app_config.load_settings(self.config_path)
+ entry = next((item for item in settings["peers"] if item.get("id") == peer), None)
+ if entry is None:
+ return
+ entry["shortcut_cycle"] = bool(enabled)
+ app_config.write_settings(self.config_path, settings)
+ except (ConfigError, OSError):
+ LOGGER.exception("Shortcut cycle setting could not be saved")
return
self._read_crossing()
- for peer in changed:
- self._tell(peer)
- self.server.peers_changed()
self.sender.refresh()
+ self._refresh_peers()
self._reflect_ways()
- self._reflect_look()
- def _choose_machine(self, peer: str) -> None:
- self._chosen = peer
- self._show_clash("")
- self._reflect_ways()
- self._reflect_look()
- def _show_clash(self, sentence: str) -> None:
- self.clash_note.setText(sentence)
- motion.set_shown(self.clash_note, bool(sentence))
-
- def _rebuild_machine_choice(self, machines: list) -> None:
- """The machine choice again when the paired machines or their names change."""
- items = tuple(machines)
- if items == self._machine_items:
- return
- self._machine_items = items
- old = self.machine_choice.view
- # Three names fit a row at the narrowest window; four or more go two to a row.
- columns = len(items) if len(items) <= 3 else 2
- self.machine_choice = widgets.Choice(items, max(1, columns), "", on_change=self._choose_machine)
- self.machine_choice.set_names("Machine")
- self._machine_slot.replaceWidget(old, self.machine_choice.view)
- old.hide()
- old.deleteLater()
-
- def _write_ways(self, **changes) -> bool:
- """One change to the chosen machine's ways. Every machine whose way back changed is told,
- along with the chosen machine when its side or way changed. An overlapping edge choice shows
- the share offer; other clashes are refused, said, and every control goes back."""
- peer = self._chosen_machine()
+ @_crossing_refresh
+ def _write_ways(self, peer=None, **changes) -> bool:
+ peer = peer or self._chosen_machine()
if self._config is None or peer is None:
- self._reflect_ways()
return False
- self._read_crossing()
- before = ways.way_back_state(self._crossing_settings())
- had_way = ways.has_way(self._crossing_settings(), peer)
+ with app_config.SETTINGS_LOCK:
+ settings = app_config.load_settings(self.config_path)
+ entry = ways._entry(settings, peer)
+ if entry is None or entry.get("left_out") is True:
+ return False
+ if "methods" in changes:
+ methods = changes.pop("methods")
+ changes.update(edge=bool(set(methods) & {"edge", "part"}), corner="corner" in methods)
+ if "edge" in methods:
+ changes["thirds"] = list(ways.PARTS)
+ if "parts" in changes:
+ changes["thirds"] = changes.pop("parts")
+ if isinstance(changes.get("corner"), str):
+ changes["corner_at"] = changes.pop("corner")
+ changes.pop("side", None)
+ try:
+ outcome = crossing_state.edit_ways(settings, peer, **changes, **self._crossing_event_args())
+ self._carry_crossing(outcome)
+ except (ConfigError, OSError):
+ LOGGER.exception("A machine's ways could not be saved")
+ self._reflect_ways()
+ return False
+ return True
+
+ def _ledger_edge(self, peer):
held = ways.ways(self._crossing_settings(), peer)
- held.update(changes)
- offer = ways.share_offer(self._crossing_settings(), peer, self._live)
- occupied = {part for part, owner in offer["thirds"].items() if owner in offer["holders"]} if offer else set()
- if offer and ("edge" in held["methods"] or
- "part" in held["methods"] and occupied.intersection(held["parts"])):
- self._show_clash("")
- self._reflect_ways()
- self.share_button.setFocus(Qt.FocusReason.OtherFocusReason)
- return False
+ methods, parts = ways.toggle_edge(held["methods"], held["parts"])
+ self._write_ways(peer=peer, methods=methods, parts=parts)
+
+ def _ledger_third(self, peer, third):
+ held = ways.ways(self._crossing_settings(), peer)
+ if held["side"] not in ways.EDGES:
+ return
+ methods, parts = ways.toggle_third(held["methods"], held["parts"], third)
+ self._write_ways(peer=peer, methods=methods, parts=parts)
+
+ def _ledger_corner(self, peer, corner):
+ settings = self._crossing_settings()
+ if ways.corner_holder(settings, corner, exclude=peer):
+ return
+ held = ways.ways(settings, peer)
+ on = not ("corner" in held["methods"] and held["corner"] == corner)
+ self._write_ways(peer=peer, corner=on, corner_at=corner)
+
+ def _ledger_jump(self, peer, value):
+ if self._config is None:
+ return
try:
- moved = app_config.set_ways(self.config_path, peer, side=changes.get("side"), methods=held["methods"],
- parts=held["parts"], corner=held["corner"], live=self._live)
- except app_config.ClashError as exc:
- self._show_clash(self._shown(str(exc)))
- self._reflect_ways()
- return False
- except (ConfigError, OSError):
- LOGGER.exception("A machine's ways could not be saved")
- self._reflect_ways()
- return False
- self._show_clash("")
+ app_config.set_jump_key(self.config_path, peer, value, self._config.trigger_key)
+ except ConfigError as exc:
+ self.atlas_canvas.announce(self._shown(str(exc)))
self._read_crossing()
- settings = self._crossing_settings()
- changed_peers = [target for target, state in ways.way_back_state(settings).items()
- if before.get(target) != state]
- if moved or ways.has_way(settings, peer) != had_way:
- # One border, walked both ways: the machine on the other side of it moves its own side to match.
- changed_peers.append(peer)
- for target in dict.fromkeys(changed_peers):
- self._tell(target)
- # A change on the Crossing page reaches a peer's pointer while it is here, not at its next crossing.
- self.server.peers_changed()
self.sender.refresh()
self._reflect_ways()
- # The Design page's preview opens where the pointer crosses and says when a place is not a way in.
- self._reflect_look()
- return True
+ @_crossing_refresh
def _ways_changed(self, way: str, on: bool) -> None:
if self._config is None:
return
if way == "shortcut":
- # The shortcut is this PC's own, whichever machine the page shows.
self._config.crossing_methods = pages_win.toggle_way(self._config.crossing_methods, way, on)
self._persist()
self.sender.update_config(self._config)
@@ -1521,160 +2193,106 @@ class WindowsApplication(QWidget):
self._reflect_look()
return
held = ways.ways(self._crossing_settings(), self._chosen_machine())["methods"]
- self._write_ways(methods=[kind for kind in pages_win.toggle_way(held, way, on) if kind != "shortcut"])
+ methods = pages_win.toggle_way(held, way, on)
+ if way == "edge" and not on:
+ methods = [kind for kind in methods if kind != "part"]
+ self._write_ways(methods=[kind for kind in methods if kind != "shortcut"])
+
+ @staticmethod
+ def _crossing_text(widget, text):
+ if widget.text() != text:
+ widget.setText(text)
- def _set_part(self, part: str, on: bool) -> None:
- held = ways.ways(self._crossing_settings(), self._chosen_machine())["parts"]
- self._write_ways(parts=pages_win.toggle_part(held, part, on))
+ @_crossing_refresh
+ def _third_changed(self, third: str) -> None:
+ held = ways.ways(self._crossing_settings(), self._chosen_machine())
+ methods, parts = ways.toggle_third(held["methods"], held["parts"], third)
+ self._write_ways(methods=methods, parts=parts)
+ @_crossing_refresh
+ def _canvas_third(self, peer: str, third: str) -> None:
+ self._ledger_third(peer, third)
+
+ @_crossing_refresh
def _reflect_ways(self) -> None:
- """The machine choice, the ways' boxes, the parts' chips and which rows show, for the chosen
- machine: a row a chosen way does not use is hidden, not dimmed, and comes back the moment one
- does."""
+ """Refresh the map and existing ledger cells without replacing the page."""
config = self._config or default_config()
settings = self._crossing_settings()
- machines = self._crossing_machines()
chosen = self._chosen_machine()
- several = len(machines) > 1
- self._rebuild_machine_choice(machines if several else [])
- self.machine_choice.set_value(chosen)
- motion.set_shown(self.machine_row, several)
- name = dict(machines).get(chosen) if several else None
- name = name or "the other machine"
- self.ways_module.eyebrow.setText(f"Ways from this screen to {name}")
+ entries = peerlist.desktops(self._peer_entries)
+ labels = {config.machine_id: "This PC"}
+ labels.update({entry["id"]: self._shown(peerlist.label_for(entries, peer_id=entry["id"])
+ or f"Machine · {entry['id'][-6:]}")
+ for entry in entries})
+ all_layout = ways.derive_layout({**settings, "layout": config.layout}, gap=0)
+ labels.update({peer: tile.get("name") or f"Machine · {peer[-6:]}"
+ for peer, tile in all_layout.items() if peer not in labels})
+ left_out = {entry["id"] for entry in entries if entry.get("left_out")}
+ dormant = {entry["id"] for entry in entries if peerlist.dormant_reason(entry) is not None or self._gone(entry["id"])}
+ in_use = {entry["id"]: entry.get("in_use", True) for entry in entries}
+ shelved = left_out | dormant | {peer for peer, enabled in in_use.items() if not enabled}
+ layout = {peer: tile for peer, tile in all_layout.items() if peer not in shelved}
+ known_caps = self._design_peer_caps()
+ capable = {peer for peer, caps in known_caps.items() if "layout" in caps}
+ active = {**settings, "peers": [entry for entry in entries if entry["id"] not in shelved]}
+ result = ways.compile_layout(active, layout, capable=capable)
+ tile_states = result.get("tiles", {})
+ tile_states[config.machine_id] = {"state": "this", "detail": config.name or platform.node()}
+ legacy = {}
+ for entry in entries:
+ peer = entry["id"]
+ state = tile_states.setdefault(peer, {})
+ held = ways.ways(settings, peer)
+ picked = ways.picked_thirds(held["methods"], held["parts"])
+ touched = state.get("thirds")
+ own, tile = layout.get(config.machine_id), layout.get(peer)
+ contact = ways._rect_contact(own, tile) if own and tile else None
+ edge_on = bool(set(held["methods"]) & {"edge", "part"})
+ corner = held["corner"] if "corner" in held["methods"] and peer not in shelved else ""
+ state.update(methods=held["methods"], side=held["side"], corner=held["corner"],
+ thirds=picked, lit=[part for part in picked if touched is None or part in touched],
+ corner_way=corner, crosses=bool((edge_on and state.get("state") in ("edge", "part")) or corner),
+ edge_off=not edge_on and not corner and bool(contact and contact[0] != "corner"),
+ linked=self._live(peer))
+ if state["edge_off"]:
+ state["state"] = "gap"
+ platform_name = {"windows": "Windows", "macos": "macOS", "linux": "Linux"}.get(
+ entry.get("platform"), "Computer")
+ state["detail"] = f"{platform_name} · {'Linked' if state['linked'] else 'Offline'}"
+ version = entry.get("app", "")
+ if peer in known_caps and peer not in capable and version:
+ version = version if version.startswith("Beamer ") else f"Beamer {version}"
+ legacy[peer] = f"{version} · only sees which side"
+ state.update(legacy=True, legacy_label=legacy[peer])
+ self.atlas_canvas.set_tiles(layout, labels, tile_states, chosen, config.shortcut_goes_to,
+ {entry["id"]: entry.get("shortcut_cycle", True) for entry in entries},
+ capable, own_id=config.machine_id,
+ rename_values={entry["id"]: self._shown(entry.get("label") or entry.get("name") or "")
+ for entry in entries})
+ self.atlas_canvas.set_left_out(left_out, in_use, dormant)
+ key = TRIGGER_KEYS.get(config.trigger_key, config.trigger_key)
+ self.crossing_ledger.reflect(settings, all_layout, labels, chosen, self._live, key, legacy)
+ self.dragging_switch.setEnabled(bool(self._ways_in() & {"edge", "part", "corner"}))
+ self.pointer_module.setVisible(not platform_parts.WAYLAND)
+ self.resistance_module.setVisible(True)
+ self.shortcut_tile.blockSignals(True)
+ try:
+ self.shortcut_tile.setChecked("shortcut" in config.crossing_methods)
+ finally:
+ self.shortcut_tile.blockSignals(False)
+ self.shortcut_tile.set_detail(f"{key}, to where input last went")
+ self.shortcut_target_choice.set_value(config.shortcut_goes_to)
+ self._crossing_text(self.shortcut_target_note, pages_win.shortcut_destination_note(
+ config.shortcut_goes_to, config.trigger_style == "hold"))
held = ways.ways(settings, chosen)
- shortcut = "shortcut" in config.crossing_methods
- methods = held["methods"] + (["shortcut"] if shortcut else [])
- for value, box in self.way_boxes.items():
- if box.isChecked() != (value in methods):
- box.blockSignals(True)
- box.setChecked(value in methods)
- box.blockSignals(False)
- side = held["side"]
- self.edge_choice.set_value(side)
- self.edge_choice.set_names(f"Where {name} is")
- self.edge_heading.setText(f"Where {name} is")
- self.edge_note.setText(f"Changing a side updates {name}'s side too; it can turn overlapping ways off, with a notice.")
- self.edge_unlearned.setText(pages_win.not_learned_edge(name))
- self.corner_choice.set_value(held["corner"])
- self.corner_choice.view.setToolTip(f"This corner leads to {name} on its configured side.")
- edge = side or "right"
- names = pages_win.part_names(edge)
- for part, button in self.part_buttons.items():
- button.setText(names[part])
- button.setChecked(part in held["parts"])
- self.parts_choice.view.refresh_metrics()
- self.parts_note.setText(
- f"Crosses only along {pages_win.parts_phrase(edge, held['parts'])}; the rest of "
- "it is a wall. Choose any, but at least one."
- )
- # Resistance and the drag guard are this PC's own, there while any machine has a zone.
- own = {"dragging", "resistance"} & pages_win.crossing_rows(self._ways_in() | set(methods))
- shown = (pages_win.crossing_rows(methods) - {"dragging", "resistance"}) | own
- for key, row in self.crossing_rows.items():
- # Wayland shows no button held before the pointer meets the edge (wayland_crossing_note).
- motion.set_shown(row, key in shown and not (key == "dragging" and platform_parts.WAYLAND))
- motion.set_shown(self.resistance_module, "resistance" in shown)
- motion.set_shown(self.shortcut_module, "shortcut" in shown or bool(getattr(self, "_trigger_conflict", "")))
- key_name = TRIGGER_KEYS.get(config.trigger_key, config.trigger_key)
- summary = pages_win.ways_summary(methods, side, held["parts"], held["corner"], key_name, config.trigger_style,
- name, several)
- if summary != self.ways_summary.text():
- shot = motion.snapshot(self.ways_summary)
- self.ways_summary.setText(summary)
- motion.fade_from(self.ways_summary, shot)
- motion.set_shown(self.edge_unlearned, not side)
- offer = ways.share_offer(settings, chosen, self._live) if chosen else None
- identity = (offer["side"], tuple(offer["holders"]), tuple(offer["thirds"].items())) if offer else None
- if identity != getattr(self, "_share_identity", None):
- self._share_identity = identity
- self._share_thirds = dict(offer["thirds"]) if offer else {}
- self.share_module.eyebrow.setText(f"Share the {offer['side']} edge" if offer else "Share the edge")
- self.share_button.setText(f"Share the {offer['side']} edge" if offer else "Share the edge")
- self._share_recipients = [chosen, *offer["holders"]] if offer else []
- labels = dict(machines)
- if offer:
- holder_names = [labels.get(peer, "another machine") for peer in offer["holders"]]
- self.share_sentence.setText(pages_win.share_sentence(holder_names, offer["side"],
- labels.get(chosen, "this machine")))
- names = pages_win.part_names(offer["side"])
- for part, tile in self.share_tiles.items():
- owner = self._share_thirds[part]
- tile.setText(f"{names[part]}\n{labels.get(owner, 'another machine')}")
- tile.setAccessibleName(f"{names[part]} third: {labels.get(owner, 'another machine')}")
- tile.setChecked(owner == chosen)
- self.share_button.setEnabled(chosen in self._share_thirds.values())
- motion.set_shown(self.share_module, offer is not None)
- for note, sentence in (
- (self.blocked_note, (ways.blocked_sentence(settings, chosen, "this PC", self._live) if chosen and not offer else "")
- or (ways.gone_sentence(settings, chosen, "this PC", self._gone) if chosen else "")),
- (self.missing_note, ways.missing_sentence(settings, chosen, "this PC") if chosen else ""),
- (self.no_way_back_note, ways.no_way_back_sentence(settings, chosen) if chosen else "")):
- sentence = self._shown(sentence)
- if sentence != note.text():
- note.setText(sentence)
- motion.set_shown(note, bool(sentence))
- drawn = []
- for ident, label in machines or [("", "")]:
- found = ways.ways(settings, ident) if ident or machines else {"side": "", "methods": [], "parts": ["middle"],
- "corner": "top_left"}
- drawn.append(dict(found, key=ident, label=label, chosen=ident == chosen or not machines))
- self.arrangement_diagram.set_machines(drawn, key_name, config.trigger_style, shortcut)
- self.resistance_strip.set_edge(edge)
- self._reflect_jump_key()
- caption = f"Where {name} is"
- if self.edge_heading.fontMetrics().horizontalAdvance(caption) > 180:
- caption = "Where the other machine is"
- self.edge_heading.setText(caption)
- self.edge_heading.setAccessibleName(f"Where {name} is")
- self.edge_heading.setToolTip(f"Where {name} is")
-
- def _reflect_jump_key(self) -> None:
- chosen = self._chosen_machine()
- entry = next((peer for peer in self._peer_entries if peer.get("id") == chosen), None)
- self.jump_heading.setVisible(entry is not None)
- self.jump_recorder.setVisible(entry is not None)
- self.jump_clear.setVisible(entry is not None)
- self.jump_note.setVisible(entry is not None)
- if entry is None:
- self.jump_recorder.cancel()
- return
- name = self._shown(peerlist.label_for(self._peer_entries, peer_id=chosen) or "this machine")
- self.jump_recorder.set_value(entry.get("jump_key", ""))
- self.jump_heading.setText(f"Jump to {name}")
- self.jump_clear.setAccessibleName(f"Clear jump key for {name}")
- chord = self.jump_recorder.key.text()
- if entry.get("jump_key"):
- self.jump_note.setText(f"Press {chord} to send input to {name}; press again to bring it home.")
- else:
- self.jump_note.setText(f"Choose a key combination to jump to {name} and back.")
- self.jump_note.setToolTip(f"Works while edges are held. Needs In use, This PC drives it and permission from {name} to drive it.")
+ self.resistance_strip.set_edge(held["side"] or "right")
+ self._update_resistance_hint(config.crossing_resistance_px)
def _jump_arming(self, armed: bool) -> None:
self.sender.jump_recording = armed
def _record_jump_key(self, value: str) -> None:
- chosen = self._chosen_machine()
- if chosen is None or self._config is None:
- return
- try:
- app_config.set_jump_key(self.config_path, chosen, value, self._config.trigger_key)
- except ConfigError as exc:
- self._read_crossing()
- self._reflect_jump_key()
- self.jump_note.setText(self._shown(str(exc)))
- return
- self._read_crossing()
- self.sender.refresh()
- self._reflect_jump_key()
-
- def _set_arrangement(self, pc_edge: str) -> None:
- """The edge of THIS PC that leads to the chosen machine -- one border, walked either way. Not
- an ordinary change: both machines have to agree on it, so this end's change is stamped and
- sent to that machine over whichever link is up."""
- if ways.ways(self._crossing_settings(), self._chosen_machine())["side"] == pc_edge:
- return
- self._write_ways(side=pc_edge)
+ self._ledger_jump(self._chosen_machine(), value)
def _set_hold_full_screen(self, enabled: bool) -> None:
if self._config is None:
@@ -1690,53 +2308,39 @@ class WindowsApplication(QWidget):
self._persist()
self.sender.update_config(self._config)
- def _set_corner(self, corner: str) -> None:
- self._write_ways(corner=corner)
def _tell(self, peer: str) -> None:
"""This PC's side for `peer` as held, stamped as held, with whether a way leads there (WIRE.md
section 8), over whichever link is up. Nothing while no side is set."""
settings = self._crossing_settings()
entry = next((item for item in settings["peers"] if item.get("id") == peer), None)
- if entry is None or entry.get("side") not in return_edge.EDGES or not entry.get("side_set_at"):
+ if entry is None:
return
+ edge = entry.get("side")
+ if edge not in return_edge.EDGES:
+ if peer not in self._layout_capable():
+ return
+ # Picture peers ignore the wire edge; a gap must still report its return-way status.
+ edge = "right"
author = protocol.read_id(entry.get("side_by")) or protocol.read_id(self._config.machine_id)
target = protocol.read_id(peer)
if author is None or target is None:
return
self._send_to(target, protocol.arrangement_v6(
- entry["side"], entry["side_set_at"], author, way_back=ways.has_way(settings, peer),
+ edge, int(entry.get("side_set_at", 0)), author, way_back=ways.has_way(settings, peer),
way_back_by=protocol.read_id(ways.way_back_by(settings, peer)),
))
def _on_arrangement(self, peer: str, edge: str, set_at: int, by: str, way_back=None, way_back_by=None) -> None:
- """A peer changed the arrangement, over either link. `edge` is the edge of the PEER that
- faces this PC; one older than what this end holds, by stamp and then by id, is ignored. A
- side that makes two zones cover one stretch turns the peer's clashing zones off. `way_back`
- is kept whatever the side; a message that changed anything here is answered with this PC's
- own, and one that changed nothing is not, so two machines never answer in turn."""
if self._config is None:
return
- self._read_crossing()
- before = ways.way_back_state(self._crossing_settings())
- try:
- changed, notices = app_config.apply_arrangement(self.config_path, peer, edge, set_at, by, way_back,
- way_back_by, live=self._live)
- except (ConfigError, OSError):
- LOGGER.exception("An arrangement could not be saved")
- return
- if not changed:
- return
- for notice in notices:
- self._on_alert("Beamer", notice)
- self._pull_peer_fields()
- self.sender.refresh()
- self.server.peers_changed()
- self._read_crossing()
- changed_peers = [target for target, state in ways.way_back_state(self._crossing_settings()).items()
- if before.get(target) != state]
- for target in dict.fromkeys([*changed_peers, peer]):
- self._tell(target)
+ with app_config.SETTINGS_LOCK:
+ outcome = crossing_state.receive_arrangement(
+ app_config.load_settings(self.config_path), peer,
+ {"edge": edge, "set_at": set_at, "by": protocol.read_id(by),
+ "way_back": way_back, "way_back_by": protocol.read_id(way_back_by)},
+ **self._crossing_event_args())
+ self._carry_crossing(outcome)
def _pull_peer_fields(self) -> None:
"""What links wrote into the first peer, into the window's flat view, and every machine's side
@@ -1757,19 +2361,14 @@ class WindowsApplication(QWidget):
def _resistance_module(self, current: Config) -> QWidget:
module = widgets.Module("Resistance")
+ self.resistance_readout = widgets.Figure(f"{current.crossing_resistance_px} px")
+ module.body.addWidget(self.resistance_readout)
self.resistance_strip = PushStrip()
self.resistance_strip.set_edge("right")
self.resistance_strip.set_value(current.crossing_resistance_px)
+ self.resistance_slider = self.resistance_strip
+ self.resistance_strip.valueChanged.connect(self._resistance_changed)
module.body.addWidget(self.resistance_strip)
- row = QHBoxLayout()
- row.setSpacing(10)
- self.resistance_slider = widgets.Ruler("Resistance", pages_win.RESISTANCE_MAX)
- self.resistance_slider.setValue(current.crossing_resistance_px)
- self.resistance_slider.valueChanged.connect(self._resistance_changed)
- row.addWidget(self.resistance_slider, 1)
- self.resistance_readout = widgets.label(f"{current.crossing_resistance_px} px", "readout")
- row.addWidget(self.resistance_readout)
- module.body.addLayout(row)
self.resistance_hint = widgets.label("", "note", wrap=True)
module.body.addWidget(self.resistance_hint)
self._update_resistance_hint(current.crossing_resistance_px)
@@ -1777,23 +2376,53 @@ class WindowsApplication(QWidget):
def _resistance_changed(self, value: int) -> None:
self.resistance_readout.setText(f"{value} px")
- self.resistance_strip.set_value(value)
self._update_resistance_hint(value)
if self._config is None:
return
self._config.crossing_resistance_px = int(value)
self.sender.update_config(self._config)
+ configure_seams = getattr(self, "_configure_capture_seams", None)
+ if callable(configure_seams):
+ configure_seams(self._config)
self._debounce_save()
def _update_resistance_hint(self, value: int) -> None:
+ side = ways.ways(self._crossing_settings(), self._chosen_machine())["side"]
text = (
"Switches the moment this PC's pointer touches the edge. Each screen supplies its own zones."
if value == 0
- else "Follows this PC's mouse on every screen; each screen supplies its own zones."
+ else "Follows this PC's mouse or trackpad on every screen; each screen supplies its own zones."
)
+ if value and side:
+ text += f" This screen's {side} edge lights to show the resistance."
if text != self.resistance_hint.text():
self.resistance_hint.setText(text)
+ def _on_local_pressure(self, edge: str, pressure: float, crossed: bool, _part=None) -> None:
+ if self._closing or not hasattr(self, "resistance_strip"):
+ return
+ resistance = self.resistance_strip.value()
+ if crossed:
+ self.resistance_pressure_timer.stop()
+ self.resistance_strip.set_pressure(resistance, edge, crossed=True)
+ return
+ self.resistance_strip.set_pressure(pressure * resistance, edge)
+ if pressure > 0:
+ self.resistance_pressure_timer.start()
+ else:
+ self.resistance_pressure_timer.stop()
+
+ def _relay_sender_pressure(self, edge: str, pressure: float, crossed: bool, part=None) -> None:
+ self.bridge.pressure.emit(edge, pressure, crossed, part)
+ self.bridge.local_pressure.emit(edge, pressure, crossed, part)
+
+ def _refresh_local_pressure(self) -> None:
+ pressure = self.sender.pressure_at(time.monotonic())
+ resistance = self.resistance_strip.value()
+ self.resistance_strip.set_pressure(pressure * resistance)
+ if pressure <= 0:
+ self.resistance_pressure_timer.stop()
+
# -- Keyboard -----------------------------------------------------------------------------
def _keyboard_page(self, layout, current: Config) -> None:
@@ -1943,17 +2572,27 @@ class WindowsApplication(QWidget):
def _shortcut_module(self, current: Config) -> QWidget:
module = widgets.Module("Shortcut")
- module.body.addWidget(
- widgets.label(
- "Use this key to send input to another machine, and to bring it back.", "note", wrap=True
- )
- )
+ key = TRIGGER_KEYS.get(current.trigger_key, current.trigger_key)
+ self.shortcut_tile = widgets.WayTile("Shortcut", f"{key}, to where input last went")
+ self.shortcut_tile.setChecked("shortcut" in current.crossing_methods)
+ self.shortcut_tile.toggled.connect(lambda on: self._ways_changed("shortcut", on))
+ module.body.addWidget(self.shortcut_tile)
self.wayland_shortcut_note = widgets.label(
"On Wayland the shortcut only brings input back: the desktop lets input go to another machine only "
"when the pointer pushes through an edge, and keys on the Stays on this PC list cannot stay here "
"while input is away.", "note", wrap=True)
self.wayland_shortcut_note.setVisible(platform_parts.WAYLAND)
module.body.addWidget(self.wayland_shortcut_note)
+ self.shortcut_target_choice = widgets.Choice(
+ (("last", "Last machine"), ("next", "Next in order"), ("ticked", "Next among ticked")),
+ 3, current.shortcut_goes_to, on_change=self._set_shortcut_goes_to,
+ )
+ self.shortcut_target_choice.set_names("Shortcut goes to")
+ self.shortcut_target_row = self._row(widgets.label("Shortcut goes to", "key"), self.shortcut_target_choice.view)
+ self.shortcut_target_note = widgets.label("", "note", wrap=True)
+ note_policy = self.shortcut_target_note.sizePolicy()
+ note_policy.setVerticalPolicy(QSizePolicy.Policy.Minimum)
+ self.shortcut_target_note.setSizePolicy(note_policy)
self.trigger_recorder = widgets.InputRecorder(
TRIGGER_KEYS.get(current.trigger_key, current.trigger_key),
self._record_trigger,
@@ -1963,6 +2602,10 @@ class WindowsApplication(QWidget):
)
self.trigger_recorder.HINT = "Click, then press the key"
self.trigger_recorder.hint.setText(self.trigger_recorder.HINT)
+ self.trigger_recorder.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Preferred)
+ self.trigger_recorder.key.setFont(theme.mono_font(theme.TYPE["keycap"]))
+ self.trigger_recorder.hint.setAlignment(Qt.AlignmentFlag.AlignLeft)
+ self.trigger_recorder._content.setSpacing(6)
module.body.addWidget(self.trigger_recorder)
self.trigger_note = widgets.label("", "note-amber", wrap=True)
self.trigger_note.setVisible(False)
@@ -1971,21 +2614,21 @@ class WindowsApplication(QWidget):
TRIGGER_STYLE_CHOICES, columns=2, current=current.trigger_style, on_change=self._set_trigger_style
)
self.trigger_style_choice.set_names("How you press it")
- module.body.addWidget(self._row(widgets.label("How you press it", "key"), self.trigger_style_choice.view))
+ self.trigger_style_row = self._row(widgets.label("How you press it", "key"), self.trigger_style_choice.view)
+ module.body.addWidget(self.trigger_style_row)
+ module.body.addWidget(self.shortcut_target_row)
+ module.body.addWidget(self.shortcut_target_note)
self.style_hint = widgets.label("", "note", wrap=True)
- module.body.addWidget(self.style_hint)
- head = QHBoxLayout()
- head.setSpacing(10)
- head.addWidget(widgets.label("Time between taps", "key"))
- head.addStretch(1)
- self.double_tap_readout = widgets.label(f"{current.double_tap_ms} ms", "readout")
- head.addWidget(self.double_tap_readout)
+ self.double_tap_readout = widgets.Figure(f"{current.double_tap_ms} ms")
+ head = widgets.FormRow(widgets.label("Time between taps", "key"), self.double_tap_readout)
# The Mac's range: the store takes 50 to 2000 ms, but only about 150 to 600 is useful.
- self.double_tap_slider = widgets.Ruler("Time between taps", 1000, minimum=50)
+ self.double_tap_slider = widgets.Ruler("Time between taps", 1000, minimum=50,
+ ticks=(50, 150, 300, 600, 1000), scale="sqrt")
self.double_tap_slider.setValue(current.double_tap_ms)
self.double_tap_slider.valueChanged.connect(self._double_tap_changed)
self.double_tap_row = self._row(head, self.double_tap_slider)
module.body.addWidget(self.double_tap_row)
+ module.body.addWidget(self.style_hint)
self.double_tap_row.setVisible(current.trigger_style != "hold")
self._update_style_hint(current.trigger_style)
return module
@@ -2025,13 +2668,14 @@ class WindowsApplication(QWidget):
self.trigger_note.setText(note)
self.trigger_note.setVisible(bool(note))
+ @_crossing_refresh
def _set_trigger_style(self, value: str) -> None:
if self._config is None:
return
self._config.trigger_style = value
self._persist()
self._configure_trigger(self._config)
- motion.set_shown(self.double_tap_row, value != "hold")
+ motion.set_shown(self.double_tap_row, value != "hold", fade=False)
self._update_style_hint(value)
self._reflect_ways()
@@ -2189,16 +2833,23 @@ class WindowsApplication(QWidget):
module.body.addWidget(caption)
module.body.addSpacing(6)
# Every style and every switch plays at this length, so it follows the tiles either way.
- self.length_choice = widgets.Choice(effects.LENGTHS, 3, current.effect_length, on_change=self._apply_look)
- self.length_choice.set_names("Length")
- self.length_choice.set_width(240)
- self.size_choice = widgets.Choice(effects.SIZES, 3, current.effect_size, on_change=self._apply_look)
- self.size_choice.set_names("Size")
- self.size_choice.set_width(240)
- for title, choice in (("Length", self.length_choice), ("Size", self.size_choice)):
- module.body.addWidget(self._row(widgets.label(title, "key"), choice.view))
- module.body.addWidget(widgets.label(
- "Length changes effect playback time, not crossing resistance or key timing. Size changes depth for styles that support it; it does not change resistance.", "small", wrap=True))
+ self.length_choice = _DesignChoiceSlider(
+ "Length", 25, 250, 5, 100, (0.5, 1.0, 2.0), effects.LENGTHS)
+ self.size_choice = _DesignChoiceSlider(
+ "Size", 20, 80, 1, 1000, (0.03, 0.045, 0.06), effects.SIZES)
+ self.length_readout = design_readout()
+ self.size_readout = design_readout()
+ for title, control, readout, description in (
+ ("Length", self.length_choice, self.length_readout, "Sets the effect's playback time."),
+ ("Size", self.size_choice, self.size_readout,
+ "Sets depth relative to the shorter screen edge.")):
+ row = self._row(widgets.label(title, "key"), control.view, readout)
+ module.body.addWidget(row)
+ module.body.addWidget(widgets.label(description, "small"))
+ self.length_choice.slider.valueChanged.connect(self._apply_look)
+ self.size_choice.slider.valueChanged.connect(self._apply_look)
+ self.length_choice.slider.sliderReleased.connect(self._apply_look)
+ self.size_choice.slider.sliderReleased.connect(self._apply_look)
self.colour_module = widgets.Module("Colour")
self.colour_note = widgets.label("For the crossing and the shortcut alike", "small")
self.colour_module.body.addWidget(self.colour_note)
@@ -2225,6 +2876,8 @@ class WindowsApplication(QWidget):
self._reflect_look()
if self._config is None:
return
+ if self.length_choice.slider.isSliderDown() or self.size_choice.slider.isSliderDown():
+ return
self._config.edge_glow = self.glow_toggle.isChecked()
self._config.shortcut_arrival = self.landing_toggle.isChecked()
self._config.shortcut_arrival_style = self.switch_style_choice.value or "match"
@@ -2232,6 +2885,8 @@ class WindowsApplication(QWidget):
self._config.glow_colour = self.glow_colour_choice.value
self._config.effect_length = self.length_choice.value or "normal"
self._config.effect_size = self.size_choice.value or "medium"
+ self._config.effect_pace = self.length_choice.numeric_value()
+ self._config.effect_size_fraction = self.size_choice.numeric_value()
self._persist()
self._hide_crossing()
@@ -2249,6 +2904,10 @@ class WindowsApplication(QWidget):
self.design_mode_choice.set_value("crossing")
switching = landing and self.design_mode_choice.value == "switch"
style = self.glow_style_choice.value
+ crossing_fx = (effects.preview_effect(style) if pages_win.effects_load_error() is None
+ else effects.CLASSIC.get(style))
+ if crossing_fx is not None:
+ self.switch_style_choice.set_detail("match", f"Plays {crossing_fx.name}")
edge = ways.ways(self._crossing_settings(), self._chosen_machine())["side"] or "right"
colour = self.glow_colour_choice.value or "signal"
methods = sorted(self._ways_in())
@@ -2257,14 +2916,15 @@ class WindowsApplication(QWidget):
self.effect_method_choice.set_value(pages_win.preview_place(methods))
method = self.effect_method_choice.value or "edge"
switch_style = (self.switch_style_choice.value or "match") if switching else None
- length = self.length_choice.value or "normal"
- size = self.size_choice.value or "medium"
+ length = self.length_choice.numeric_value()
+ size = self.size_choice.numeric_value()
look = (style, colour, switching, switch_style, method, edge, length, size)
previous, self._look = self._look, look
- # Each still redrawn by this change cross-fades: every one with the colour or the length, the
+ # Each still redrawn by this change cross-fades: every one with the colour or the size, the
# crossing's with the place, the Shortcut and menu stills with the crossing style beside them.
+ # The length redraws none: a still is the same frame of its effect at every length.
stills = []
- if previous is not None and (previous[1], previous[6], previous[7]) != (colour, length, size):
+ if previous is not None and (previous[1], previous[7]) != (colour, size):
stills = [*self.effect_stills.values(), *self.switch_stills.values()]
elif previous is not None and previous[7] != size:
stills = [*self.effect_stills.values(), *self.switch_stills.values()]
@@ -2294,10 +2954,13 @@ class WindowsApplication(QWidget):
fx = (effects.preview_effect(style) if pages_win.effects_load_error() is None
else effects.CLASSIC.get(style)) or effects.CLASSIC["glow"]
self.effect_name.setText(f"{fx.name}, {fx.intensity}")
+ wayland_effects_unavailable = platform_parts.WAYLAND and (
+ not os.environ.get("DISPLAY") or self._effects_failed
+ )
self.effect_note.setText(
"On Wayland the desktop does not let Beamer draw at the edges of the screen, so crossings show no "
"effect on this machine. The other machines still show theirs."
- if platform_parts.WAYLAND
+ if wayland_effects_unavailable
else "The effects stopped working and are off until Beamer restarts, so crossings show Glow in "
"the same colours. The log says why."
if self._effects_failed
@@ -2310,10 +2973,19 @@ class WindowsApplication(QWidget):
still.set_palette(colours)
for still in self.switch_stills.values():
still.set_crossing_style(style)
- pace = effects.pace(length)
+ pace = length
+ screen = QApplication.primaryScreen()
+ geometry = screen.availableGeometry() if screen is not None else None
+ width, height = (geometry.width(), geometry.height()) if geometry is not None else (1920, 1080)
+ readout_style = fx.id if switching else style
+ length_text, size_text = effects.design_slider_readouts(readout_style, pace, size, width, height)
+ self.length_readout.setText(length_text)
+ self.size_readout.setText(size_text)
+ self.length_choice.set_accessible_value(length_text)
+ self.size_choice.set_accessible_value(size_text)
for still in (*self.effect_stills.values(), *self.switch_stills.values()):
still.set_pace(pace)
- still.set_effect_size(size)
+ still.set_effect_size(self.size_choice.value, size)
for still in self.effect_stills.values():
still.set_place(method)
for still, shot in still_shots.items():
@@ -2344,7 +3016,9 @@ class WindowsApplication(QWidget):
# A change to a shared setting while Same on all machines is on is stamped here, where
# every page's changes are saved, and sent once saved.
fields = self._same_fields()
- shared = self._same_seen is not None and fields != self._same_seen and self._config.same_on_both
+ seen = self._same_seen
+ shared = (seen is not None and self._config.same_on_both
+ and settings_sync.changed(seen, fields, self._config.same_groups))
self._same_seen = fields
design_fields = self._design_fields()
design_changed = self._design_seen is not None and design_fields != self._design_seen
@@ -2353,9 +3027,19 @@ class WindowsApplication(QWidget):
self._config.design_set_at = settings_sync.next_stamp(
max(self._config.design_set_at, self._config.same_set_at), time.time())
self._config.design_by = self._config.machine_id
+ # Each shared value changed here gets its own stamp, with Same on or off, so the latest
+ # choice of each wins when it is turned on later; the values left alone keep theirs.
+ stamp = None
+ if seen is not None:
+ config = self._config
+ held = settings_sync.held_stamps(config.same_stamps, config.same_set_at, config.same_by)
+ held, stamp = settings_sync.stamp_changes(held, seen, fields, config.machine_id,
+ floor=max(config.same_set_at, config.design_set_at))
+ if stamp is not None or shared:
+ config.same_stamps = settings_sync.stored_stamps(held)
if shared:
- self._config.same_set_at = settings_sync.next_stamp(
- max(self._config.same_set_at, self._config.design_set_at), time.time())
+ self._config.same_set_at = max(stamp or 0, settings_sync.next_stamp(
+ max(self._config.same_set_at, self._config.design_set_at), time.time()))
self._config.same_by = self._config.machine_id
try:
with app_config.SETTINGS_LOCK:
@@ -2420,8 +3104,19 @@ class WindowsApplication(QWidget):
held = next((peer for peer in settings["peers"] if peer.get("token") == replaced.get("token")), None)
if held is None or held.get("id") != replaced.get("id") or held.get("linked") != replaced.get("linked"):
raise ConfigError("the machine being replaced changed while pairing")
+ if replaced is not None and (held.get("id") == entry.get("id") or (
+ not held.get("id") and held.get("from_1_4")
+ and held.get("host") == entry.get("host")
+ and held.get("platform") == entry.get("platform"))):
+ for field in ("ways", "shortcut_cycle", "jump_key"):
+ if field in held:
+ entry[field] = copy.deepcopy(held[field])
peerlist.add_peer(settings, entry, replaced)
- app_config.write_settings(self.config_path, settings)
+ settings["layout"] = ways.derive_layout(settings, gap=0)
+ outcome = crossing_state.paired(settings, platform="pc", own_displays=self._own_displays(),
+ now=time.time(), capable=self._layout_capable() | {entry["id"]})
+ outcome["changed"] = True
+ self._carry_crossing(outcome, redraw=False)
def _peer_items(self, peers: list) -> list:
"""(entry, label, state, where) for every paired machine, from what the links know of it now."""
@@ -2451,9 +3146,33 @@ class WindowsApplication(QWidget):
items.append((entry, labels[token], state, where))
return items
+ def _window_settings(self) -> dict:
+ """GUI-only snapshot; link read/modify/write paths continue to read under their lock."""
+ with app_config.SETTINGS_LOCK:
+ version = []
+ for path in (self.config_path, app_config.legacy_config_path(self.config_path)):
+ try:
+ stat = path.stat()
+ version.append((stat.st_mtime_ns, stat.st_ctime_ns, stat.st_size, stat.st_ino))
+ except FileNotFoundError:
+ version.append(None)
+ version = tuple(version)
+ if version != getattr(self, "_window_settings_version", None):
+ try:
+ saved = app_config.load_settings(self.config_path)
+ except (ConfigError, OSError):
+ if hasattr(self, "_window_settings_cache"):
+ return self._window_settings_cache
+ raise
+ self._window_settings_cache = saved
+ # Keep the pre-read version so a concurrent replacement is seen next tick.
+ self._window_settings_version = version
+ return self._window_settings_cache
+
def _refresh_peers(self) -> None:
try:
- peers, zones = self.book.peers(), self.book.zones()
+ saved = self._window_settings()
+ peers, zones = copy.deepcopy((saved.get("peers", []), saved.get("zones", [])))
except (ConfigError, OSError):
LOGGER.exception("The peers could not be read")
peers, zones = [], []
@@ -2463,8 +3182,8 @@ class WindowsApplication(QWidget):
self._config.design_follow_peer = ""
self._persist()
self._refresh_design_follow()
- self.machines.set_peers(self._peer_items(peers))
- if hasattr(self, "arrangement_diagram"):
+ self._set_machine_peers(peers)
+ if hasattr(self, "atlas_canvas"):
self._reflect_other_name()
# A machine paired, removed or renamed, or a side or zone a link wrote: the Crossing page follows.
seen = repr((peers, zones, self._hide_addresses()))
@@ -2478,7 +3197,12 @@ class WindowsApplication(QWidget):
def _refresh_peer_states(self) -> None:
"""The rows' states again from the peers last read: the links move faster than the file does."""
- self.machines.set_peers(self._peer_items(self._peer_entries))
+ self._set_machine_peers(self._peer_entries)
+
+ def _set_machine_peers(self, peers: list) -> None:
+ group_on = settings_sync.group_on(self._config, "names") if self._config else False
+ shortcut_goes_to = self._config.shortcut_goes_to if self._config else "last"
+ self.machines.set_peers(self._peer_items(peers), same_on=group_on, cycle_mode=shortcut_goes_to)
def _any_send(self) -> bool:
return any(entry.get("in_use", True) is True and entry.get("send") and protocol.linkable(entry)
@@ -2487,6 +3211,64 @@ class WindowsApplication(QWidget):
def _label_of(self, peer: Optional[bytes]) -> str:
return self._labels_by_id.get(peer, "another machine") if peer is not None else ""
+ def _header_response_time(self):
+ outgoing = {peer for entry in self._peer_entries
+ if (peer := protocol.read_id(entry.get("id"))) is not None and self.sender.links.up(peer)}
+ incoming = self.server.links()
+ peer = self.sender.owner if self.sender.owner in outgoing else None
+ if peer is None and self.server.owner in incoming:
+ peer = self.server.owner
+ if peer is None:
+ candidates = outgoing | incoming
+ peer = min(candidates) if candidates else None
+ if peer is None:
+ return "", None, False
+ link = self.sender.links._link(peer)
+ response = getattr(link, "response_time_ms", None) if link is not None and link.live() else None
+ if response is None and peer in incoming:
+ lookup = getattr(self.server, "response_time_ms", None)
+ response = lookup(peer) if lookup is not None else None
+ return self._label_of(peer), response, True
+
+ def _drive_status(self) -> str:
+ if self.sender.redirecting:
+ return f"Driving {self._label_of(self.sender.owner)}"
+ driver = self.server.owner
+ return f"Driven by {self._label_of(driver)}" if driver is not None else "Idle"
+
+ def _refresh_tray_state(self) -> None:
+ state = self._shown(self._drive_status())
+ previous = getattr(self, "_last_drive_status", None)
+ if previous is not None and previous != state:
+ self._last_refusal = ""
+ self._refusal_notices.reset()
+ self._last_drive_status = state
+ tooltip = f"{state}\n{self._shown(self._last_refusal)}" if self._last_refusal else state
+ if hasattr(self, "tray"):
+ if getattr(self, "_tray_tooltip_seen", None) != tooltip:
+ self.tray.setToolTip(tooltip)
+ self._tray_tooltip_seen = tooltip
+ if hasattr(self, "status_action") and self.status_action.text() != state:
+ self.status_action.setText(state)
+
+ def _current_chain_sentence(self) -> str:
+ route = self.sender.route_chain
+ if len(route) <= 1:
+ driver = self.server.owner
+ route = (driver, self._identity()["id"]) if driver is not None else ()
+ if not route:
+ return "Current chain: Idle"
+ identity = self._identity()
+ own_id = protocol.id_text(identity["id"])
+ names = []
+ for ident in route:
+ key = ident if isinstance(ident, str) else protocol.id_text(ident)
+ if key == own_id:
+ names.append(identity["name"])
+ else:
+ names.append(self._labels_by_id.get(protocol.read_id(key), "another machine"))
+ return "Current chain: " + " → ".join(names)
+
def _edit_peer(self, token: str, **fields) -> bool:
try:
with app_config.SETTINGS_LOCK:
@@ -2531,6 +3313,20 @@ class WindowsApplication(QWidget):
if self._edit_peer(token, in_use=bool(enabled)):
self._after_peers_edit()
+ def _set_peer_left_out(self, token: str, enabled: bool) -> None:
+ try:
+ with app_config.SETTINGS_LOCK:
+ settings = app_config.load_settings(self.config_path)
+ entry = next((item for item in settings["peers"] if item.get("token") == token), None)
+ if entry is None or entry.get("port") == 0:
+ return
+ event = crossing_state.leave_out if enabled else crossing_state.put_back
+ self._carry_crossing(event(settings, entry["id"], **self._crossing_event_args()))
+ except (ConfigError, OSError):
+ LOGGER.exception("A machine's layout state could not be saved")
+ return
+ self._refresh_peers()
+
def _set_every_peer(self, field: str, enabled: bool) -> None:
"""The tray's two ticks: one direction for every paired machine at once."""
if field == "send" and not enabled and self.sender.owner is not None:
@@ -2548,44 +3344,61 @@ class WindowsApplication(QWidget):
self._after_peers_edit()
def _refresh_tray_directions(self) -> None:
- """The tray's ticks name who they cover and show whether every machine has the direction on."""
+ """Name each direction's scope and distinguish none, some and all machines being enabled."""
for action, field, text in (
- (self.drive_action, "allow_drive", "Machines drive this PC"),
(self.send_action, "send", "This PC drives machines"),
+ (self.drive_action, "allow_drive", "Machines drive this PC"),
):
entries = peerlist.desktops(self._peer_entries) if field == "send" else self._peer_entries
if len(entries) == 1:
who = self._shown(peerlist.labels(entries)[entries[0]["token"]])
text = f"{who} drives this PC" if field == "allow_drive" else f"This PC drives {who}"
+ elif len(entries) > 1:
+ text = "Every machine drives this PC" if field == "allow_drive" else "This PC drives every machine"
action.setEnabled(bool(entries))
+ enabled = [entry.get(field) is True for entry in entries]
+ if enabled and any(enabled) and not all(enabled):
+ text += " (some enabled)"
if action.text() != text:
action.setText(text)
- on = bool(entries) and all(entry.get(field) for entry in entries)
+ on = bool(enabled) and all(enabled)
if action.isChecked() != on:
action.setChecked(on)
def _refresh_tray_machines(self) -> None:
- """With more than one machine to send to, the tray has "Send input to" for each, and the toggle
- is only there to bring input back; with one, the toggle names it, as it always did."""
+ """List each send target; the active target's row returns input to this PC."""
labels = peerlist.labels(self._peer_entries)
- sendable = [(entry["id"], f"Send input to {self._shown(labels[entry['token']])}") for entry in self._peer_entries
+ sendable = [(entry["id"], self._shown(labels[entry["token"]])) for entry in self._peer_entries
if entry.get("in_use", True) is True and entry.get("send") and entry.get("port")
and protocol.read_id(entry.get("id")) is not None]
items = sendable if len(sendable) > 1 else []
- if items != [(ident, action.text()) for ident, action in self.machine_actions.items()]:
+ if [ident for ident, _label in items] != list(self.machine_actions):
for action in self.machine_actions.values():
self.tray_menu.removeAction(action)
action.deleteLater()
self.machine_actions = {}
- for ident, text in items:
- action = QAction(text, self.tray_menu)
- action.triggered.connect(lambda _checked=False, peer=protocol.read_id(ident): self.sender.go(peer))
+ for ident, _label in items:
+ action = QAction("", self.tray_menu)
+ action.triggered.connect(
+ lambda _checked=False, peer=protocol.read_id(ident): self._send_to_from_tray(peer)
+ )
self.tray_menu.insertAction(self.pause_action, action)
self.machine_actions[ident] = action
- on = self.sender.owner
- for ident, action in self.machine_actions.items():
- action.setEnabled(protocol.read_id(ident) != on)
- self.redirect_action.setVisible(not self.machine_actions or self.sender.redirecting)
+ owner = self.sender.owner if self.sender.redirecting else None
+ for ident, label in items:
+ action = self.machine_actions[ident]
+ text = "Bring input back" if protocol.read_id(ident) == owner else f"Send input to {label}"
+ if action.text() != text:
+ action.setText(text)
+ action.setEnabled(True)
+ self.redirect_action.setVisible(not self.machine_actions)
+
+ def _send_to_from_tray(self, peer: bytes) -> None:
+ """Return input when its active target is chosen; otherwise switch to that machine."""
+ if self.sender.redirecting and self.sender.owner == peer:
+ self.sender.set_redirecting(False)
+ else:
+ self.sender.go(peer)
def _after_peers_edit(self) -> None:
"""Whatever changed the peers list: the flat view and the links follow, and the machines are listed again."""
@@ -2635,7 +3448,8 @@ class WindowsApplication(QWidget):
LOGGER.exception("A machine could not be removed")
self._on_alert("Beamer", "Beamer could not save the removal. Try again in a moment.")
return
- LOGGER.info("Removed %s from the paired machines", removed.get("name") or "a machine")
+ LOGGER.info("Removed %s from the paired machines",
+ peerlist.label_for([removed], token=token) or "a machine")
if remaining:
self._after_peers_edit()
for peer, state in after.items():
@@ -2656,7 +3470,8 @@ class WindowsApplication(QWidget):
self._reflect_config(self._config)
self.server.peers_changed()
self.sender.refresh()
- self.same_switch.setEnabled(False)
+ for check in self.same_checks.values():
+ check.setEnabled(False)
self._refresh_peers()
def _toggle_pairing_sheet(self) -> None:
@@ -2667,6 +3482,24 @@ class WindowsApplication(QWidget):
self.machines.set_pairing_open(self._pairing_open)
self._refresh_pairing()
+ def _re_pair(self, token: str) -> None:
+ entry = next((item for item in self._peer_entries if item.get("token") == token), None)
+ if entry is None:
+ return
+ self._select_page("overview")
+ self._pairing_open = True
+ address = entry.get("host") or ""
+ if self._hide_addresses():
+ self.sheet.address.clear()
+ self._refresh_pairing()
+ if self.pairing is not None and any(item.get("address") == address for item in self.pairing.machines()):
+ self.sheet._pick(address)
+ else:
+ self.sheet.address.setText(address)
+ self.sheet.setVisible(True)
+ self.machines.set_pairing_open(True)
+ self._refresh_pairing()
+
def _show_code(self) -> None:
if self.pairing is None:
self.sheet.say_host("Pairing is not available: this PC's settings could not be read.", "note-fault")
@@ -2771,8 +3604,9 @@ class WindowsApplication(QWidget):
self.sheet.say_pair(self._shown(peerlist.pairing_error_text(error, self._pairing_target or "That machine")), "note-fault")
return
self.sheet.clear_code()
- self.sheet.say_pair(self._shown(f"Paired with {entry['name']}."), "note-live")
- LOGGER.info("Paired with %s", entry["name"])
+ label = peerlist.label_for(self.book.peers(), token=entry.get("token")) or "that machine"
+ self.sheet.say_pair(self._shown(f"Paired with {label}."), "note-live")
+ LOGGER.info("Paired with %s", label)
self._after_peers_edit()
def _on_paired(self, entry) -> None:
@@ -2843,8 +3677,7 @@ class WindowsApplication(QWidget):
self._refresh_peers()
self._refresh_pairing()
self._refresh_window()
- self.tray.setToolTip(self._title())
- self.status_action.setText(self._title())
+ self._refresh_tray_state()
def save(self) -> None:
"""The Connection page's one setting is this PC's own port. It never touches a peer's entry, whose
@@ -2874,6 +3707,7 @@ class WindowsApplication(QWidget):
self.save_message.setVisible(True)
widgets.set_role(self.save_message, "note-live")
+ @_crossing_refresh
def _apply_config(self, config: Config) -> None:
self._config = config
self._settings_port = config.port
@@ -2882,12 +3716,16 @@ class WindowsApplication(QWidget):
self._apply_input_scale(config)
if not config.edge_glow:
self._hide_crossing()
- self.same_switch.setEnabled(self._paired)
+ for check in self.same_checks.values():
+ check.setEnabled(self._paired)
if self._paired:
self._start_receiver(config)
self.server.peers_changed()
self._send_paired()
self.sender.update_config(config)
+ configure_seams = getattr(self, "_configure_capture_seams", None)
+ if callable(configure_seams):
+ configure_seams(config)
self._refresh_peers()
if self._any_send():
self._start_sending(config)
@@ -2895,6 +3733,15 @@ class WindowsApplication(QWidget):
self._stop_sending()
self.host_readout.setText(self._shown(config.host) or "Not known yet")
+ def _configure_capture_seams(self, config: Config) -> None:
+ configure = getattr(getattr(self, "hooks", None), "configure_seams", None)
+ if not callable(configure):
+ return
+ try:
+ configure(self.sender._desktop_module().monitors(), config.crossing_resistance_px)
+ except Exception:
+ LOGGER.exception("Could not configure X11 display seam holds")
+
# -- Firewall, on Connection --------------------------------------------------------------
def _firewall_module(self, layout) -> None:
@@ -3052,32 +3899,33 @@ class WindowsApplication(QWidget):
def _build_tray(self) -> None:
self.tray = QSystemTrayIcon(QIcon(status_icon(self._status)), self)
- self.tray.setToolTip(self._title())
+ self.tray.setToolTip(self._drive_status())
menu = QMenu()
+ self.status_action = menu.addAction(self._drive_status())
+ self.status_action.setEnabled(False)
+ menu.addSeparator()
# The version line; it becomes the way to a newer release when there is one.
self.header_action = menu.addAction(f"Beamer {VERSION}")
self.header_action.setEnabled(False)
self.header_action.triggered.connect(self.open_update)
menu.addSeparator()
- self.open_action = menu.addAction("Open Beamer")
- self.open_action.triggered.connect(self.show_window)
- self.status_action = menu.addAction(self._title())
- self.status_action.setEnabled(False)
- self.tray_menu = menu
self.redirect_action = menu.addAction("Send input across")
self.redirect_action.triggered.connect(self.toggle_redirect)
self.pause_action = menu.addAction("Pause crossing")
self.pause_action.triggered.connect(self.toggle_pause)
menu.addSeparator()
+ self.tray_menu = menu
# One tick per direction, each the same switch the Overview page shows, so either
# direction can be turned off while the other keeps working and the two never disagree.
- self.drive_action = menu.addAction("Machines drive this PC")
- self.drive_action.setCheckable(True)
- self.drive_action.triggered.connect(lambda on: self._set_every_peer("allow_drive", on))
self.send_action = menu.addAction("This PC drives machines")
self.send_action.setCheckable(True)
self.send_action.triggered.connect(lambda on: self._set_every_peer("send", on))
+ self.drive_action = menu.addAction("Machines drive this PC")
+ self.drive_action.setCheckable(True)
+ self.drive_action.triggered.connect(lambda on: self._set_every_peer("allow_drive", on))
menu.addSeparator()
+ self.open_action = menu.addAction("Settings…")
+ self.open_action.triggered.connect(lambda _checked=False: self.show_window())
menu.addAction("Reload configuration").triggered.connect(self.reload_config)
menu.addAction("Open log folder").triggered.connect(self.open_log_folder)
menu.addSeparator()
@@ -3087,7 +3935,9 @@ class WindowsApplication(QWidget):
# Left click opens the window; right click is the
# context menu Qt already gives QSystemTrayIcon for free.
self.tray.activated.connect(self._on_tray_activated)
- self.tray.show()
+ if self.tray_available:
+ self.tray.show()
+ self._refresh_tray_state()
def reload_config(self) -> None:
"""Re-reads settings.json, for the times it was edited outside the window, and shows it."""
@@ -3104,9 +3954,10 @@ class WindowsApplication(QWidget):
self._reflect_config(config)
LOGGER.info("Configuration reloaded from %s", self.config_path)
+ @_crossing_refresh
def _reflect_config(self, config: Config) -> None:
"""Every control on every page set from `config`, without any of them saving back."""
- for box in (*self.way_boxes.values(), self.dragging_switch, self.hold_switch, self.glow_toggle,
+ for box in ( self.dragging_switch, self.hold_switch, self.glow_toggle,
self.landing_toggle,
self.resistance_slider, self.double_tap_slider):
box.blockSignals(True)
@@ -3119,15 +3970,15 @@ class WindowsApplication(QWidget):
self.resistance_slider.setValue(config.crossing_resistance_px)
self.double_tap_slider.setValue(config.double_tap_ms)
finally:
- for box in (*self.way_boxes.values(), self.dragging_switch, self.hold_switch, self.glow_toggle,
+ for box in ( self.dragging_switch, self.hold_switch, self.glow_toggle,
self.landing_toggle,
self.resistance_slider, self.double_tap_slider):
box.blockSignals(False)
- self.resistance_readout.setText(f"{config.crossing_resistance_px} px")
+ self._crossing_text(self.resistance_readout, f"{config.crossing_resistance_px} px")
self._update_resistance_hint(config.crossing_resistance_px)
- self.double_tap_readout.setText(f"{config.double_tap_ms} ms")
+ self._crossing_text(self.double_tap_readout, f"{config.double_tap_ms} ms")
self.resistance_strip.set_value(config.crossing_resistance_px)
- motion.set_shown(self.double_tap_row, config.trigger_style != "hold")
+ motion.set_shown(self.double_tap_row, config.trigger_style != "hold", fade=False)
self.trigger_recorder.set_title(TRIGGER_KEYS.get(config.trigger_key, config.trigger_key))
self.trigger_style_choice.set_value(config.trigger_style)
self._update_style_hint(config.trigger_style)
@@ -3135,8 +3986,8 @@ class WindowsApplication(QWidget):
self.modifier_note.setText(MODIFIER_NOTES[config.modifier_style])
self.glow_style_choice.set_value(config.glow_style)
self.glow_colour_choice.set_value(config.glow_colour)
- self.length_choice.set_value(config.effect_length)
- self.size_choice.set_value(config.effect_size)
+ self.length_choice.set_numeric(config.effect_pace)
+ self.size_choice.set_numeric(config.effect_size_fraction)
self._reflect_look()
self.appearance_choice.set_value(config.appearance)
self._apply_appearance(config.appearance)
@@ -3251,21 +4102,21 @@ class WindowsApplication(QWidget):
"""Every key, on the hook thread. The trigger is swallowed as it
switches; everything else goes to the Mac only while the Mac has
input, and a key on the ignored list not even then."""
- if isinstance(name, capture_win.TextInput):
+ if isinstance(name, TextInput):
return self.sender.on_text(name.text, vk)
- if isinstance(name, capture_win.DeadKey):
+ if isinstance(name, DeadKey):
return self.sender.on_dead_key(vk)
if self.sender.handle_jump_key(name, down, vk):
return True
if not self.sender.shortcut_armed:
- self._trigger.configure(self._trigger.key, self._trigger.style, self._trigger.window_ms)
+ self._trigger.disarmed(name, down)
return self.sender.on_key(name, down, vk, us)
action = self._trigger.feed(name, down, time.monotonic())
if action is not None:
if action == capture_win.TOGGLE:
- self.sender.toggle()
+ self.sender.toggle_shortcut()
else:
- self.sender.set_redirecting(action == capture_win.REDIRECT)
+ self.sender.hold_shortcut(action == capture_win.REDIRECT)
return True
if self._trigger.claims(name, down, self.sender.redirecting):
return True
@@ -3285,10 +4136,12 @@ class WindowsApplication(QWidget):
except Exception:
return
available = [item for item in peers if item.get("in_use", True) is True]
- ids = [protocol.read_id(item.get("id")) for item in available]
- for item, peer in zip(available, ids):
+ for item in available:
+ peer = protocol.read_id(item.get("id"))
if peer is not None and item.get("in_use", True) is True and item.get("send"):
- self._send_to(peer, protocol.paired_msg([other for other in ids if other not in (None, peer)][: protocol.MAX_PEERS]))
+ ids = [protocol.read_id(ident) for ident in peerlist.paired_ids(
+ peers, exclude=protocol.id_text(peer))]
+ self._send_to(peer, protocol.paired_msg(ids))
def _learn_peer_hardware(self, peer: bytes, address: str) -> None:
"""A peer's hardware address from the ARP table, off the GUI thread."""
@@ -3304,6 +4157,7 @@ class WindowsApplication(QWidget):
"""A peer took input on this PC, or gave it back. Either way the outward edge follows:
this PC's input is never here and elsewhere at once."""
self.sender.set_receiving(bool(peer))
+ self._refresh_tray_state()
def _on_peers_changed(self) -> None:
"""A link learnt something about a peer (an address, an id, a name, a hardware address) and
@@ -3321,14 +4175,24 @@ class WindowsApplication(QWidget):
self._sending_detail = (
f"This PC's keyboard and mouse are on {self._label_of(self.sender.owner)}" if redirecting else self.sender.status
)
+ self._refresh_tray_state()
def _announced_port(self) -> int:
return self._settings_port
- def show_window(self) -> None:
+ def show_window(self, activation_token: Optional[str] = None) -> None:
+ use_activation_token = bool(
+ activation_token and sys.platform.startswith("linux") and platform_parts.WAYLAND
+ )
+ if use_activation_token:
+ os.environ["XDG_ACTIVATION_TOKEN"] = activation_token
self.showNormal()
self.raise_()
- self.activateWindow()
+ try:
+ self.activateWindow()
+ finally:
+ if use_activation_token and os.environ.get("XDG_ACTIVATION_TOKEN") == activation_token:
+ os.environ.pop("XDG_ACTIVATION_TOKEN", None)
def open_home_page(self) -> None:
QDesktopServices.openUrl(QUrl(HOME_PAGE))
@@ -3336,7 +4200,7 @@ class WindowsApplication(QWidget):
def show_about(self) -> None:
box = QMessageBox(self)
box.setWindowTitle("About Beamer")
- box.setIconPixmap(QIcon(str(ICON_PATH)).pixmap(64, 64))
+ box.setIconPixmap(QIcon(str(ICON_PATH)).pixmap(QSize(64, 64), 1.0))
box.setTextFormat(Qt.TextFormat.RichText)
box.setText(
f"<b>Beamer {VERSION}</b><br>One keyboard and mouse for all your Macs and PCs.<br><br>"
@@ -3351,18 +4215,22 @@ class WindowsApplication(QWidget):
def showEvent(self, event) -> None:
super().showEvent(event)
+ if hasattr(self, "refresh_timer"):
+ self._refresh_window()
self._run_previews()
def hideEvent(self, event) -> None:
super().hideEvent(event)
self.ignored_recorder.cancel()
self.trigger_recorder.cancel()
- self.jump_recorder.cancel()
+ self.crossing_ledger.cancel_recording()
self._run_previews()
def changeEvent(self, event) -> None:
super().changeEvent(event)
if event.type() == QEvent.Type.WindowStateChange:
+ if hasattr(self, "refresh_timer") and not self.isMinimized():
+ self._refresh_window()
self._run_previews()
def quit(self) -> None:
@@ -3379,20 +4247,29 @@ class WindowsApplication(QWidget):
if stop_injector is not None:
stop_injector()
self._hide_crossing()
- self.tray.hide()
+ if hasattr(self, "tray"):
+ self.tray.hide()
QApplication.quit()
def closeEvent(self, event) -> None:
- """Closing the window hides to the tray; the tray's Quit ends the process."""
if self._closing:
super().closeEvent(event)
return
+ tray = getattr(self, "tray", None)
+ tray_visible = tray is not None and getattr(tray, "isVisible", lambda: False)()
+ if not tray_visible or not QSystemTrayIcon.isSystemTrayAvailable():
+ self.quit()
+ event.accept()
+ return
event.ignore()
self.hide()
def keyPressEvent(self, event) -> None:
if event.key() == Qt.Key.Key_Escape:
- self.hide()
+ if QSystemTrayIcon.isSystemTrayAvailable() and self.tray.isVisible():
+ self.hide()
+ else:
+ self.quit()
return
if event.key() in (Qt.Key.Key_Return, Qt.Key.Key_Enter) and self._page == "connection":
self.save()
@@ -3411,42 +4288,78 @@ class WindowsApplication(QWidget):
if self._closing or config is None or not config.edge_glow or not pages_win.is_effect(config.glow_style):
return None
if self.effects is None:
- self.effects = EffectOverlay(on_failure=self._on_effects_failed)
+ self.effects = (EffectOverlayX11Proxy(on_failure=self._on_effects_failed)
+ if xwayland_effects_available() else EffectOverlay(on_failure=self._on_effects_failed))
+ if isinstance(self.effects, EffectOverlayX11Proxy):
+ self.glow = self.effects
if self.effects.failed:
return None
- self.effects.configure(config.glow_style, config.glow_colour, config.effect_length, config.effect_size)
- if self.effects.failed or self.effects._fx is None:
+ self.effects.configure(config.glow_style, config.glow_colour, config.effect_length, config.effect_size,
+ config.effect_pace, config.effect_size_fraction)
+ ready = (self.effects.effect_ready if isinstance(self.effects, EffectOverlayX11Proxy)
+ else self.effects._fx is not None)
+ if self.effects.failed or not ready:
return None
return self.effects
def _on_pressure(self, edge: str, pressure: float, crossed: bool, part=None) -> None:
- if self._closing or self._config is None or not self._config.edge_glow or platform_parts.WAYLAND:
+ if (self._closing or self._config is None or not self._config.edge_glow
+ or (platform_parts.WAYLAND and not os.environ.get("DISPLAY"))):
return
overlay = self._effect_overlay()
if overlay is not None:
- overlay.push(edge, pressure, crossed, part=part)
+ if platform_parts.WAYLAND:
+ # InputCapture keeps the authoritative pointer pinned at the edge.
+ x, y = platform_parts.desktop.cursor_position()
+ point = QPointF(x, y)
+ if isinstance(overlay, EffectOverlayX11Proxy):
+ box = desktop_box()
+ overlay.push(edge, pressure, crossed, cursor=point, part=part, desk=box)
+ else:
+ overlay.push(edge, pressure, crossed, cursor=point, part=part)
+ else:
+ overlay.push(edge, pressure, crossed, part=part)
return
style = self._config.glow_style
if self.glow is None:
- self.glow = EdgeGlow()
+ self.glow = (EffectOverlayX11Proxy(on_failure=self._on_effects_failed)
+ if xwayland_effects_available() else EdgeGlow())
+ if isinstance(self.glow, EffectOverlayX11Proxy):
+ self.effects = self.glow
# An effect that failed earlier in the run falls back to the plain glow, in its colour.
- self.glow.configure(style if style in ("glow", "beam") else "glow", self._config.glow_colour,
- self._config.effect_length, self._config.effect_size)
+ glow_style = style if style in ("glow", "beam") else "glow"
+ if isinstance(self.glow, EffectOverlayX11Proxy):
+ self.glow.configure_glow(glow_style, self._config.glow_colour,
+ self._config.effect_length, self._config.effect_size,
+ self._config.effect_pace, self._config.effect_size_fraction)
+ else:
+ self.glow.configure(glow_style, self._config.glow_colour,
+ self._config.effect_length, self._config.effect_size,
+ self._config.effect_pace, self._config.effect_size_fraction)
self.glow.set_pressure(edge, pressure, crossed, part)
def _on_arrival(self, method: str, edge: str, x: float, y: float) -> None:
"""A crossing landed the pointer on `edge`, or with method "switch" input came here by a
switch and the pointer is wherever it was left."""
- if platform_parts.WAYLAND:
+ if platform_parts.WAYLAND and not os.environ.get("DISPLAY"):
return
if method == "switch":
overlay = self._switch_overlay()
if overlay is not None:
- overlay.switched(logical_point(x, y), self._config.shortcut_arrival_style)
+ if isinstance(overlay, EffectOverlayX11Proxy):
+ box = desktop_box()
+ overlay.switched(x, y, [box.x(), box.y(), box.width(), box.height()],
+ self._config.shortcut_arrival_style)
+ else:
+ overlay.switched(logical_point(x, y), self._config.shortcut_arrival_style)
return
overlay = self._effect_overlay()
if overlay is not None:
- overlay.arrive(method, edge, logical_point(x, y))
+ if isinstance(overlay, EffectOverlayX11Proxy):
+ box = desktop_box()
+ overlay.arrive(method, edge, x, y, [box.x(), box.y(), box.width(), box.height()])
+ else:
+ overlay.arrive(method, edge, logical_point(x, y))
elif self.effects is not None:
self.effects.crossed_in()
@@ -3457,11 +4370,17 @@ class WindowsApplication(QWidget):
if self._closing or config is None or not config.edge_glow or not config.shortcut_arrival:
return None
if self.effects is None:
- self.effects = EffectOverlay(on_failure=self._on_effects_failed)
+ self.effects = (EffectOverlayX11Proxy(on_failure=self._on_effects_failed)
+ if xwayland_effects_available() else EffectOverlay(on_failure=self._on_effects_failed))
+ if isinstance(self.effects, EffectOverlayX11Proxy):
+ self.glow = self.effects
if self.effects.failed:
return None
- self.effects.configure(config.glow_style, config.glow_colour, config.effect_length, config.effect_size)
- if self.effects.failed or self.effects._fx is None:
+ self.effects.configure(config.glow_style, config.glow_colour, config.effect_length, config.effect_size,
+ config.effect_pace, config.effect_size_fraction)
+ ready = (self.effects.effect_ready if isinstance(self.effects, EffectOverlayX11Proxy)
+ else self.effects._fx is not None)
+ if self.effects.failed or not ready:
return None
return self.effects
@@ -3488,8 +4407,7 @@ class WindowsApplication(QWidget):
return
try:
self.tray.setIcon(QIcon(status_icon(state)))
- self.tray.setToolTip(self._title())
- self.status_action.setText(self._title())
+ self._refresh_tray_state()
except Exception:
LOGGER.exception("Tray status update failed")
# Re-read the firewall each time the receiver starts listening, never on a timer: a
@@ -3498,11 +4416,35 @@ class WindowsApplication(QWidget):
self._check_firewall()
self._last_seen_state = state
- def _refresh_window(self) -> None:
+ def _refresh_window(self, *, skip_hidden=False) -> None:
if self._closing:
return
+ try:
+ saved = self._window_settings()
+ except (ConfigError, OSError):
+ saved = {}
+ if saved is not getattr(self, "_tick_settings", None):
+ self._tick_settings = saved
+ self._refresh_peers()
+ self._reconcile_displays()
+ if skip_hidden and (not self.isVisible() or self.isMinimized()):
+ self._refresh_tray_state()
+ self._refresh_tray_directions()
+ self._refresh_tray_machines()
+ pause = "Resume crossing" if self.sender.crossing_paused else "Pause crossing"
+ if self.pause_action.text() != pause:
+ self.pause_action.setText(pause)
+ if self.pause_button.text() != pause:
+ self.pause_button.setText(pause)
+ widgets.set_role(self.pause_button, "primary" if self.sender.crossing_paused else "")
+ redirect = "Bring input back to this PC" if self.sender.redirecting else self._redirect_text()
+ if self.redirect_action.text() != redirect:
+ self.redirect_action.setText(redirect)
+ if self.redirect_button.full_text != redirect:
+ self.redirect_button.set_full_text(redirect)
+ self.redirect_action.setEnabled(self._config is not None and self._any_send())
+ return
self._show_same()
- self._settle_presence()
with self._status_lock:
state = self._status
detail = self._status_detail
@@ -3531,8 +4473,8 @@ class WindowsApplication(QWidget):
self.round_trip_readout.setText(trip_text)
self.round_trip_row.setVisible(trip is not None)
redirect_text = "Bring input back to this PC" if self.sender.redirecting else self._redirect_text()
- if redirect_text != self.redirect_button.text():
- self.redirect_button.setText(redirect_text)
+ if redirect_text != self.redirect_button.full_text:
+ self.redirect_button.set_full_text(redirect_text)
self.redirect_action.setText(redirect_text)
sending = self._config is not None and self._any_send()
self.redirect_button.setEnabled(sending)
@@ -3550,6 +4492,7 @@ class WindowsApplication(QWidget):
self.crossing_state.setText(sentence)
motion.fade_from(self.crossing_state, shot)
armed = args[4]
+ self._refresh_tray_state()
self.pause_button.setVisible(armed)
motion.set_shown(self.pause_row, armed or pages_win.crossing_state_blocked(*args[:4]))
# "On <machine>" above already says this while redirecting; the hint is for the rest --
@@ -3561,13 +4504,14 @@ class WindowsApplication(QWidget):
self.send_hint.setText(send_hint)
# Hidden while empty, or its spacing leaves a gap between the two switches.
self.send_hint.setVisible(bool(send_hint))
- self.sidebar.set_link(tone, SIDEBAR_LINK_WORDS.get(state, "Unknown"))
- self.sidebar.set_dots(pages_win.dots(self._config is None or not self._paired, self._firewall_tone))
+ response_peer, response_time, response_connected = self._header_response_time()
+ self.sidebar.set_link(tone, SIDEBAR_LINK_WORDS.get(state, "Unknown"), response_peer,
+ response_time, response_connected)
+ dormant = any(peerlist.dormant_reason(entry) for entry in self._peer_entries)
+ dots = pages_win.dots(self._config is None or not self._paired, self._firewall_tone, dormant)
+ self.sidebar.set_dots(dots)
self._peers_tick += 1
- if self._peers_tick % 4 == 0:
- self._refresh_peers()
- else:
- self._refresh_peer_states()
+ self._refresh_peer_states()
self._refresh_tray_directions()
self._refresh_tray_machines()
self._refresh_pairing()
@@ -3591,6 +4535,8 @@ def _windows_kernel32():
kernel32.CreateMutexW.argtypes = [ctypes.c_void_p, ctypes.c_int, ctypes.c_wchar_p]
kernel32.CloseHandle.argtypes = [ctypes.c_void_p]
kernel32.GetCurrentProcess.restype = ctypes.c_void_p
+ kernel32.GetCurrentProcessId.restype = ctypes.c_ulong
+ kernel32.ProcessIdToSessionId.argtypes = [ctypes.c_ulong, ctypes.POINTER(ctypes.c_ulong)]
kernel32.SetPriorityClass.argtypes = [ctypes.c_void_p, ctypes.c_ulong]
kernel32.SetProcessInformation.argtypes = [ctypes.c_void_p, ctypes.c_int, ctypes.c_void_p, ctypes.c_ulong]
return kernel32
@@ -3630,11 +4576,27 @@ def _claim_instance():
return lock.unlock if lock.tryLock(0) else None
+def activate_existing_instance(hidden: bool, activation_token: Optional[str] = None) -> bool:
+ if hidden:
+ return False
+ return send_instance_activation(activation_token=activation_token)
+
+
+def prepare_windows_startup() -> None:
+ if sys.platform == "win32":
+ autostart_win.migrate_legacy_task()
+
+
def main() -> None:
+ arguments = parse_args()
+ try:
+ prepare_windows_startup()
+ except OSError:
+ LOGGER.exception("Could not migrate the previous Windows sign-in task; keeping it for another attempt")
release = _claim_instance()
if release is None:
+ activate_existing_instance(arguments.hidden, os.environ.get("XDG_ACTIVATION_TOKEN"))
return
- arguments = parse_args()
log_path = configure_logging()
if log_path is not None:
crash_log.install(log_path.parent, LOGGER)
@@ -3652,18 +4614,28 @@ def main() -> None:
if not kernel32.SetPriorityClass(kernel32.GetCurrentProcess(), 0x8000): # ABOVE_NORMAL_PRIORITY_CLASS
LOGGER.warning("Could not raise Beamer's priority: %s", ctypes.WinError(ctypes.get_last_error()))
_stay_unthrottled(kernel32)
+ instance_signal = None
try:
app = QApplication(sys.argv)
app.setApplicationName("Beamer")
+ app.setDesktopFileName("uk.co.kalkman.beamer")
app.setQuitOnLastWindowClosed(False)
theme.init_fonts()
app.setFont(theme.font(theme.TYPE["body"]))
- application = WindowsApplication(arguments.config.expanduser().resolve())
- if not arguments.hidden:
+ application = WindowsApplication(
+ arguments.config.expanduser().resolve(), start_after_first_paint=not arguments.hidden
+ )
+ instance_signal = InstanceSignal(application.show_window, parent=app)
+ if not instance_signal.listening:
+ LOGGER.warning("Could not start the second-launch listener: %s", instance_signal.server.errorString())
+ if not arguments.hidden or not application.tray_available:
application.show()
- application.start()
+ if arguments.hidden:
+ QTimer.singleShot(0, application.start)
sys.exit(app.exec())
finally:
+ if instance_signal is not None:
+ instance_signal.close()
release()
@@ -3685,8 +4657,59 @@ def import_probe(out_path: str, names: list) -> int:
return 0
+def register_autostart_for_setup() -> int:
+ try:
+ exe = autostart_win.installed_exe()
+ if exe is None:
+ raise OSError("Only the installed Beamer app can start at sign-in")
+ autostart_win.set_enabled(True, exe)
+ except OSError as exc:
+ LOGGER.warning("Could not enable start at sign-in from setup: %s", exc)
+ return 1
+ return 0
+
+
+def cleanup_for_uninstall() -> int:
+ failed = False
+ exe = autostart_win.installed_exe()
+ if exe is None:
+ LOGGER.warning("Could not remove start-at-sign-in tasks outside the installed app")
+ failed = True
+ else:
+ try:
+ autostart_win.set_enabled(False, exe)
+ except OSError as exc:
+ LOGGER.warning("Could not remove the per-user logon task: %s", exc)
+ failed = True
+ try:
+ autostart_win.remove_legacy_task()
+ except OSError as exc:
+ LOGGER.warning("Could not remove the legacy logon task: %s", exc)
+ failed = True
+ for rule in (
+ "Beamer Receiver (TCP-In)",
+ "Beamer Pairing (UDP-In)",
+ "Beamer Pairing (TCP-In)",
+ ):
+ try:
+ result = autostart_win._run(
+ ["netsh", "advfirewall", "firewall", "delete", "rule", f"name={rule}"]
+ )
+ if result.returncode != 0:
+ LOGGER.warning("Could not remove firewall rule %s: %s", rule, result.stderr or result.stdout)
+ failed = True
+ except OSError as exc:
+ LOGGER.warning("Could not remove firewall rule %s: %s", rule, exc)
+ failed = True
+ return int(failed)
+
+
if __name__ == "__main__":
# Before the single-instance lock, so a Beamer already running does not turn the probe away.
if sys.argv[1:2] == ["--import-probe"]:
sys.exit(import_probe(sys.argv[2], sys.argv[3:]))
+ if sys.argv[1:2] == ["--enable-autostart"]:
+ sys.exit(register_autostart_for_setup())
+ if sys.argv[1:2] == ["--uninstall-cleanup"]:
+ sys.exit(cleanup_for_uninstall())
main()
diff --git a/win_app/linux_desktop.py b/win_app/linux_desktop.py
new file mode 100644
index 0000000..08852db
--- /dev/null
+++ b/win_app/linux_desktop.py
@@ -0,0 +1,14 @@
+"""Desktop identity for Linux-specific guidance and portal compatibility."""
+
+import os
+
+
+def desktop(environ=None) -> str:
+ environ = os.environ if environ is None else environ
+ value = environ.get("XDG_CURRENT_DESKTOP") or environ.get("XDG_SESSION_DESKTOP", "")
+ names = {name.strip().lower() for name in value.split(":")}
+ if names & {"kde", "plasma"}:
+ return "kde"
+ if "gnome" in names:
+ return "gnome"
+ return ""
diff --git a/win_app/machines_win.py b/win_app/machines_win.py
index 023dac5..6d93dec 100644
--- a/win_app/machines_win.py
+++ b/win_app/machines_win.py
@@ -4,12 +4,15 @@ them and gives each the one function it calls back."""
from __future__ import annotations
+import math
+import sys
from typing import Callable, Optional
-from PySide6.QtCore import QPointF, QRectF, QRegularExpression, QSize, Qt
+from PySide6.QtCore import QPointF, QRectF, QRegularExpression, QSize, Qt, Signal
from PySide6.QtGui import QColor, QFontMetricsF, QPainter, QPen, QRegularExpressionValidator
from PySide6.QtWidgets import (
QButtonGroup,
+ QCheckBox,
QBoxLayout,
QHBoxLayout,
QLabel,
@@ -57,13 +60,15 @@ class _PairCodeCells:
def _cell_rectangles(self) -> list[QRectF]:
metrics = QFontMetricsF(self.font())
- width = max(34.0, metrics.horizontalAdvance("0") + CODE_CELL_PAD_X * 2)
- height = min(max(40.0, metrics.height() + CODE_CELL_PAD_Y * 2), float(self.height()))
+ # Whole pixels: glyphs land on the pixel grid, so a fractional cell pitch walked each digit
+ # further off its cell's centre, up to a pixel and a half by the sixth (09-10-2026).
+ width = float(math.ceil(max(34.0, metrics.horizontalAdvance("0") + CODE_CELL_PAD_X * 2)))
+ height = min(float(math.ceil(max(40.0, metrics.height() + CODE_CELL_PAD_Y * 2))), float(self.height()))
advances = [width + CODE_CELL_GAP] * 6
advances[2] += CODE_GROUP_GAP
group_width = sum(advances) - CODE_CELL_GAP
- x = (self.width() - group_width) / 2
- y = (self.height() - height) / 2
+ x = float(round((self.width() - group_width) / 2))
+ y = float(round((self.height() - height) / 2))
cells = []
for index in range(6):
cells.append(QRectF(x, y, width, height))
@@ -73,16 +78,36 @@ class _PairCodeCells:
def digit_cells(self) -> list[QRectF]:
return [cell.adjusted(1, 1, -1, -1) for cell in self._cell_rectangles()]
+ def caret_rect(self, position: int) -> QRectF:
+ metrics = QFontMetricsF(self.font())
+ digits = "".join(character for character in self.text() if character.isdigit())[:CODE_DIGITS]
+ cells = self._cell_rectangles()
+ position = min(len(digits), max(0, position))
+ # In the cell the next digit lands in, the one painted with the signal border; only a full code
+ # puts it after the sixth digit. rc14 put it after the last digit, a cell behind (10-10-2026).
+ if position < CODE_DIGITS:
+ index = position
+ glyph = digits[index] if index < len(digits) else "0"
+ cursor_x = cells[index].center().x() - metrics.horizontalAdvance(glyph) / 2
+ else:
+ index = CODE_DIGITS - 1
+ cursor_x = cells[index].center().x() + metrics.horizontalAdvance(digits[index]) / 2
+ cell = cells[index]
+ return QRectF(cursor_x, cell.top() + 8, 1, max(0, cell.height() - 16))
+
def _paint_digits(self, painter: QPainter, text: str, selected: tuple[int, int] = (0, 0), focused: bool = False) -> None:
metrics = QFontMetricsF(self.font())
digits = "".join(character for character in text if character.isdigit())[:6]
cells = self._cell_rectangles()
inner = self.digit_cells()
start, length = selected
+ # The cell the caret is in: where the next digit goes, with the cursor moved back too.
+ current = min(5, len(digits), self.cursorPosition()) if focused else None
for index, (cell, ink_box) in enumerate(zip(cells, inner)):
painter.setBrush(QColor(theme.colour("ground")))
- painter.setPen(QPen(QColor(theme.colour("signal" if focused and index == min(5, len(digits)) else "edge")), 1))
- painter.drawRoundedRect(cell, 4, 4)
+ painter.setPen(QPen(QColor(theme.colour("signal" if index == current else "edge")), 1))
+ # Half a pixel in, so the 1 px border sits on whole pixels, inside the widget.
+ painter.drawRoundedRect(cell.adjusted(0.5, 0.5, -0.5, -0.5), 4, 4)
if start <= index < start + length:
painter.fillRect(ink_box, QColor(theme.colour("signal_dim")))
if index >= len(digits):
@@ -90,17 +115,13 @@ class _PairCodeCells:
character = digits[index]
bounds = metrics.tightBoundingRect(character)
centre = ink_box.center()
- baseline = QPointF(centre.x() - bounds.center().x(), centre.y() - bounds.center().y())
+ baseline = QPointF(round(centre.x() - bounds.center().x()), round(centre.y() - bounds.center().y()))
painter.setPen(QColor(theme.colour("ink")))
painter.drawText(baseline, character)
if focused and length == 0:
- index = min(5, max(0, self.cursorPosition()))
- cell = cells[index]
- cursor_x = cell.left() + (cell.width() + metrics.horizontalAdvance("0")) / 2
- if index < len(digits):
- cursor_x = cell.center().x() - metrics.horizontalAdvance(digits[index]) / 2
+ caret = self.caret_rect(self.cursorPosition())
painter.setPen(QPen(QColor(theme.colour("signal")), 1))
- painter.drawLine(QPointF(cursor_x, cell.top() + 8), QPointF(cursor_x, cell.bottom() - 8))
+ painter.drawLine(caret.topLeft(), caret.bottomLeft())
class PairCodeEdit(QLineEdit, _PairCodeCells):
@@ -115,6 +136,20 @@ class PairCodeEdit(QLineEdit, _PairCodeCells):
self._mouse_selecting = False
self._double_clicked = False
+ def inputMethodQuery(self, query, argument=None):
+ if query == Qt.InputMethodQuery.ImCursorRectangle:
+ return self.caret_rect(self.cursorPosition()).toRect()
+ if query == Qt.InputMethodQuery.ImAnchorRectangle:
+ position = self.cursorPosition()
+ if self.hasSelectedText():
+ start = self.selectionStart()
+ end = start + len(self.selectedText())
+ position = end if position == start else start
+ return self.caret_rect(position).toRect()
+ if argument is None:
+ return super().inputMethodQuery(query)
+ return super().inputMethodQuery(query, argument)
+
def paintEvent(self, event) -> None:
super().paintEvent(event)
painter = QPainter(self)
@@ -179,6 +214,22 @@ class PairCodeEdit(QLineEdit, _PairCodeCells):
self.setSelection(self._mouse_anchor, position - self._mouse_anchor)
+class RenameEdit(QLineEdit):
+ saved = Signal(str)
+ cancelled = Signal()
+
+ def keyPressEvent(self, event):
+ if event.key() == Qt.Key.Key_Escape:
+ self.cancelled.emit()
+ event.accept()
+ return
+ if event.key() in (Qt.Key.Key_Return, Qt.Key.Key_Enter):
+ self.saved.emit(self.text())
+ event.accept()
+ return
+ super().keyPressEvent(event)
+
+
class PairCodeLabel(QLabel, _PairCodeCells):
"""Read-only pairing digits in the same six-cell layout as the entry control."""
@@ -280,12 +331,19 @@ class PairCodeLabel(QLabel, _PairCodeCells):
class PeerRow(QWidget):
"""One paired machine: its name and state, use switch, direction disclosure and Remove."""
- def __init__(self, token: str, on_send: Callable, on_allow: Callable, on_in_use: Callable, on_remove: Callable) -> None:
+ def __init__(self, token: str, on_send: Callable, on_allow: Callable, on_in_use: Callable,
+ on_left_out: Callable, on_remove: Callable, on_rename: Optional[Callable] = None,
+ on_cycle: Optional[Callable] = None, on_repair: Optional[Callable] = None) -> None:
super().__init__()
self.setProperty("vernier", "plain")
self.token = token
+ self._left_out = False
self._phone = False
self._on_remove = on_remove
+ self._on_rename = on_rename or (lambda *_: None)
+ self._on_repair = on_repair or (lambda *_: None)
+ self._entry = {}
+ self._same_on = False
column = QVBoxLayout(self)
column.setContentsMargins(0, 0, 0, 8)
column.setSpacing(6)
@@ -304,17 +362,42 @@ class PeerRow(QWidget):
name_layout.addWidget(self.led, 0, Qt.AlignmentFlag.AlignVCenter)
self.name = widgets.label("", "tile-name", wrap=True)
name_layout.addWidget(self.name, 1)
+ self.rename_button = _button("Rename", "small")
+ self.rename_button.setMinimumWidth(self.rename_button.sizeHint().width())
+ self.rename_button.clicked.connect(self._begin_rename)
+ name_layout.addWidget(self.rename_button)
head.addWidget(name_line, 1)
+ self.rename_edit = RenameEdit()
+ self.rename_edit.saved.connect(self._save_rename)
+ self.rename_edit.cancelled.connect(self._cancel_rename)
+ self.rename_edit.setVisible(False)
+ self.rename_note = widgets.label("", "note-quiet", wrap=True)
+ self.rename_note.setVisible(False)
self.word = widgets.label("", "readout")
head.addWidget(self.word)
column.addLayout(head)
+ column.addWidget(self.rename_edit)
+ column.addWidget(self.rename_note)
self.where = widgets.label("", "note-quiet", wrap=True)
column.addWidget(self.where)
self.detail = widgets.label("", "note", wrap=True)
column.addWidget(self.detail)
+ self.repair_button = _button("Re-pair", "small")
+ self.repair_button.clicked.connect(lambda: self._on_repair(self.token))
+ column.addWidget(self.repair_button, 0, Qt.AlignmentFlag.AlignLeft)
+ self.left_out_note = widgets.label("Left out of the layout. The shortcut and the menu still reach it.",
+ "note-quiet", wrap=True)
+ self.left_out_note.setVisible(False)
+ column.addWidget(self.left_out_note)
+ self.shortcut_cycle = QCheckBox("In the shortcut's cycle")
+ self.shortcut_cycle.setVisible(False)
+ self.shortcut_cycle.toggled.connect(lambda enabled: (on_cycle or (lambda *_: None))(self._entry.get("id"), enabled))
+ column.addWidget(self.shortcut_cycle)
self.in_use = widgets.Switch("In use")
self.in_use.toggled.connect(lambda on: on_in_use(self.token, on))
self.in_use.setToolTip("Off on this PC: no input or settings link to this machine. Pairing, directions, ways and jump key are kept. Turn it back on here to reconnect.")
+ self.left_out = _button("Leave out", "small")
+ self.left_out.clicked.connect(lambda: on_left_out(self.token, not self._left_out))
self.send = widgets.Switch("This PC drives it")
self.send.setToolTip("Input moves only when this PC enables this switch and the other machine enables It drives this PC.")
self.allow = widgets.Switch("It drives this PC")
@@ -346,6 +429,7 @@ class PeerRow(QWidget):
controls.addStretch(1)
controls.addWidget(self.in_use)
controls.addWidget(self.directions)
+ controls.addWidget(self.left_out)
controls.addWidget(self.remove_button, 0, Qt.AlignmentFlag.AlignBottom)
self.controls = controls
column.addLayout(controls)
@@ -379,19 +463,62 @@ class PeerRow(QWidget):
self.head.setDirection(direction)
self.head.setAlignment(self.word, Qt.AlignmentFlag.AlignRight if wide else Qt.AlignmentFlag.AlignLeft)
self.controls.setDirection(direction)
- for control in (self.in_use, self.directions, self.remove_button):
+ for control in (self.in_use, self.directions, self.left_out, self.remove_button):
self.controls.setAlignment(control, Qt.AlignmentFlag.AlignRight if wide else Qt.AlignmentFlag.AlignLeft)
def _ask(self, asking: bool) -> None:
self.confirm.setVisible(asking)
self.remove_button.setVisible(not asking)
self.in_use.setVisible(not asking)
+ self.left_out.setVisible(not asking and not self._phone)
self.directions.setVisible(not asking and not self._phone)
self.direction_group.setVisible(not asking and not self._phone and self.directions.isChecked())
- def refresh(self, entry: dict, label: str, state, where: str) -> None:
- self._phone = entry.get("port") == 0
+ def _begin_rename(self) -> None:
+ self.rename_edit.setText(self._entry.get("label", "") or self._entry.get("name", ""))
+ self.name.setVisible(False)
+ self.rename_button.setVisible(False)
+ self.rename_edit.setVisible(True)
+ self.rename_note.setText("Only on this computer" if self._same_on is False and sys.platform.startswith("linux")
+ else "Only on this PC")
+ self.rename_note.setVisible(not self._same_on)
+ self.rename_edit.setFocus()
+ self.rename_edit.selectAll()
+
+ def _save_rename(self, text: str) -> None:
+ self._on_rename(self.token, text)
+ self._cancel_rename()
+
+ def _cancel_rename(self) -> None:
+ self.rename_edit.clearFocus()
+ self.rename_edit.setVisible(False)
+ self.rename_note.setVisible(False)
+ self.name.setVisible(True)
+ self.rename_button.setVisible(True)
+
+ def refresh(self, entry: dict, label: str, state, where: str, same_on: bool = False,
+ *, cycle_mode: str) -> None:
asking = self.confirm.isVisibleTo(self)
+ seen = (repr(entry), label, state, where, same_on, cycle_mode, asking, self.directions.isChecked())
+ if seen == getattr(self, "_refresh_seen", None):
+ return
+ self._refresh_seen = seen
+ self._phone = entry.get("port") == 0
+ self._entry = entry
+ self._same_on = same_on
+ self._left_out = entry.get("left_out") is True
+ dormant = peerlist.dormant_reason(entry) is not None
+ self.shortcut_cycle.setVisible(not self._phone and cycle_mode == "ticked")
+ self.shortcut_cycle.setEnabled(entry.get("in_use", True) is True and not dormant)
+ self.shortcut_cycle.blockSignals(True)
+ self.shortcut_cycle.setChecked(entry.get("shortcut_cycle", True))
+ self.shortcut_cycle.blockSignals(False)
+ self.repair_button.setVisible(dormant)
+ self.repair_button.setAccessibleName(f"Re-pair {label}")
+ self.left_out.setVisible(not self._phone and not asking)
+ self.left_out.setText("Put back" if self._left_out else "Leave out")
+ self.left_out.setAccessibleName(f"{'Put back' if self._left_out else 'Leave out'} {label}")
+ self.left_out_note.setVisible(self._left_out)
self.directions.setVisible(not self._phone and not asking)
self.direction_group.setVisible(not self._phone and not asking and self.directions.isChecked())
self.led.set_tone(state.tone)
@@ -417,9 +544,13 @@ class PeerRow(QWidget):
class MachinesModule(widgets.Module):
"""The paired machines, one row each, and the button that opens the pairing sheet."""
- def __init__(self, on_send: Callable, on_allow: Callable, on_in_use: Callable, on_remove: Callable, on_pair: Callable) -> None:
+ def __init__(self, on_send: Callable, on_allow: Callable, on_in_use: Callable, on_left_out: Callable,
+ on_remove: Callable, on_pair: Callable, on_rename: Optional[Callable] = None,
+ on_cycle: Optional[Callable] = None, on_repair: Optional[Callable] = None) -> None:
super().__init__("Machines")
- self._callbacks = (on_send, on_allow, on_in_use, on_remove)
+ self._callbacks = (on_send, on_allow, on_in_use, on_left_out, on_remove,
+ on_rename or (lambda *_: None), on_cycle,
+ on_repair or (lambda *_: None))
self.rows: dict = {}
self.rows_layout = QVBoxLayout()
self.rows_layout.setContentsMargins(0, 0, 0, 0)
@@ -431,7 +562,7 @@ class MachinesModule(widgets.Module):
self.empty = widgets.label(EMPTY, "note", wrap=True)
self.body.addWidget(self.empty)
- def set_peers(self, items: list) -> None:
+ def set_peers(self, items: list, same_on: bool = False, *, cycle_mode: str) -> None:
"""`items`: (entry, label, state, where) for each paired machine, in the order to show them."""
tokens = [entry["token"] for entry, *_ in items]
for token in [held for held in self.rows if held not in tokens]:
@@ -447,7 +578,7 @@ class MachinesModule(widgets.Module):
elif self.rows_layout.indexOf(row) != index:
self.rows_layout.removeWidget(row)
self.rows_layout.insertWidget(index, row)
- row.refresh(entry, label, state, where)
+ row.refresh(entry, label, state, where, same_on, cycle_mode=cycle_mode)
row.divider.setVisible(index > 0)
self.empty.setVisible(not items)
@@ -679,6 +810,14 @@ class PairingSheet(widgets.Module):
return None
def _pick(self, address: str) -> None:
+ button = next((candidate for candidate in self.group.buttons()
+ if candidate.property("address") == address), None)
+ self.group.setExclusive(False)
+ for candidate in self.group.buttons():
+ candidate.setChecked(False)
+ self.group.setExclusive(True)
+ if button is not None:
+ button.setChecked(True)
self.address.clear()
self._on_pick(next((item for item in self._machines if item["address"] == address), None))
self._refresh_pair_button()
diff --git a/win_app/motion.py b/win_app/motion.py
index d038a5e..f6bca16 100644
--- a/win_app/motion.py
+++ b/win_app/motion.py
@@ -126,7 +126,7 @@ def target_shown(widget: QWidget) -> bool:
return (not widget.isHidden()) if target is None else target
-def set_shown(widget: QWidget, shown: bool) -> None:
+def set_shown(widget: QWidget, shown: bool, *, fade: bool = True) -> None:
"""Shows or hides a row or module by sliding its height open or shut and fading it; the cap on
its height comes off at the end, so later layout is never held to the animated size."""
shown = bool(shown)
@@ -150,7 +150,8 @@ def set_shown(widget: QWidget, shown: bool) -> None:
stop(widget, "shown")
finish()
return
- fade = _fade_of(widget)
+ # Crossing rows uncover at full opacity: an opacity effect composites the whole subtree.
+ fade = _fade_of(widget) if fade else None
start_height = widget.height() if (moving or not widget.isHidden()) else 0
start_opacity = fade.opacity() if (fade is not None and moving) else (0.0 if shown else 1.0)
end_height = _natural_height(widget) if shown else 0
diff --git a/win_app/pages_win.py b/win_app/pages_win.py
index 45c6116..d76634a 100644
--- a/win_app/pages_win.py
+++ b/win_app/pages_win.py
@@ -6,6 +6,7 @@ Pure, so the rules are tested without Qt.
from __future__ import annotations
import re
+import threading
from core import effects
from core import peerlist
@@ -17,7 +18,7 @@ PAGES = (
"The machines paired with this PC, where input is right now, and the controls you reach for "
"every day. Pair a machine here first."),
("crossing", "Crossing",
- "Choose how the pointer or a key moves input to another machine, and how hard the edge "
+ "Choose how the pointer or a key moves input to each machine, and how hard the edge "
"pushes back first."),
("keyboard", "Keyboard",
"How this PC's Ctrl and Windows keys arrive on another machine, the keys and buttons that stay "
@@ -43,22 +44,76 @@ FOOTER_APPLY = "Changes apply as you make them."
FOOTER_TRAY = "Closing this window keeps Beamer running in the tray."
+class LinuxPermissionState:
+ """The two Wayland portal rows, independent of Qt and D-Bus."""
+
+ STATUSES = {"not_requested", "ready", "refused", "unavailable"}
+ DIRECTIONS = {"capture", "remote"}
+
+ def __init__(self) -> None:
+ self._lock = threading.RLock()
+ self._rows = {direction: ("not_requested", "", False) for direction in self.DIRECTIONS}
+ self._requesters = {}
+ self.on_change = None
+
+ def status(self, direction: str) -> tuple[str, str]:
+ with self._lock:
+ return self._rows[direction][:2]
+
+ def can_ask_again(self, direction: str) -> bool:
+ with self._lock:
+ return self._rows[direction][2]
+
+ def bind_requester(self, direction: str, request) -> None:
+ with self._lock:
+ self._requesters[direction] = request
+
+ def report(self, direction: str, status: str, detail: str = "", retryable: bool = False) -> None:
+ if direction not in self.DIRECTIONS or status not in self.STATUSES:
+ raise ValueError("Unknown Linux permission row or status")
+ value = (status, detail if status in ("refused", "unavailable") else "",
+ status == "refused" or retryable)
+ with self._lock:
+ self._rows[direction] = value
+ changed = self.on_change
+ if changed is not None:
+ changed(direction, *value)
+
+ def ask_again(self, direction: str) -> bool:
+ with self._lock:
+ if not self._rows[direction][2]:
+ return False
+ request = self._requesters.get(direction)
+ if request is None:
+ return False
+ self.report(direction, "not_requested")
+ request()
+ return True
+
+
+def linux_permissions_visible(platform: str, wayland: bool) -> bool:
+ return platform.startswith("linux") and wayland
+
+
def footer(page: str) -> str:
return FOOTER_TRAY if page == "connection" else f"{FOOTER_APPLY} {FOOTER_TRAY}"
-def dots(config_error: bool, firewall_tone: str | None) -> dict:
+def dots(config_error: bool, firewall_tone: str | None, dormant: bool = False) -> dict:
"""Page key to the tone of its sidebar dot, for the pages that need one.
`firewall_tone` is the note tone Connection's firewall module is already showing -- "note" is
its healthy end-state (the button just offers a manual re-check), so only "note-amber" and
"note-fault" earn a dot; a plain boolean would also mark the healthy state. Both problems sit
- on Connection, and a fault outranks amber."""
+ on Connection, and a fault outranks amber. A dormant pairing marks Overview and Crossing amber."""
+ marks = {}
if config_error or firewall_tone == "note-fault":
- return {"connection": "fault"}
- if firewall_tone == "note-amber":
- return {"connection": "amber"}
- return {}
+ marks["connection"] = "fault"
+ elif firewall_tone == "note-amber":
+ marks["connection"] = "amber"
+ if dormant:
+ marks.update({"overview": "amber", "crossing": "amber"})
+ return marks
# The Design page's styles and colours: Light first, then each crossing effects direction in
@@ -199,7 +254,7 @@ def crossing_state_blocked(paired, mac_heard, sending, connected) -> bool:
def crossing_rows(methods) -> frozenset:
- """Which of the Crossing page's rows the chosen ways use; the rest are hidden."""
+ """The Crossing rows used by these ways; the page may keep the drag guard visible but disabled."""
methods = set(methods)
rows = set()
# Where the Mac sits, which every way in uses: a crossing lands by it, and this PC's edge facing
@@ -220,7 +275,7 @@ def crossing_rows(methods) -> frozenset:
# stands in for Classic's Glow and Beam, which have no arrival of their own. Named as the Mac's is.
SIMPLE = "Simple"
SWITCH_SIMPLE = (
- ("match", "Same as crossing", "Plays the crossing style"),
+ ("match", "Same as crossing", "Plays Glow"),
("locator", "Ring", "Closes onto the pointer"),
)
@@ -239,7 +294,6 @@ SIDE_CHOICES = (("left", "Left"), ("right", "Right"), ("top", "Above"), ("bottom
# The ways in, as their rows read: the pointer's first, then the shortcut.
WAY_ROWS = (
("edge", "Edge", "One whole side"),
- ("part", "Part of the edge", "Only the thirds you pick"),
("corner", "Corner", "Push diagonally into a corner"),
("shortcut", "Shortcut", "Press a key to switch input"),
)
@@ -289,6 +343,38 @@ def ways_summary(methods, edge, parts, corner, key_name, style, name="the other
return f"Input moves to {name} when you {joined}.{after}"
+def ways_note(methods, edge, parts, corner, key_name, style, name, several=False) -> str:
+ methods = set(methods)
+ phrases = []
+ if "shortcut" in methods:
+ phrases.append(f"{'Hold' if style == 'hold' else 'Double-tap'} {key_name}")
+ pointer = []
+ if edge:
+ if "part" in methods:
+ pointer.append(parts_phrase(edge, parts))
+ elif "edge" in methods:
+ pointer.append(f"the {edge} edge")
+ if "corner" in methods:
+ pointer.append(f"the {(corner or 'top_right').replace('_', ' ')} corner")
+ if pointer:
+ joined = pointer[0] if len(pointer) == 1 else ", ".join(pointer[:-1]) + " or " + pointer[-1]
+ phrases.append(f"push through {joined}" + (f" to reach {name}" if several else ""))
+ sentence = ", or ".join(phrases)
+ return sentence[0].upper() + sentence[1:] + "." if sentence else "This PC is always in the shortcut's cycle."
+
+
+def shortcut_destination_note(mode: str, hold: bool) -> str:
+ if mode == "last":
+ note = "With Hold, input goes to the last machine."
+ elif hold:
+ note = "With Hold, input goes to the first ready machine in order."
+ else:
+ note = "The order follows the tiles from top to bottom, then left to right. This PC is always in the cycle."
+ if mode == "ticked":
+ note += " Choose which machines join the cycle with the tick boxes on their tiles."
+ return note
+
+
# The arrangement diagram. Each side of this PC has an angle, and a machine's screen travels round
# this PC's between them: through a corner position, never across it.
SIDE_ANGLE = {"right": 0.0, "top": 90.0, "left": 180.0, "bottom": 270.0}
diff --git a/win_app/peers_view.py b/win_app/peers_view.py
index 9ee8970..9c9b6ae 100644
--- a/win_app/peers_view.py
+++ b/win_app/peers_view.py
@@ -9,7 +9,7 @@ from __future__ import annotations
from dataclasses import dataclass
-from core import protocol
+from core import peerlist, protocol
PLATFORM_NAMES = {"macos": "Mac", "windows": "Windows", "linux": "Linux", "ios": "iPhone", "android": "Android"}
@@ -42,6 +42,9 @@ def describe(entry: dict, label: str, *, up: bool, driving: bool, input_there: b
"""`up`: a link to this machine is live, either way round. `driving`: its input is on this PC.
`input_there`: this PC's input is on it. `kind` and `status`: what the link this PC dials to it
last reported."""
+ reason = peerlist.dormant_reason(entry)
+ if reason:
+ return PeerState("amber", "Needs re-pair", reason)
if entry.get("in_use", True) is not True:
return PeerState("amber", "NOT IN USE", f"{label} is not in use on this PC.")
if driving:
diff --git a/win_app/renders/qt-pairing-dialog.png b/win_app/renders/qt-pairing-dialog.png
new file mode 100644
index 0000000..2be4532
Binary files /dev/null and b/win_app/renders/qt-pairing-dialog.png differ
diff --git a/win_app/requirements-win.txt b/win_app/requirements-win.txt
index 17ffc2b..9f901f2 100644
--- a/win_app/requirements-win.txt
+++ b/win_app/requirements-win.txt
@@ -2,4 +2,5 @@ PySide6-Essentials>=6.11.1
pyinstaller>=6.0
pyinstaller-hooks-contrib>=2024.1
PyNaCl>=1.6
+pywin32>=306
segno>=1.6
diff --git a/win_app/sender.py b/win_app/sender.py
index b02e742..44de7bf 100644
--- a/win_app/sender.py
+++ b/win_app/sender.py
@@ -32,6 +32,7 @@ from core import keytable
from core import owner as owner_module
from core import peerlist
from core import protocol
+from core import special_keys
from core import receiver
from core import return_edge
from core import ways
@@ -55,7 +56,7 @@ NOT_CONNECTED_STATUS = "Not connected"
# table takes the physical key, so the two are swapped back here.
PHYSICAL = {"cmd": "ctrl", "cmd_r": "ctrl_r", "ctrl": "cmd", "ctrl_r": "cmd_r"}
MEDIA_KEYS = frozenset(
- {"volume_mute", "volume_down", "volume_up", "media_next", "media_prev", "media_stop", "media_play_pause"}
+ {"volume_mute", "volume_down", "volume_up", "media_next", "media_prev", "media_stop", "media_play_pause", "brightness_up", "brightness_down"}
)
MODIFIER_KEYS = frozenset({"shift", "shift_r", "ctrl", "ctrl_r", "alt", "alt_r", "cmd", "cmd_r"})
# What this machine tells its peers it is (WIRE.md section 2); Linux and Windows read keys alike.
@@ -168,16 +169,21 @@ class LinkSender:
self._entries: list = [] # every entry, in the order the UI shows them
self._zone_list: list = []
self._models: list = [] # [(peer id, model)], this PC's zones in use
+ self._pressure_model = None
self._edge_cursor_error_logged = False
self._ignore_gate = ignored.Gate()
# The name a key went down under, by virtual key, so its release matches even when Shift or
# the style changes while it is held.
self._keys_down: dict = {}
+ self._pending_windows_key: Optional[int] = None
+ self._intent_keys_up: set = set()
+ self._intent_windows_up: set = set()
self._accepts: dict = {} # peer id: whether it lets this PC drive it
self._sent_names: dict = {} # (peer, physical key): the name its press went out under
self._buttons_held = set()
self._pin_point = None
self._monitors = None
+ self._display_map = {}
self._monitors_at = 0.0
self._clipboard_stamp = None
# The machine this PC's input last landed on, as an id text, for the shortcut's choice.
@@ -242,6 +248,13 @@ class LinkSender:
owner = self._owner
return owner.on if owner is not None else None
+ @property
+ def route_chain(self) -> tuple:
+ """The current route and any onward machine named by a refusal."""
+ with self._lock:
+ owner = self._owner
+ return owner.chain if owner is not None else ()
+
def expects_clipboard(self, link, began) -> bool:
"""For a link's `large` hook: whether a frame its peer began sending at `began` could be the
clipboard of a let-go."""
@@ -272,6 +285,50 @@ class LinkSender:
return protocol.read_id(ways.shortcut_peer(self._entries, self._last_on, ready))
+ def _cycle_order(self) -> list:
+ config = self._setting("layout", {}) or {}
+ own = protocol.id_text(self._own_id)
+ layout = ways.derive_layout({"machine_id": own, "peers": self._entries,
+ "zones": self._zone_list, "layout": config}, gap=0)
+ positions = {ident: (tile["x"], tile["y"], tile["w"], tile["h"])
+ for ident, tile in layout.items()}
+ return ways.shortcut_order(self._entries, own, positions,
+ self._setting("shortcut_goes_to", "last"))
+
+ def _cycle_target(self):
+ target, skipped = ways.next_target({"shortcut_goes_to": self._setting("shortcut_goes_to", "last")},
+ self._cycle_order(), protocol.peer_id_text(self.owner) if self.owner else None,
+ self._cycle_ready)
+ self._announce_shortcut_skips(skipped)
+ return protocol.read_id(target) if target is not None else None
+
+ def _cycle_ready(self, ident):
+ peer = protocol.read_id(ident)
+ return peer is not None and self.links.up(peer) and self._accepts.get(peer) is True
+
+ def _announce_shortcut_skips(self, skipped):
+ for ident in skipped:
+ self._alert(f"Skipped {peerlist.label_for(self._entries, peer_id=ident) or 'Other machine'}: not connected.")
+
+ def toggle_shortcut(self) -> None:
+ if self._setting("shortcut_goes_to", "last") == "last":
+ self.toggle()
+ return
+ target = self._cycle_target()
+ self.set_redirecting(target is not None, peer=target)
+
+ def hold_shortcut(self, down: bool) -> None:
+ if not down:
+ self.set_redirecting(False)
+ return
+ target, skipped = ways.hold_target(
+ {"shortcut_goes_to": self._setting("shortcut_goes_to", "last")},
+ self._cycle_order(), self._last_on,
+ self._cycle_ready)
+ self._announce_shortcut_skips(skipped)
+ target = protocol.read_id(target) if target else None
+ self.set_redirecting(target is not None, peer=target)
+
@property
def waking(self) -> bool:
return bool(self._waking)
@@ -449,10 +506,74 @@ class LinkSender:
if owner.away:
if not self._live():
self._lost()
- elif vk is not None and self._ignore_gate.keeps(ignored.key(vk), down):
+ return False
+ if vk is not None and self._ignore_gate.keeps(ignored.key(vk), down):
return False
elif vk is not None and not down:
self._ignore_gate.keeps(ignored.key(vk), False)
+ target = self._peers.get(owner.on) or {}
+ to_mac = not sys.platform.startswith("linux") and target.get("platform") == "macos"
+ to_linux = not sys.platform.startswith("linux") and target.get("platform") == "linux"
+ if vk in self._intent_windows_up:
+ if not down:
+ self._intent_windows_up.discard(vk)
+ return True
+ if vk in self._intent_keys_up:
+ if not down:
+ self._intent_keys_up.discard(vk)
+ return True
+ if vk in (0x5B, 0x5C) and (to_mac or to_linux):
+ if down:
+ self._keys_down[held] = self._key_data(name, us)
+ self._pending_windows_key = held
+ return True
+ if self._pending_windows_key == held:
+ self._pending_windows_key = None
+ self._input({"type": protocol.MSG_KEYDOWN, "data": dict(data)})
+ return self._input({"type": protocol.MSG_KEYUP, "data": dict(data)})
+ active_windows_key = self._pending_windows_key
+ if active_windows_key is None and to_mac:
+ active_windows_key = next((key for key in (0x5B, 0x5C) if key in self._keys_down), None)
+ if down and to_mac and active_windows_key is not None and vk is not None:
+ other_modifiers = {0x10, 0xA0, 0xA1, 0x11, 0xA2, 0xA3, 0x12, 0xA4, 0xA5, 0x5C}
+ other_modifiers.discard(active_windows_key)
+ intent = None if other_modifiers.intersection(self._keys_down) else special_keys.windows_shortcut_intent(name)
+ if intent is not None:
+ windows_key = active_windows_key
+ was_pending = self._pending_windows_key == windows_key
+ if was_pending:
+ self._pending_windows_key = None
+ else:
+ self._input({"type": protocol.MSG_KEYUP, "data": dict(self._keys_down[windows_key])})
+ self._keys_down.pop(windows_key, None)
+ self._intent_windows_up.add(windows_key)
+ self._intent_keys_up.add(vk)
+ if intent:
+ message = {"type": protocol.MSG_KEYDOWN, "data": {"key": intent}}
+ self._input(message)
+ return self._input(dict(message, type=protocol.MSG_KEYUP))
+ return True
+ pending_data = self._keys_down.get(self._pending_windows_key)
+ self._pending_windows_key = None
+ if pending_data is not None:
+ self._input({"type": protocol.MSG_KEYDOWN, "data": dict(pending_data)})
+ if down and to_linux and self._pending_windows_key is not None and vk is not None:
+ intent = {"s": "spotlight", "h": "", "n": ""}.get(name.lower())
+ if intent is not None:
+ windows_key = self._pending_windows_key
+ self._pending_windows_key = None
+ self._keys_down.pop(windows_key, None)
+ self._intent_windows_up.add(windows_key)
+ self._intent_keys_up.add(vk)
+ if intent:
+ message = {"type": protocol.MSG_KEYDOWN, "data": {"key": intent}}
+ self._input(message)
+ return self._input(dict(message, type=protocol.MSG_KEYUP))
+ return True
+ pending_data = self._keys_down.get(self._pending_windows_key)
+ self._pending_windows_key = None
+ if pending_data is not None:
+ self._input({"type": protocol.MSG_KEYDOWN, "data": dict(pending_data)})
return self._input({"type": protocol.MSG_KEYDOWN if down else protocol.MSG_KEYUP, "data": dict(data)})
def on_text(self, text: str, vk: Optional[int] = None) -> bool:
@@ -488,6 +609,17 @@ class LinkSender:
data["us"] = us
return data
+ def _send_pending_windows_key(self) -> None:
+ """The Windows key is held back until the next key says whether it begins a shortcut; a
+ mouse button or the wheel is not one, so the key goes ahead of it as the modifier it is."""
+ held = self._pending_windows_key
+ if held is None:
+ return
+ self._pending_windows_key = None
+ data = self._keys_down.get(held)
+ if data is not None:
+ self._input({"type": protocol.MSG_KEYDOWN, "data": dict(data)})
+
def on_button(self, name: str, down: bool) -> bool:
"""A mouse button, from the hook thread: True when it is not for this PC."""
if down:
@@ -504,6 +636,8 @@ class LinkSender:
return False
elif not down:
self._ignore_gate.keeps(ignored.button(name), False)
+ if down and owner.away:
+ self._send_pending_windows_key()
return self._input({"type": protocol.MSG_MOUSEDOWN if down else protocol.MSG_MOUSEUP, "data": {"button": name}})
def on_wheel(self, dy: float, dx: float) -> bool:
@@ -513,6 +647,7 @@ class LinkSender:
if not self._live():
self._lost()
return False
+ self._send_pending_windows_key()
return self._input(protocol.scroll_msg(dy, dx, "line"))
def on_pointer_move(self) -> bool:
@@ -580,8 +715,9 @@ class LinkSender:
return
self._edge_cursor_error_logged = False
outcome = model = target = None
+ display_map = self._cached_display_map()
for peer, candidate in list(self._models):
- result = candidate.feed(monitors, pointer, float(dx), float(dy))
+ result = candidate.feed(monitors, pointer, float(dx), float(dy), display_map=display_map)
if result.action != return_edge.PASS:
outcome, model, target = result, candidate, peer
break
@@ -597,12 +733,14 @@ class LinkSender:
elif isinstance(model, return_edge.CornerPush):
# The corner's name, so the effects play their corner forms; the glow lights the edge.
part = model.corner
+ self._pressure_model = model
self._notify_pressure(model.edge, outcome.pressure, outcome.action == return_edge.CROSS, part)
if outcome.action == return_edge.CROSS:
offset = receiver.corner_offset(model.corner, model.edge) if isinstance(model, return_edge.CornerPush) else outcome.offset
# The model names the edge on the far side, not the one just left: it is the same
- # border, read from the other end.
- self._go(target, outcome.edge, offset)
+ # border, read from the other end. The display it leads to lands the pointer there, as
+ # the Mac's own crossing does.
+ self._go(target, outcome.edge, offset, outcome.display, outcome.side)
def zone_models(self) -> list:
"""The models of this PC's ways out, where a desktop that captures input at barriers puts
@@ -611,6 +749,26 @@ class LinkSender:
return []
return [model for _peer, model in list(self._models)]
+ def seam_clip_position(self, x: int, y: int):
+ """Keep a local pointer on an armed display edge when it enters an adjacent display."""
+ if self.redirecting:
+ return None
+ models = self.zone_models()
+ if not models:
+ return None
+ monitors = self._cached_monitors()
+ display_map = {str(index): monitor for index, monitor in enumerate(monitors)}
+ from capture_win import internal_seam_position
+
+ return internal_seam_position((x, y), monitors, display_map, models)
+
+ def pressure_at(self, now: float | None = None) -> float:
+ """The active local way's pressure fraction at `now`, without advancing its model."""
+ model = self._pressure_model
+ if model is None:
+ return 0.0
+ return model.pressure_at(self._clock() if now is None else now)
+
def _still_dragging(self) -> bool:
"""A release the hook never saw -- let go over the secure desktop or an elevated window --
would otherwise hold the edge shut for good, so each button is asked of Windows again."""
@@ -625,13 +783,13 @@ class LinkSender:
# -- switching ----------------------------------------------------------
- def set_redirecting(self, value, came_home=True) -> bool:
+ def set_redirecting(self, value, came_home=True, peer=None) -> bool:
"""Moves this PC's input to the shortcut's machine, or home, as the shortcut, the Send button,
the tray and the direction switch do. False when nothing moved."""
if value:
if self.redirecting:
- return False
- peer = self.shortcut_target()
+ return self.go(peer) if peer is not None and peer != self.owner else False
+ peer = peer or self.shortcut_target()
if peer is None:
self._alert(f"Cannot switch — {self.status}")
return False
@@ -649,10 +807,11 @@ class LinkSender:
edge is off."""
self.set_redirecting(not self.redirecting)
- def go(self, peer: bytes, edge: Optional[str] = None, offset: Optional[float] = None) -> bool:
- return self._go(peer, edge, offset)
+ def go(self, peer: bytes, edge: Optional[str] = None, offset: Optional[float] = None,
+ display=None, side=None) -> bool:
+ return self._go(peer, edge, offset, display, side)
- def _go(self, peer: bytes, edge=None, offset=None) -> bool:
+ def _go(self, peer: bytes, edge=None, offset=None, display=None, side=None) -> bool:
owner = self._owner
if owner is None:
return False
@@ -663,11 +822,12 @@ class LinkSender:
if self.driven():
# A machine that is driven does not drive (section 4): its driver goes home first, then
# the move goes ahead. Waiting happens off this thread, which may be the hook's.
- threading.Thread(target=self._after_let_go, args=(peer, edge, offset), name="Beamer-links-home", daemon=True).start()
+ threading.Thread(target=self._after_let_go, args=(peer, edge, offset, display, side),
+ name="Beamer-links-home", daemon=True).start()
return True
with self._lock:
self._note_clipboard()
- actions = owner.go(peer, edge, offset)
+ actions = owner.go(peer, edge, offset, display=display, side=side)
self._queue(actions)
self._report(actions)
if owner.away and self.driven():
@@ -678,7 +838,7 @@ class LinkSender:
self._report(actions)
return owner.away
- def _after_let_go(self, peer, edge, offset) -> None:
+ def _after_let_go(self, peer, edge, offset, display=None, side=None) -> None:
if not self.send_peer_home() and self.driven():
self._alert(f"Cannot switch — {self._name(peer)} could not be reached while this PC is being driven")
return
@@ -686,7 +846,7 @@ class LinkSender:
while self.driven() and self._clock() < deadline and not self._stop_event.is_set():
time.sleep(0.02)
if not self.driven() and not self.redirecting:
- self._go(peer, edge, offset)
+ self._go(peer, edge, offset, display, side)
def set_receiving(self, receiving: bool) -> None:
"""A peer took this PC's input, or gave it back. Input cannot be here and elsewhere at
@@ -963,6 +1123,11 @@ class LinkSender:
def _send(self, peer: bytes, message: dict) -> None:
kind = message["type"]
+ if kind == protocol.MSG_KEYDOWN and message.get("data", {}).get("key") == "tab":
+ for transition in self._switcher_transition(peer):
+ if not self.links.send_input(peer, transition):
+ self._send_failed(peer)
+ return
if kind == protocol.MSG_FOCUS:
data = message["data"]
message = protocol.focus_v6(
@@ -981,6 +1146,13 @@ class LinkSender:
else:
self.links.post(peer, message)
+ def _switcher_transition(self, peer: bytes) -> list:
+ sent = {physical: name for (sent_peer, physical), name in self._sent_names.items() if sent_peer == peer}
+ messages, held_as = special_keys.switcher_transitions(OWN_PLATFORM, (self._peers.get(peer) or {}).get("platform", ""), sent)
+ for physical, name in held_as.items():
+ self._sent_names[(peer, physical)] = name
+ return messages
+
def _key_message(self, peer: bytes, message: dict, preserve: bool = False) -> Optional[dict]:
"""The key as `peer` is sent it: named by the key table for the peer's platform and the
user's style, and dropped when the peer does not take media keys."""
@@ -994,16 +1166,24 @@ class LinkSender:
name = self._sent_names[held]
elif message["type"] == protocol.MSG_KEYUP and held in self._sent_names:
# The release leaves under the name its press went under, whatever the style says now.
- name = self._sent_names.pop(held)
+ sent = {key: sent_name for (sent_peer, key), sent_name in self._sent_names.items() if sent_peer == peer}
+ name = special_keys.release_key(physical, sent)
+ self._sent_names.pop(held)
+ if name is None:
+ return None
elif message["type"] == protocol.MSG_KEYDOWN and held in self._sent_names:
# So does each auto-repeat of it.
name = self._sent_names[held]
else:
style = self._setting("modifier_style", "semantic")
try:
- name = keytable.wire_name(physical, OWN_PLATFORM, entry.get("platform") or "", style)
+ peer_platform = entry.get("platform") or ""
+ name = keytable.wire_name(physical, OWN_PLATFORM, peer_platform, style)
+ name = special_keys.wire_name(name, OWN_PLATFORM, peer_platform)
except ValueError:
name = physical
+ if name is None:
+ return None
if message["type"] == protocol.MSG_KEYDOWN:
self._sent_names[held] = name
return {"type": message["type"], "data": dict(data, key=name)}
@@ -1074,10 +1254,14 @@ class LinkSender:
# of deltas still in flight cannot cross twice, and nothing else re-arms it.
with self._lock:
self._arm_locked()
+ if moved.edge in return_edge.EDGES:
+ # Landed by a crossing: the push that brought it here does not carry on through a zone.
+ for _peer, model in self._models:
+ model.start_grace()
LOGGER.info("input returned to this PC (%s)%s", moved.why, _at_edge(moved.edge))
self._report_redirecting(False)
if moved.edge in return_edge.EDGES and isinstance(moved.offset, (int, float)):
- self._land(moved.edge, moved.offset)
+ self._land(moved.edge, moved.offset, moved.display, moved.side)
elif moved.why in ("asked", "switch"):
self._report_arrival(None)
else:
@@ -1089,12 +1273,14 @@ class LinkSender:
reason = HOME_REASONS.get(moved.why, "{name} returned the input").format(name=self._name(moved.left))
self._alert(reason)
- def _land(self, edge: str, offset: float) -> None:
+ def _land(self, edge: str, offset: float, display=None, side=None) -> None:
"""The peer pushed the pointer back through its zone: land it on the edge of this PC it comes
back to."""
try:
desktop = self._desktop_module()
- x, y = return_edge.arrival_position(self._cached_monitors(), edge, offset)
+ display_map = getattr(desktop, "display_map", lambda: {})()
+ x, y = return_edge.arrival_position(self._cached_monitors(), edge, offset,
+ display, side, display_map)
desktop.set_cursor_position(x, y)
except Exception:
LOGGER.exception("Could not place the pointer at the %s edge on arrival", edge)
@@ -1224,15 +1410,18 @@ class LinkSender:
"""A fresh set of zone models, for the peers this PC can send to now (never the one its input
is on: that peer's own zones lead on from there)."""
owner = self._owner
+ self._pressure_model = None
if owner is None:
self._models = []
return
allowed = set(owner.reach_for(None))
self._armed_for = frozenset(allowed)
try:
+ previous = self._models
self._models = receiver.zone_models(
self._zone_list, self._entries, allowed, self._resistance(), None,
)
+ return_edge.keep_grace(previous, self._models)
except Exception:
LOGGER.exception("Could not arm the zones")
self._models = []
@@ -1288,10 +1477,18 @@ class LinkSender:
def _cached_monitors(self):
now = self._clock()
if self._monitors is None or now - self._monitors_at > MONITORS_MAX_AGE_SECONDS:
- self._monitors = self._desktop_module().monitors()
+ desktop = self._desktop_module()
+ self._monitors = desktop.monitors()
+ # The keys the map's display-scoped zones name, read with the monitors they describe.
+ reader = getattr(desktop, "display_map", None)
+ self._display_map = reader() if callable(reader) else {}
self._monitors_at = now
return self._monitors
+ def _cached_display_map(self):
+ self._cached_monitors()
+ return self._display_map
+
def _desktop_module(self):
if self._desktop is not None:
return self._desktop
diff --git a/win_app/tests/display_map_fixture.py b/win_app/tests/display_map_fixture.py
new file mode 100644
index 0000000..730e551
--- /dev/null
+++ b/win_app/tests/display_map_fixture.py
@@ -0,0 +1,10 @@
+"""Display fixtures shared by the matrix runner and cache-specific tests."""
+
+import kvm_bridge_win
+
+
+refresh_own_displays = kvm_bridge_win.WindowsApplication._refresh_own_displays
+
+
+def display_fields(window):
+ return {"display": "0"} if window._own_displays() else {}
diff --git a/win_app/tests/render_settings_layout.py b/win_app/tests/render_settings_layout.py
index 1f745e9..7a2353d 100644
--- a/win_app/tests/render_settings_layout.py
+++ b/win_app/tests/render_settings_layout.py
@@ -33,7 +33,7 @@ from test_settings_layout_acceptance import SyntheticWindow, write_synthetic_set
WIDTHS = (320, 640, 900, 1440, 1920)
SCALES = ("1.0", "1.25", "1.5", "2.0")
HEIGHT = 900
-OUT = Path(os.environ.get("BEAMER_RENDER_OUT", ROOT / "renders"))
+OUT = Path(os.environ.get("BEAMER_RENDER_OUT", ROOT / "win_app" / "renders"))
def capture_document(page):
@@ -260,6 +260,88 @@ def run_matrix():
raise SystemExit(1)
+def run_crossing_state(state, destination):
+ """Build the seven review states from valid saved settings in a fresh Qt process."""
+ import tempfile
+ import app_config
+ from core import crossing_state, protocol
+ from core.tests import responder_harness as harness
+
+ if state not in range(1, 8):
+ raise ValueError("crossing state must be 1..7")
+ app = QApplication.instance() or QApplication([])
+ theme.init_fonts()
+ app.setFont(theme.font(theme.TYPE["body"]))
+ scratch = ROOT / "win_app" / ".test-tmp"
+ scratch.mkdir(parents=True, exist_ok=True)
+ with tempfile.TemporaryDirectory(prefix=f"ledger-state-{state}-", dir=scratch) as working:
+ own = protocol.id_text(harness.HERE)
+ first, second, third = (protocol.id_text(peer) for peer in (harness.B, harness.C, harness.D))
+ peer_ids = [second] if state in (2, 3) else [first, second, third] if state == 6 else [first]
+ all_peers = {first: harness.entry(harness.B, "MacBook Pro", platform="macos"),
+ second: harness.entry(harness.C, "Fedora laptop", platform="linux"),
+ third: harness.entry(harness.D, "Studio PC", platform="windows", shortcut_cycle=False)}
+ settings = app_config.migrate(None, machine_id=own)
+ settings.update(appearance="dark", name="Desktop PC", check_updates=False,
+ port=harness.free_port(), shortcut_goes_to="ticked",
+ peers=[all_peers[peer] for peer in peer_ids])
+ settings["layout"] = {own: {"x": 0, "y": 0, "w": 160, "h": 100}}
+ positions = {first: (0, -100), second: (-160, 0), third: (160, 0)}
+ for peer in peer_ids:
+ x, y = positions[peer]
+ settings["layout"][peer] = {"x": x, "y": y, "w": 160, "h": 100}
+ for peer in peer_ids:
+ thirds = ["start", "end"] if state == 3 else ["middle"] if state == 6 and peer == second else list(("start", "middle", "end"))
+ corner = "top_left" if state in (4, 7) else "bottom_left" if state == 6 and peer == second else ""
+ settings = crossing_state.edit_ways(settings, peer, platform="pc", edge=state != 5,
+ thirds=thirds, corner=bool(corner),
+ corner_at=corner or None,
+ live=lambda _peer: True, gone=lambda _peer: False,
+ capable=peer_ids, now=1791619200)["settings"]
+ if state == 6:
+ next(entry for entry in settings["peers"] if entry["id"] == second)["jump_key"] = "alt+f18"
+ path = Path(working) / "settings.json"
+ app_config.write_settings(path, settings)
+ window = SyntheticWindow(path)
+ window.full_screen_timer.stop()
+ window.refresh_timer.stop()
+ window._live = lambda peer: state != 6 or peer != third
+ window._design_peer_caps = lambda: {peer: {"layout"} for peer in peer_ids}
+ window._chosen = peer_ids[0]
+ window._reflect_ways()
+ window.setAttribute(Qt.WidgetAttribute.WA_DontShowOnScreen, True)
+ window.setAttribute(Qt.WidgetAttribute.WA_ShowWithoutActivating, True)
+ width, height = (640, 600) if state == 7 else (960, 760)
+ window.resize(width, height)
+ window.show()
+ window._select_page("crossing")
+ settle(app)
+ scroll = window.stack.currentWidget()
+ chrome = window.height() - scroll.viewport().height()
+ window.resize(width, scroll.widget().sizeHint().height() + chrome + 2)
+ settle(app)
+ destination = Path(destination)
+ destination.parent.mkdir(parents=True, exist_ok=True)
+ raster = window.grab().toImage()
+ if raster.isNull() or not raster.save(str(destination)):
+ raise RuntimeError(f"could not save built Crossing state {destination}")
+ record = {"state": state, "file": str(destination), "size": [raster.width(), raster.height()],
+ "ledger_narrow": window.crossing_ledger.narrow,
+ "map_height": window.atlas_canvas.height(),
+ "hint_gap": (window.atlas_canvas_hint.mapTo(window.ways_module, QPoint()).y()
+ - window.atlas_canvas.mapTo(window.ways_module, QPoint(0, window.atlas_canvas.height())).y()),
+ "horizontal_scroll": scroll.horizontalScrollBar().maximum(),
+ "rows": [{"name": row.name.full_text, "status": row.status.text(),
+ "edge": row.edge_value.text(), "corner": row.corner_value.text(),
+ "jump": row.jump.value} for row in window.crossing_ledger.rows.values()]}
+ (scratch / f"ledger-render-{state}.json").write_text(json.dumps(record, indent=2) + "\n")
+ print(json.dumps(record))
+ window.server.stop()
+ window.close()
+ window.deleteLater()
+ settle(app)
+
+
def comparison_sheets(qt_root):
mac_root = ROOT.parent / "laymac" / "renders"
app = QApplication.instance() or QApplication([])
@@ -304,7 +386,9 @@ def run_test_suite(selectors=()):
if __name__ == "__main__":
- if len(sys.argv) == 2 and sys.argv[1] == "--matrix":
+ if len(sys.argv) == 4 and sys.argv[1] == "--crossing-state":
+ run_crossing_state(int(sys.argv[2]), sys.argv[3])
+ elif len(sys.argv) == 2 and sys.argv[1] == "--matrix":
run_matrix()
elif len(sys.argv) == 3 and sys.argv[1] == "--compare":
comparison_sheets(Path(sys.argv[2]))
diff --git a/win_app/tests/run_display_map.py b/win_app/tests/run_display_map.py
new file mode 100644
index 0000000..31c05d8
--- /dev/null
+++ b/win_app/tests/run_display_map.py
@@ -0,0 +1,41 @@
+"""Run one Qt test module with a deterministic PC display cache."""
+
+import argparse
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+from unittest.mock import patch
+
+
+def main():
+ parser = argparse.ArgumentParser(description=__doc__)
+ parser.add_argument("display_map", choices=("empty", "windows"))
+ parser.add_argument("module", help="Discovery pattern, e.g. test_pages_win.py")
+ parser.add_argument("--verbose", action="store_true")
+ args = parser.parse_args()
+ app_dir = Path(__file__).resolve().parents[1]
+ sys.path.insert(0, str(app_dir))
+ sys.path.insert(1, str(app_dir / "tests"))
+ temp_dir = app_dir / ".test-tmp"
+ temp_dir.mkdir(parents=True, exist_ok=True)
+ tempfile.tempdir = str(temp_dir)
+
+ import kvm_bridge_win
+ import display_map_fixture
+ from core import return_edge
+
+ def refresh(window):
+ window._own_display_map = (
+ {"0": return_edge.Rect(0, 0, 1920, 1080)}
+ if args.display_map == "windows" else {}
+ )
+
+ with patch.object(kvm_bridge_win.WindowsApplication, "_refresh_own_displays", refresh):
+ suite = unittest.defaultTestLoader.discover(str(app_dir / "tests"), pattern=args.module)
+ result = unittest.TextTestRunner(verbosity=2 if args.verbose else 1).run(suite)
+ return 0 if result.wasSuccessful() else 1
+
+
+if __name__ == "__main__":
+ sys.exit(main())
diff --git a/win_app/tests/test_app_config.py b/win_app/tests/test_app_config.py
index d6e575c..98db5df 100644
--- a/win_app/tests/test_app_config.py
+++ b/win_app/tests/test_app_config.py
@@ -9,7 +9,8 @@ import sys
sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
import app_config
-from core import protocol
+from core import protocol, ways
+from core.tests import responder_harness as h
from dataclasses import replace
from app_config import ConfigError, config_from_dict, config_to_dict, default_config
@@ -29,6 +30,41 @@ class EdgeGlowConfigTests(unittest.TestCase):
with self.assertRaises(ConfigError):
config_from_dict({**BASE, "edge_glow": "yes"})
+
+class OverlappingZonesTests(unittest.TestCase):
+ def _legacy_contacts(self):
+ own, a, b = (protocol.id_text(peer) for peer in (h.HERE, h.B, h.C))
+ settings = app_config.migrate(None, machine_id=own)
+ settings["peers"] = [h.entry(h.B, "Studio", side="right"), h.entry(h.C, "Laptop", side="right")]
+ settings["zones"] = [{"peer": a, "kind": "edge"}, {"peer": b, "kind": "edge"}]
+ settings["layout"] = {own: dict(x=0, y=0, w=100, h=100),
+ a: dict(x=100, y=0, w=100, h=50),
+ b: dict(x=100, y=50, w=100, h=50)}
+ return settings
+
+ def test_overlapping_legacy_choices_load_as_intent_and_contact_zones(self):
+ with tempfile.TemporaryDirectory() as folder:
+ path = Path(folder) / "settings.json"
+ app_config.write_settings(path, self._legacy_contacts())
+ saved = app_config.load_settings(path)
+ self.assertTrue(all(peer["ways"]["edge"] for peer in saved["peers"]))
+ self.assertIsNone(ways._clashing(saved))
+ self.assertEqual({zone["peer"] for zone in saved["zones"]},
+ {protocol.id_text(h.B), protocol.id_text(h.C)})
+
+ def test_inactive_peer_zones_do_not_refuse_the_settings_file(self):
+ for inactive in ({"in_use": False}, {"left_out": True}):
+ with self.subTest(inactive=inactive):
+ settings = self._legacy_contacts()
+ settings["peers"][0].update(inactive)
+ with tempfile.TemporaryDirectory() as folder:
+ path = Path(folder) / "settings.json"
+ app_config.write_settings(path, settings)
+ saved = app_config.load_settings(path)
+ self.assertTrue(saved["peers"][0]["ways"]["edge"])
+ self.assertFalse(any(zone["peer"] == protocol.id_text(h.B) for zone in saved["zones"]))
+ self.assertIsNone(ways._clashing(saved))
+
def test_showing_where_the_pointer_lands_is_on_for_an_old_config_and_round_trips_off(self):
self.assertTrue(config_from_dict(dict(BASE)).shortcut_arrival)
config = config_from_dict({**BASE, "shortcut_arrival": False})
diff --git a/win_app/tests/test_appearance_contrast.py b/win_app/tests/test_appearance_contrast.py
index 810373c..328ab0b 100644
--- a/win_app/tests/test_appearance_contrast.py
+++ b/win_app/tests/test_appearance_contrast.py
@@ -63,6 +63,8 @@ class AppearanceContrast(unittest.TestCase):
cls.window = SyntheticWindow(write_synthetic_settings(Path(cls.folder.name)))
cls.window.full_screen_timer.stop()
cls.window.refresh_timer.stop()
+ cls.window._live = lambda _peer: True
+ cls.window._reflect_ways()
cls.window.setAttribute(Qt.WidgetAttribute.WA_DontShowOnScreen, True)
cls.window.setAttribute(Qt.WidgetAttribute.WA_ShowWithoutActivating, True)
cls.window.resize(WIDTH, 900)
diff --git a/win_app/tests/test_arrangement.py b/win_app/tests/test_arrangement.py
index 78219ae..e644f02 100644
--- a/win_app/tests/test_arrangement.py
+++ b/win_app/tests/test_arrangement.py
@@ -29,6 +29,8 @@ class Folder(unittest.TestCase):
harness.entry(B, "Mac", side="left", side_set_at=100, side_by=LOW),
harness.entry(C, "Other", platform="windows", side="top"),
]
+ for entry in settings["peers"]:
+ entry["caps"] = []
settings["zones"] = [
{"peer": BT, "kind": "edge"},
{"peer": BT, "kind": "corner", "corner": "top_left", "edge": "left", "off": True},
@@ -65,15 +67,15 @@ class ArrangementTests(Folder):
self.assertEqual(app_config.apply_arrangement(self.path, BT, "up", 200, HIGH), (False, []))
self.assertEqual(app_config.apply_arrangement(self.path, BT, "left", 200, "not an id"), (False, []))
- def test_a_side_that_clashes_with_another_peers_zone_turns_the_senders_zone_off_and_says_so(self):
+ def test_old_peer_arrangement_compiles_one_side_allocation_without_clash_notices(self):
changed, notices = app_config.apply_arrangement(self.path, BT, "bottom", 200, HIGH)
self.assertTrue(changed)
self.assertEqual(self.peer(BT)["side"], "top")
zones = [zone for zone in self.saved()["zones"] if zone["peer"] == BT and zone["kind"] == "edge"]
- self.assertTrue(zones[0]["off"])
- self.assertTrue(notices and "Mac" in notices[0] and "Other" in notices[0])
- other = [zone for zone in self.saved()["zones"] if zone["peer"] == CT][0]
- self.assertNotIn("off", other)
+ self.assertEqual(zones, [{"peer": BT, "kind": "edge"}])
+ self.assertEqual(notices, [])
+ self.assertFalse(any(zone["peer"] == CT for zone in self.saved()["zones"]))
+ self.assertTrue(self.peer(CT)["ways"]["edge"])
class LearnedTests(Folder):
diff --git a/win_app/tests/test_atlas_canvas.py b/win_app/tests/test_atlas_canvas.py
new file mode 100644
index 0000000..30216e1
--- /dev/null
+++ b/win_app/tests/test_atlas_canvas.py
@@ -0,0 +1,302 @@
+import os
+import sys
+import unittest
+from pathlib import Path
+
+
+os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+
+class AtlasCanvasTests(unittest.TestCase):
+ def setUp(self):
+ from PySide6.QtWidgets import QApplication
+
+ self.app = QApplication.instance() or QApplication([])
+
+ def test_this_pc_tile_shows_platform_and_linked_status(self):
+ import sys
+
+ from diagram import AtlasCanvas
+
+ canvas = AtlasCanvas()
+ self.addCleanup(canvas.deleteLater)
+ canvas.set_tiles({"home": {"x": 0, "y": 0, "w": 160, "h": 100}},
+ {"home": "This PC"}, {}, "home", own_id="home")
+
+ state = canvas.states["home"]
+ self.assertEqual(state["detail"], "Linux" if sys.platform.startswith("linux") else "Windows")
+ self.assertTrue(state["linked"])
+
+ def test_this_pc_tile_keeps_its_machine_name_as_the_own_tile_detail(self):
+ from diagram import AtlasCanvas
+
+ canvas = AtlasCanvas()
+ self.addCleanup(canvas.deleteLater)
+ canvas.set_tiles({"home": {"x": 0, "y": 0, "w": 160, "h": 100}},
+ {"home": "This PC"}, {"home": {"detail": "Studio PC"}}, "home", own_id="home")
+
+ self.assertEqual(canvas.states["home"]["detail"], "Studio PC")
+
+ def test_this_pc_name_is_painted_over_its_display_boxes(self):
+ from PySide6.QtCore import Qt
+ from PySide6.QtGui import QColor, QImage
+
+ from diagram import AtlasCanvas
+ import theme
+
+ canvas = AtlasCanvas()
+ self.addCleanup(canvas.deleteLater)
+ canvas.resize(480, 268)
+ canvas.set_tiles({"home": {"x": 0, "y": 0, "w": 160, "h": 100,
+ "displays": {"main": {"x": 0, "y": 0, "w": 1728, "h": 1117}}}},
+ {"home": "This PC"}, {"home": {"state": "this"}}, "home", own_id="home")
+ image = QImage(canvas.size(), QImage.Format.Format_ARGB32)
+ image.fill(Qt.GlobalColor.transparent)
+ canvas.render(image)
+
+ rect = canvas.tile_rect("home")
+ ink = QColor(theme.colour("ink"))
+ visible_ink = any(
+ (lambda pixel: abs(pixel.red() - ink.red()) < 24 and abs(pixel.green() - ink.green()) < 24
+ and abs(pixel.blue() - ink.blue()) < 24)(image.pixelColor(x, y))
+ for y in range(max(0, int(rect.top()) + 6), min(image.height(), int(rect.top()) + 30))
+ for x in range(max(0, int(rect.left()) + 20), min(image.width(), int(rect.right()) - 20)))
+ self.assertTrue(visible_ink)
+
+ def test_drag_compiles_layout_and_refuses_overlap_at_nearest_free_snap(self):
+ from PySide6.QtCore import QPoint, Qt
+ from PySide6.QtTest import QTest
+
+ from diagram import AtlasCanvas
+ from core import ways
+
+ drops = []
+ settings = {"machine_id": "home", "peers": [{"id": "peer", "side": "right"}], "zones": []}
+
+ def compile_drop(tiles, moved):
+ result = ways.compile_layout(settings, tiles, moved=moved)
+ refused = result
+ if not result["accepted"]:
+ tiles[moved] = result["snap"][moved]
+ result = ways.compile_layout(settings, tiles)
+ drops.append((tiles, moved, result, refused))
+
+ canvas = AtlasCanvas(on_drop=compile_drop)
+ self.addCleanup(canvas.deleteLater)
+ canvas.resize(720, 300)
+ canvas.set_tiles({"home": {"x": 0, "y": 0, "w": 160, "h": 100},
+ "peer": {"x": 172, "y": 0, "w": 160, "h": 100}},
+ {"home": "This PC", "peer": "Studio PC"}, {"peer": {"state": "edge"}},
+ "home")
+ canvas.show()
+ self.app.processEvents()
+ start = canvas.tile_rect("peer").center().toPoint()
+ QTest.mousePress(canvas, Qt.MouseButton.LeftButton, pos=start)
+ QTest.mouseMove(canvas, start + QPoint(-120, 0), 10)
+ QTest.mouseRelease(canvas, Qt.MouseButton.LeftButton, pos=start + QPoint(-120, 0))
+ self.assertEqual(len(drops), 1)
+ self.assertEqual(drops[0][1], "peer")
+ self.assertTrue(drops[0][2]["accepted"])
+ self.assertFalse(drops[0][3]["accepted"])
+ self.assertFalse(ways._overlaps(drops[0][0]["peer"], drops[0][0]["home"]))
+ self.assertEqual(drops[0][0]["peer"], drops[0][3]["snap"]["peer"])
+
+ def test_alt_click_splits_a_display_and_drag_moves_only_that_display(self):
+ from PySide6.QtCore import QPoint, Qt
+ from PySide6.QtTest import QTest
+
+ from diagram import AtlasCanvas
+
+ drops = []
+ canvas = AtlasCanvas(on_drop=lambda tiles, moved: drops.append((tiles, moved)))
+ self.addCleanup(canvas.deleteLater)
+ canvas.resize(720, 300)
+ canvas.set_tiles({
+ "home": {"x": 0, "y": 0, "w": 160, "h": 100},
+ "peer": {"x": 172, "y": 0, "w": 160, "h": 100,
+ "displays": {"left": {"x": 0, "y": 0, "w": 100, "h": 100},
+ "right": {"x": 100, "y": 0, "w": 100, "h": 100}}},
+ }, {"home": "This PC", "peer": "Studio"}, {"peer": {"state": "edge"}}, "home")
+ canvas.show()
+ self.app.processEvents()
+
+ point = canvas.display_rect("peer", "right").center().toPoint()
+ QTest.mouseClick(canvas, Qt.MouseButton.LeftButton, Qt.KeyboardModifier.AltModifier, pos=point)
+ self.assertIn("right", canvas.tiles["peer"]["display_offsets"])
+ self.assertEqual(drops[-1][1], "peer")
+
+ before_tile = dict(canvas.tiles["peer"])
+ point = canvas.display_rect("peer", "right").center().toPoint()
+ QTest.mousePress(canvas, Qt.MouseButton.LeftButton, pos=point)
+ QTest.mouseMove(canvas, point + QPoint(40, 0), 10)
+ QTest.mouseRelease(canvas, Qt.MouseButton.LeftButton, pos=point + QPoint(40, 0))
+ self.assertEqual(canvas.tiles["peer"]["x"], before_tile["x"])
+ self.assertGreater(canvas.tiles["peer"]["display_offsets"]["right"]["x"], 0)
+
+ def test_arrow_moves_focused_tile_a_third_and_announces_sentence(self):
+ from PySide6.QtCore import Qt
+ from PySide6.QtTest import QTest
+
+ from diagram import AtlasCanvas
+
+ canvas = AtlasCanvas()
+ canvas.resize(720, 300)
+ canvas.set_tiles({"home": {"x": 0, "y": 0, "w": 160, "h": 100},
+ "peer": {"x": 172, "y": 0, "w": 160, "h": 100}},
+ {"home": "This PC", "peer": "Studio PC"},
+ {"peer": {"state": "edge", "announcement": "Crosses on the right."}}, "peer")
+ self.addCleanup(canvas.deleteLater)
+ canvas.show()
+ canvas.setFocus()
+ QTest.keyClick(canvas, Qt.Key.Key_Down)
+ self.assertEqual(canvas.tiles["peer"]["y"], 33)
+ self.assertIn("Studio PC, right of This PC, bottom third.", canvas.accessibleDescription())
+
+ def test_rename_cancel_and_save_actions(self):
+ from PySide6.QtCore import Qt
+ from PySide6.QtTest import QTest
+
+ from diagram import AtlasCanvas
+
+ renamed = []
+ canvas = AtlasCanvas(on_rename=lambda peer, name: renamed.append((peer, name)))
+ self.addCleanup(canvas.deleteLater)
+ canvas.resize(720, 300)
+ canvas.set_tiles({"home": {"x": 0, "y": 0, "w": 160, "h": 100},
+ "peer": {"x": 172, "y": 0, "w": 160, "h": 100}},
+ {"home": "This PC", "peer": "Studio PC"}, {"peer": {"state": "edge"}}, "home")
+ canvas.begin_rename("peer")
+ canvas.rename_edit.setText("Studio")
+ QTest.keyClick(canvas.rename_edit, Qt.Key.Key_Escape)
+ self.assertEqual(renamed, [])
+ canvas.begin_rename("peer")
+ canvas.rename_edit.setText("Studio")
+ QTest.keyClick(canvas.rename_edit, Qt.Key.Key_Return)
+ self.assertEqual(renamed, [("peer", "Studio")])
+
+ def test_clearing_a_rename_restores_the_machine_name(self):
+ from PySide6.QtCore import Qt
+ from PySide6.QtTest import QTest
+
+ from diagram import AtlasCanvas
+
+ renamed = []
+ canvas = AtlasCanvas(on_rename=lambda peer, name: renamed.append((peer, name)))
+ self.addCleanup(canvas.deleteLater)
+ canvas.resize(720, 300)
+ canvas.set_tiles({"home": {"x": 0, "y": 0, "w": 160, "h": 100},
+ "peer": {"x": 172, "y": 0, "w": 160, "h": 100}},
+ {"home": "This PC", "peer": "Studio PC"}, {"peer": {"state": "edge"}}, "home")
+ canvas.begin_rename("peer")
+ canvas.rename_edit.clear()
+ QTest.keyClick(canvas.rename_edit, Qt.Key.Key_Return)
+
+ self.assertEqual(renamed, [("peer", "")])
+
+ def test_leave_out_and_put_back_move_the_machine_between_canvas_and_shelf(self):
+ from diagram import AtlasCanvas
+
+ calls = []
+ canvas = AtlasCanvas(on_leave_out=lambda peer, left: calls.append((peer, left)))
+ self.addCleanup(canvas.deleteLater)
+ canvas.set_tiles({"home": {"x": 0, "y": 0, "w": 160, "h": 100},
+ "peer": {"x": 172, "y": 0, "w": 160, "h": 100}},
+ {"home": "This PC", "peer": "Studio PC"}, {"peer": {"state": "edge"}}, "home")
+ canvas.set_left_out({"peer"}, {"peer": True})
+ self.assertIn("peer", canvas.shelf_ids)
+ canvas.put_back("peer")
+ self.assertEqual(calls, [("peer", False)])
+
+ def test_not_in_use_machines_are_shelved_without_becoming_left_out(self):
+ from diagram import AtlasCanvas
+
+ canvas = AtlasCanvas()
+ self.addCleanup(canvas.deleteLater)
+ canvas.set_tiles({"home": {"x": 0, "y": 0, "w": 160, "h": 100},
+ "peer": {"x": 172, "y": 0, "w": 160, "h": 100}},
+ {"home": "This PC", "peer": "Studio PC"}, {"peer": {"state": "edge"}}, "peer")
+ canvas.set_left_out(set(), {"peer": False})
+
+ self.assertIn("peer", canvas.shelf_ids)
+ self.assertNotIn("peer", canvas.left_out_ids)
+
+ def test_shelf_tiles_cannot_be_hit_or_renamed_on_the_canvas(self):
+ from PySide6.QtCore import Qt
+ from PySide6.QtTest import QTest
+ from diagram import AtlasCanvas
+
+ canvas = AtlasCanvas()
+ self.addCleanup(canvas.deleteLater)
+ canvas.resize(720, 300)
+ canvas.set_tiles({"home": {"x": 0, "y": 0, "w": 160, "h": 100},
+ "peer": {"x": 0, "y": 0, "w": 160, "h": 100}},
+ {"home": "This PC", "peer": "Shelf"}, {}, "home", own_id="home")
+ canvas.set_left_out({"peer"})
+ canvas.show()
+ point = canvas.tile_rect("peer").center().toPoint()
+ QTest.mouseClick(canvas, Qt.MouseButton.LeftButton, pos=point)
+ self.assertIsNone(canvas._drag)
+ self.assertEqual(canvas.selected, "home")
+ QTest.mouseDClick(canvas, Qt.MouseButton.LeftButton, pos=point)
+ self.assertIsNone(canvas._rename_peer)
+
+ def test_drag_keeps_the_map_transform_until_release(self):
+ from PySide6.QtCore import QPoint, Qt
+ from PySide6.QtTest import QTest
+ from diagram import AtlasCanvas
+
+ canvas = AtlasCanvas()
+ self.addCleanup(canvas.deleteLater)
+ canvas.resize(360, 268)
+ canvas.set_tiles({"home": {"x": 0, "y": 0, "w": 160, "h": 100},
+ "peer": {"x": 160, "y": 0, "w": 160, "h": 100}},
+ {"home": "This PC", "peer": "Peer"}, {}, "peer", own_id="home")
+ canvas.show()
+ point = canvas.tile_rect("peer").center().toPoint()
+ scale, origin = canvas._scale, canvas._origin
+ QTest.mousePress(canvas, Qt.MouseButton.LeftButton, pos=point)
+ QTest.mouseMove(canvas, point + QPoint(80, 0))
+ self.assertEqual(canvas._scale, scale)
+ self.assertEqual(canvas._origin, origin)
+ self.assertTrue(canvas.hasMouseTracking())
+
+ def test_pressing_this_machine_never_changes_the_selected_peer(self):
+ from PySide6.QtCore import Qt
+ from PySide6.QtTest import QTest
+
+ from diagram import AtlasCanvas
+
+ selected = []
+ canvas = AtlasCanvas(on_select=selected.append)
+ self.addCleanup(canvas.deleteLater)
+ canvas.resize(720, 300)
+ canvas.set_tiles({"home": {"x": 0, "y": 0, "w": 160, "h": 100},
+ "peer": {"x": 172, "y": 0, "w": 160, "h": 100}},
+ {"home": "This PC", "peer": "Studio PC"}, {"peer": {"state": "edge"}}, "peer",
+ own_id="home")
+ canvas.show()
+ self.app.processEvents()
+ QTest.mouseClick(canvas, Qt.MouseButton.LeftButton, pos=canvas.tile_rect("home").center().toPoint())
+
+ self.assertEqual(canvas.selected, "peer")
+ self.assertEqual(selected, [])
+
+ def test_shortcut_mode_and_tile_cycle_ticks_persist(self):
+ from diagram import AtlasCanvas
+ from widgets import Choice
+
+ ticks = []
+ modes = []
+ canvas = AtlasCanvas(on_cycle=lambda peer, enabled: ticks.append((peer, enabled)))
+ self.addCleanup(canvas.deleteLater)
+ canvas.set_tiles({"home": {"x": 0, "y": 0, "w": 160, "h": 100},
+ "peer": {"x": 172, "y": 0, "w": 160, "h": 100}},
+ {"home": "This PC", "peer": "Studio PC"}, {"peer": {"state": "edge"}}, "home",
+ cycle_mode="ticked")
+ canvas.set_cycle("peer", False)
+ self.assertEqual(ticks, [("peer", False)])
+ choice = Choice((("last", "Last machine"), ("next", "Next in order"),
+ ("ticked", "Next among ticked")), 3, "last", on_change=modes.append)
+ choice._buttons["ticked"].click()
+ self.assertEqual(modes, ["ticked"])
diff --git a/win_app/tests/test_atlas_crossing_colours.py b/win_app/tests/test_atlas_crossing_colours.py
new file mode 100644
index 0000000..d6a1ba0
--- /dev/null
+++ b/win_app/tests/test_atlas_crossing_colours.py
@@ -0,0 +1,127 @@
+import os
+import sys
+import unittest
+from pathlib import Path
+from unittest import mock
+
+os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+
+class AtlasCrossingColoursTests(unittest.TestCase):
+ def setUp(self):
+ from PySide6.QtWidgets import QApplication
+ import diagram
+
+ self.app = QApplication.instance() or QApplication([])
+ self.canvas = diagram.AtlasCanvas()
+ self.addCleanup(self.canvas.deleteLater)
+ self.canvas.resize(720, 268)
+ self.canvas.set_tiles(
+ {"home": {"x": 80, "y": 50, "w": 160, "h": 100},
+ "peer": {"x": 240, "y": 50, "w": 160, "h": 100}},
+ {"home": "This PC", "peer": "Studio PC"},
+ {"peer": {"state": "edge", "crosses": True, "linked": True}},
+ "peer", own_id="home")
+
+ def painted_tiles(self):
+ from PySide6.QtGui import QPen
+ import diagram
+
+ painter = mock.Mock()
+ borders = []
+ pen = None
+
+ def set_pen(value):
+ nonlocal pen
+ pen = value
+
+ def rounded_rect(rect, *_args):
+ if isinstance(pen, QPen):
+ borders.append((rect, pen.color(), pen.widthF()))
+
+ painter.setPen.side_effect = set_pen
+ painter.drawRoundedRect.side_effect = rounded_rect
+ with mock.patch.object(diagram, "QPainter", return_value=painter):
+ self.canvas.paintEvent(None)
+ return borders, painter
+
+ def test_selected_and_own_tile_borders_are_neutral(self):
+ import diagram
+
+ borders, _painter = self.painted_tiles()
+ for key, role, width in (("peer", "ink_2", 2), ("home", "edge", 1)):
+ border = next(item for item in borders if item[0] == self.canvas.tile_rect(key))
+ self.assertEqual(border[1], diagram._colour(role))
+ self.assertNotEqual(border[1], diagram._colour("signal"))
+ self.assertEqual(border[2], width)
+
+ def test_crossing_peer_has_crosses_foot_in_signal(self):
+ import diagram
+
+ for state in ("edge", "part", "corner"):
+ with self.subTest(state=state):
+ self.canvas.states["peer"] = {"state": state, "crosses": True}
+ _borders, painter = self.painted_tiles()
+ calls = painter.method_calls
+ foot_index = next(index for index, call in enumerate(calls)
+ if call[0] == "drawText" and call[1][-1] == "Crosses")
+ pen = next(call[1][0] for call in reversed(calls[:foot_index]) if call[0] == "setPen")
+ self.assertEqual(pen, diagram._colour("signal"))
+
+ def test_peer_without_a_crossing_has_no_crosses_foot(self):
+ for crosses in ({}, {"crosses": False}):
+ with self.subTest(crosses=crosses):
+ self.canvas.states["peer"] = {"state": "edge", **crosses}
+ _borders, painter = self.painted_tiles()
+ feet = [call.args[-1] for call in painter.drawText.call_args_list]
+ self.assertIn("Edge off", feet)
+ self.assertNotIn("Crosses", feet)
+
+ def test_outcome_rule_matches_the_mac_for_disabled_and_indirect_crossings(self):
+ import diagram
+
+ for state, crosses, own, name, expected in (
+ ("edge", True, False, "", "Crosses"),
+ ("edge", False, False, "", "Edge off"),
+ ("gap", True, False, "", "Drag to connect"),
+ ("between", False, False, "Studio", "Crosses to Studio"),
+ ("between", False, False, "", "Set elsewhere"),
+ ("set-elsewhere", False, False, "Studio", "Set on Studio"),
+ ("set_elsewhere", False, False, "Studio", "Set on Studio"),
+ ("edge", True, True, "", "")):
+ with self.subTest(state=state, crosses=crosses, own=own, name=name):
+ self.assertEqual(diagram.outcome_for_tile(state, crosses, own, name), expected)
+
+ def test_contact_is_four_pixels_with_round_caps_and_two_pixel_insets(self):
+ from PySide6.QtCore import Qt
+
+ canvas = self.canvas
+ painter = mock.Mock()
+ own = canvas.tiles["home"]
+ rect = canvas.tile_rect("home")
+ canvas._paint_contact(painter, own, rect, ("right", 50, 150))
+ pen = painter.setPen.call_args.args[0]
+ self.assertEqual(pen.widthF(), 4)
+ self.assertEqual(pen.capStyle(), Qt.PenCapStyle.RoundCap)
+ start, end = painter.drawLine.call_args.args
+ self.assertEqual(start.x(), rect.right())
+ self.assertEqual(end.x(), rect.right())
+ self.assertEqual(start.y(), rect.top() + 2)
+ self.assertEqual(end.y(), rect.bottom() - 2)
+
+ def test_corner_crossing_dot_has_seven_pixel_diameter(self):
+ painter = mock.Mock()
+ self.canvas._paint_contact(painter, self.canvas.tiles["home"],
+ self.canvas.tile_rect("home"), ("corner", "top_right", ""))
+ self.assertEqual(painter.drawEllipse.call_args.args[1:], (3.5, 3.5))
+
+ def test_rendered_seam_is_distinct_from_selected_border(self):
+ import diagram
+
+ image = self.canvas.grab().toImage()
+ seam = self.canvas.tile_rect("home")
+ x, y = round(seam.right()), round(seam.center().y())
+ self.assertEqual(image.pixelColor(x, y), diagram._colour("signal"))
+ self.assertEqual(image.pixelColor(x - 1, y), diagram._colour("signal"))
+ self.assertNotEqual(image.pixelColor(x + 3, y), diagram._colour("signal"))
diff --git a/win_app/tests/test_atlas_map_feel.py b/win_app/tests/test_atlas_map_feel.py
new file mode 100644
index 0000000..41399a6
--- /dev/null
+++ b/win_app/tests/test_atlas_map_feel.py
@@ -0,0 +1,98 @@
+import os
+import sys
+import unittest
+from pathlib import Path
+from unittest import mock
+
+os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+
+class AtlasMapFeelTests(unittest.TestCase):
+ def setUp(self):
+ from PySide6.QtWidgets import QApplication
+ from diagram import AtlasCanvas
+
+ self.app = QApplication.instance() or QApplication([])
+ self.drops = mock.Mock()
+ self.canvas = AtlasCanvas(on_drop=self.drops)
+ self.addCleanup(self.canvas.deleteLater)
+ self.canvas.resize(720, 268)
+ self.canvas.set_tiles(
+ {"home": {"x": 80, "y": 50, "w": 160, "h": 100},
+ "peer": {"x": 240, "y": 72, "w": 120, "h": 60}},
+ {"home": "This PC", "peer": "Studio PC"},
+ {"peer": {"state": "edge", "crosses": True}}, "peer", own_id="home")
+
+ def test_arrangement_box_centres_and_refits_after_a_peer_moves(self):
+ canvas = self.canvas
+ def box():
+ rects = [canvas.tile_rect(peer) for peer in canvas.tiles]
+ left, top = min(rect.left() for rect in rects), min(rect.top() for rect in rects)
+ right, bottom = max(rect.right() for rect in rects), max(rect.bottom() for rect in rects)
+ return left, top, right, bottom
+
+ before = box()
+ self.assertAlmostEqual((before[0]+before[2])/2, canvas.width()/2)
+ self.assertAlmostEqual((before[1]+before[3])/2, canvas.height()/2)
+ self.assertAlmostEqual(canvas._scale, min((canvas.width()-24)/280, (canvas.height()-24)/100, 1.0))
+ before_scale = canvas._scale
+ canvas.tiles["peer"].update(x=500, y=280)
+ canvas._geometry()
+ after = box()
+ self.assertNotEqual(after, before)
+ self.assertAlmostEqual((after[0]+after[2])/2, canvas.width()/2)
+ self.assertAlmostEqual((after[1]+after[3])/2, canvas.height()/2)
+ self.assertNotEqual(canvas._scale, before_scale)
+ canvas._drag = "peer"
+ frozen = (canvas.tile_rect("home"), canvas._scale)
+ canvas.tiles["peer"].update(x=-400, y=-250)
+ canvas._geometry()
+ self.assertEqual((canvas.tile_rect("home"), canvas._scale), frozen)
+
+ def test_recentre_places_peer_and_commits_once(self):
+ canvas = self.canvas
+ self.assertFalse(canvas.recentre_button.isHidden())
+ self.assertEqual(canvas.recentre_button.accessibleName(), "Recentre Studio PC")
+ canvas.recentre_button.click()
+ self.assertEqual(canvas.tiles["peer"], {"x": 240, "y": 70, "w": 120, "h": 60})
+ self.drops.assert_called_once()
+ layout, peer = self.drops.call_args.args
+ self.assertEqual(peer, "peer")
+ self.assertEqual(layout[peer], canvas.tiles[peer])
+ self.assertTrue(canvas.recentre_button.isHidden())
+
+ def test_preview_exists_only_within_the_release_radius_and_leaves_tile_at_pointer(self):
+ canvas = self.canvas
+ canvas._drag = "peer"
+ canvas.tiles["peer"].update(x=256, y=70)
+ dropped = dict(canvas.tiles["peer"])
+ self.assertEqual(canvas.snap_preview(), {"x": 240, "y": 70, "w": 120, "h": 60})
+ self.assertEqual(canvas.tiles["peer"], dropped)
+ canvas.tiles["peer"]["x"] = 259
+ self.assertIsNone(canvas.snap_preview())
+ canvas._drag_display = "screen"
+ canvas.tiles["peer"]["x"] = 240
+ self.assertIsNone(canvas.snap_preview())
+
+ def test_c_key_recentres(self):
+ from PySide6.QtCore import QEvent, Qt
+ from PySide6.QtGui import QKeyEvent
+
+ event = QKeyEvent(QEvent.Type.KeyPress, Qt.Key.Key_C, Qt.KeyboardModifier.NoModifier, "c")
+ self.canvas.keyPressEvent(event)
+ self.assertEqual(self.canvas.tiles["peer"]["y"], 70)
+ self.drops.assert_called_once()
+
+ def test_release_commits_the_preview_with_the_larger_centre_radius(self):
+ from PySide6.QtCore import QPointF
+
+ canvas = self.canvas
+ canvas._drag = "peer"
+ canvas.tiles["peer"].update(x=256, y=70)
+ target = canvas.snap_preview()
+ event = mock.Mock()
+ event.position.return_value = QPointF(400, 150)
+ canvas.mouseReleaseEvent(event)
+ self.drops.assert_called_once()
+ self.assertEqual(self.drops.call_args.args[0]["peer"], target)
diff --git a/win_app/tests/test_audit_regressions.py b/win_app/tests/test_audit_regressions.py
index 514bba0..fe1cb2b 100644
--- a/win_app/tests/test_audit_regressions.py
+++ b/win_app/tests/test_audit_regressions.py
@@ -14,7 +14,7 @@ ROOT = Path(__file__).resolve().parents[2]
class PageAuditRegressions(unittest.TestCase):
@classmethod
def setUpClass(cls):
- output = ROOT / "renders" / "regressions"
+ output = ROOT / "win_app" / "renders" / "regressions"
output.mkdir(parents=True, exist_ok=True)
cls.directory = tempfile.TemporaryDirectory(dir=output)
cls.addClassCleanup(cls.directory.cleanup)
diff --git a/win_app/tests/test_autostart_win.py b/win_app/tests/test_autostart_win.py
index 12b6e53..169a68f 100644
--- a/win_app/tests/test_autostart_win.py
+++ b/win_app/tests/test_autostart_win.py
@@ -1,6 +1,8 @@
import subprocess
import unittest
import xml.etree.ElementTree as ET
+from pathlib import Path
+from unittest.mock import patch
import autostart_win
@@ -10,21 +12,23 @@ EXE = r"C:\Users\alex\AppData\Local\Beamer\Beamer.exe"
class FakeSchtasks:
def __init__(self, exists=False, fail=None):
- self.exists = exists
+ self.tasks = {"Beamer"} if exists else set()
self.fail = fail
self.calls = []
self.xml = None
def __call__(self, args):
self.calls.append(args[1])
+ name = args[args.index("/tn") + 1] if "/tn" in args else "Beamer"
if args[1] == "/create" and self.fail is None:
with open(args[args.index("/xml") + 1], encoding="utf-16") as handle:
self.xml = handle.read()
- self.exists = True
+ self.tasks.add(name)
if args[1] == "/delete" and self.fail is None:
- self.exists = False
+ self.tasks.discard(name)
if args[1] == "/query":
- return subprocess.CompletedProcess(args, 0 if self.exists else 1, "", "")
+ xml = autostart_win.task_xml(EXE, r"STUDIO-PC\alex")
+ return subprocess.CompletedProcess(args, 0 if name in self.tasks else 1, xml, "")
return subprocess.CompletedProcess(args, 1 if self.fail else 0, "", self.fail or "")
@@ -33,6 +37,7 @@ class TaskXmlTests(unittest.TestCase):
root = ET.fromstring(autostart_win.task_xml(EXE, r"STUDIO-PC\alex").replace('encoding="UTF-16"', ""))
self.assertEqual(root.find("t:Actions/t:Exec/t:Command", NS).text, EXE)
self.assertEqual(root.find("t:Actions/t:Exec/t:Arguments", NS).text, "--hidden")
+ self.assertEqual(root.find("t:Principals/t:Principal/t:UserId", NS).text, r"STUDIO-PC\alex")
self.assertEqual(root.find("t:Principals/t:Principal/t:RunLevel", NS).text, "HighestAvailable")
self.assertEqual(root.find("t:Settings/t:ExecutionTimeLimit", NS).text, "PT0S")
self.assertEqual(root.find("t:Triggers/t:LogonTrigger/t:UserId", NS).text, r"STUDIO-PC\alex")
@@ -42,25 +47,83 @@ class TaskXmlTests(unittest.TestCase):
class SwitchTests(unittest.TestCase):
+ def test_empty_session_identity_is_reported_as_unavailable(self):
+ with patch.object(autostart_win, "_session_value", side_effect=["", ""]):
+ with self.assertRaisesRegex(OSError, "signed-in account"):
+ autostart_win.current_user()
+
def test_on_then_off(self):
fake = FakeSchtasks()
- autostart_win.set_enabled(True, EXE, user="u", run=fake)
+ with patch.object(autostart_win, "can_run_for_current_user", return_value=True):
+ autostart_win.set_enabled(True, EXE, user="STUDIO-PC\\alex", run=fake)
self.assertIn("--hidden", fake.xml)
- self.assertTrue(autostart_win.is_enabled(fake))
- autostart_win.set_enabled(False, EXE, run=fake)
- self.assertFalse(autostart_win.is_enabled(fake))
+ self.assertTrue(autostart_win.is_enabled(fake, "STUDIO-PC\\alex"))
+ autostart_win.set_enabled(False, EXE, user="STUDIO-PC\\alex", run=fake)
+ self.assertFalse(autostart_win.is_enabled(fake, "STUDIO-PC\\alex"))
def test_off_when_absent_touches_nothing(self):
fake = FakeSchtasks()
- autostart_win.set_enabled(False, EXE, run=fake)
- self.assertEqual(fake.calls, ["/query"])
+ autostart_win.set_enabled(False, EXE, user="u", run=fake)
+ self.assertEqual(fake.calls, ["/query", "/query"])
def test_refusal_is_raised(self):
fake = FakeSchtasks(fail="ERROR: Access is denied.")
- with self.assertRaises(OSError) as caught:
- autostart_win.set_enabled(True, EXE, user="u", run=fake)
+ with patch.object(autostart_win, "can_run_for_current_user", return_value=True):
+ with self.assertRaises(OSError) as caught:
+ autostart_win.set_enabled(True, EXE, user="u", run=fake)
self.assertIn("Access is denied", str(caught.exception))
+ def test_task_name_is_scoped_to_the_signed_in_user(self):
+ self.assertEqual(autostart_win.task_name("STUDIO-PC\\alex"), "Beamer-STUDIO-PC-alex")
+
+ def test_refuses_silent_elevation_for_another_users_session(self):
+ fake = FakeSchtasks()
+ with patch.object(autostart_win, "can_run_for_current_user", return_value=False):
+ with self.assertRaisesRegex(OSError, "administrator account"):
+ autostart_win.set_enabled(True, EXE, user="STUDIO-PC\\alex", run=fake)
+ self.assertEqual(fake.calls, [])
+
+ def test_uninstall_removes_the_legacy_global_task(self):
+ fake = FakeSchtasks(exists=True)
+ autostart_win.remove_legacy_task(fake)
+ self.assertEqual(fake.calls, ["/query", "/delete"])
+
+ def test_uninstall_leaves_an_absent_legacy_global_task_alone(self):
+ fake = FakeSchtasks()
+ autostart_win.remove_legacy_task(fake)
+ self.assertEqual(fake.calls, ["/query"])
+
+ def test_reading_the_switch_migrates_the_legacy_task_before_reporting_state(self):
+ fake = FakeSchtasks(exists=True)
+ with patch.object(autostart_win, "installed_exe", return_value=EXE), patch.object(autostart_win, "can_run_for_current_user", return_value=True):
+ self.assertTrue(autostart_win.is_enabled(fake, "STUDIO-PC\\alex"))
+ self.assertNotIn("Beamer", fake.tasks)
+ self.assertLess(fake.calls.index("/create"), fake.calls.index("/delete"))
+
+ def test_enabling_startup_replaces_the_legacy_task_instead_of_adding_a_second(self):
+ fake = FakeSchtasks(exists=True)
+ with patch.object(autostart_win, "can_run_for_current_user", return_value=True):
+ autostart_win.set_enabled(True, EXE, user="STUDIO-PC\\alex", run=fake)
+ self.assertEqual(fake.tasks, {autostart_win.task_name("STUDIO-PC\\alex")})
+
+
+class InstallerTests(unittest.TestCase):
+ def test_inno_setup_uses_the_checked_app_helper_for_start_at_sign_in(self):
+ setup = (Path(__file__).parents[1] / "Beamer-Setup.iss").read_text(encoding="utf-8")
+ self.assertIn("PrivilegesRequired=lowest", setup)
+ self.assertIn('Flags: unchecked', setup[setup.index('[Tasks]') : setup.index('[Files]')])
+ code = setup[setup.index("[Code]") :]
+ self.assertIn("RunTaskOperation(ExpandConstant('{app}\\Beamer.exe'), '--enable-autostart', ResultCode)", code)
+ self.assertIn("if IsAdmin then", code)
+ self.assertIn("ShellExec('runas'", code)
+ self.assertIn("ewWaitUntilTerminated", code)
+ self.assertIn("ResultCode <> 0", code)
+ self.assertIn("RaiseException", code)
+ self.assertIn("same administrator account", code)
+ self.assertNotIn("<Task version=", code)
+ self.assertNotIn('/Create /TN', code)
+ self.assertNotIn('/delete /tn "Beamer" /f', code)
+
if __name__ == "__main__":
unittest.main()
diff --git a/win_app/tests/test_autostart_x11.py b/win_app/tests/test_autostart_x11.py
index 09a6be9..7eff366 100644
--- a/win_app/tests/test_autostart_x11.py
+++ b/win_app/tests/test_autostart_x11.py
@@ -58,6 +58,9 @@ class AutostartX11Test(unittest.TestCase):
def enable(self, exe=EXE):
autostart_x11.set_enabled(True, exe, base=self.base)
+ def test_it_answers_the_question_the_settings_page_asks_of_every_platform(self):
+ self.assertTrue(autostart_x11.can_run_for_current_user())
+
def test_enable_writes_the_exact_file(self):
self.enable()
self.assertEqual(
diff --git a/win_app/tests/test_brightness_worker.py b/win_app/tests/test_brightness_worker.py
new file mode 100644
index 0000000..29e7159
--- /dev/null
+++ b/win_app/tests/test_brightness_worker.py
@@ -0,0 +1,131 @@
+import threading
+import sys
+import types
+import unittest
+from unittest.mock import patch
+
+import display_brightness
+import input_injector
+from brightness_worker import BrightnessWorker
+
+
+class BrightnessInputTests(unittest.TestCase):
+ def test_brightness_injection_returns_while_the_wmi_operation_is_blocked(self):
+ entered = threading.Event()
+ release = threading.Event()
+ original = input_injector._IS_WINDOWS
+ input_injector._IS_WINDOWS = False
+ self.addCleanup(setattr, input_injector, "_IS_WINDOWS", original)
+ self.addCleanup(release.set)
+
+ def slow_adjust(_steps):
+ entered.set()
+ release.wait(2)
+
+ with patch.object(display_brightness, "adjust", side_effect=slow_adjust):
+ worker = threading.Thread(target=input_injector.inject_key, args=("brightness_up", True))
+ worker.start()
+ worker.join(0.2)
+ self.assertFalse(worker.is_alive(), "brightness injection held the input reader")
+ self.assertTrue(entered.wait(1), "brightness work was not started")
+
+ def test_repeated_presses_coalesce_to_the_latest_net_target(self):
+ entered = threading.Event()
+ release = threading.Event()
+ done = threading.Event()
+ steps = []
+
+ def adjust(target):
+ steps.append(target)
+ if len(steps) == 1:
+ entered.set()
+ release.wait(2)
+ else:
+ done.set()
+
+ worker = BrightnessWorker(adjust)
+ worker.submit(1)
+ self.assertTrue(entered.wait(1))
+ worker.submit(1)
+ worker.submit(1)
+ worker.submit(-1)
+ worker.submit(1)
+ release.set()
+ self.assertTrue(done.wait(1))
+ self.assertEqual(steps, [1, 2])
+
+
+class DirectWmiTests(unittest.TestCase):
+ def test_worker_thread_initialises_and_uninitialises_com_around_wmi(self):
+ events = []
+ pythoncom = types.ModuleType("pythoncom")
+ pythoncom.CoInitialize = lambda: events.append("initialise")
+ pythoncom.CoUninitialize = lambda: events.append("uninitialise")
+ client = types.ModuleType("win32com.client")
+
+ class Service:
+ @staticmethod
+ def ExecQuery(_query):
+ events.append("query")
+ return []
+
+ class Locator:
+ @staticmethod
+ def ConnectServer(_host, _namespace):
+ events.append("connect")
+ return Service()
+
+ client.Dispatch = lambda _name: Locator()
+ win32com = types.ModuleType("win32com")
+ win32com.__path__ = []
+ with patch.dict(sys.modules, {
+ "pythoncom": pythoncom,
+ "win32com": win32com,
+ "win32com.client": client,
+ }):
+ self.assertFalse(display_brightness.adjust(1))
+ self.assertEqual(events[0], "initialise")
+ self.assertEqual(events[-1], "uninitialise")
+
+ def test_adjust_uses_wmi_com_and_steps_through_supported_levels(self):
+ calls = []
+
+ class Params:
+ pass
+
+ class MethodDefinition:
+ class InParameters:
+ @staticmethod
+ def SpawnInstance_():
+ return Params()
+
+ class Monitor:
+ InstanceName = "panel"
+ CurrentBrightness = 20
+ Level = [0, 20, 40, 80]
+
+ @staticmethod
+ def Methods_(_name):
+ return MethodDefinition()
+
+ @staticmethod
+ def ExecMethod_(_name, params):
+ calls.append(params.Brightness)
+ return type("Result", (), {"ReturnValue": 0})()
+
+ class Service:
+ @staticmethod
+ def ExecQuery(query):
+ return [Monitor()] if "WmiMonitorBrightness FROM" in query else [Monitor()]
+
+ class Locator:
+ @staticmethod
+ def ConnectServer(_host, _namespace):
+ return Service()
+
+ self.assertTrue(display_brightness.adjust(2, dispatch=lambda _name: Locator()))
+ self.assertEqual(calls, [80])
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/win_app/tests/test_capture_portal.py b/win_app/tests/test_capture_portal.py
index df705b2..722a696 100644
--- a/win_app/tests/test_capture_portal.py
+++ b/win_app/tests/test_capture_portal.py
@@ -8,6 +8,7 @@ import os
import sys
import time
import unittest
+from unittest import mock
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
@@ -24,6 +25,22 @@ SESSION = "/org/freedesktop/portal/desktop/session/1_42/beamer2"
class BarrierTest(unittest.TestCase):
+ def test_kde_uses_one_complete_edge_for_selected_thirds(self):
+ models = [return_edge.PartEdge("left", {"middle"}), return_edge.PartEdge("left", {"end"})]
+ self.assertEqual(capture_portal.barriers(models, ONE, whole_edges=True), [("left", (0, 0, 0, 1079))])
+
+ def test_kde_corners_use_complete_edges_without_internal_seams(self):
+ models = [return_edge.CornerPush("top_right", "right")]
+ screens = [Rect(0, 0, 1920, 1080), Rect(1920, 0, 1920, 1080)]
+ self.assertCountEqual(capture_portal.barriers(models, screens, whole_edges=True),
+ [("top", (0, 0, 1919, 0)), ("right", (3840, 0, 3840, 1079)),
+ ("top", (1920, 0, 3839, 0))])
+
+ def test_kde_does_not_widen_a_partly_exposed_side_across_a_monitor_seam(self):
+ screens = [Rect(0, 0, 1920, 1080), Rect(1920, 200, 1280, 1024)]
+ self.assertEqual(capture_portal.barriers([return_edge.ReturnEdge("right")], screens, whole_edges=True),
+ [("right", (3200, 200, 3200, 1223))])
+
def test_a_whole_edge_on_one_display(self):
self.assertEqual(capture_portal.barriers([return_edge.ReturnEdge("right")], ONE), [("right", (1920, 0, 1920, 1079))])
self.assertEqual(capture_portal.barriers([return_edge.ReturnEdge("top")], ONE), [("top", (0, 0, 1919, 0))])
@@ -59,6 +76,21 @@ class BarrierTest(unittest.TestCase):
models = [return_edge.SpanEdge("top", lambda: (100, 200)), return_edge.ReturnEdge("left"), return_edge.ReturnEdge("left")]
self.assertEqual(capture_portal.barriers(models, ONE), [("left", (0, 0, 0, 1079))])
+ def test_mutter_accepts_every_barrier_on_the_laptops_logical_monitor(self):
+ models = [return_edge.ReturnEdge(edge) for edge in ("left", "right", "top", "bottom")]
+ models += [return_edge.PartEdge(edge, {part}) for edge in ("left", "right", "top", "bottom")
+ for part in ("start", "middle", "end")]
+ models += [return_edge.CornerPush(corner, edge) for corner, edge in
+ (("top_left", "left"), ("top_right", "right"), ("bottom_left", "left"), ("bottom_right", "right"))]
+ for model in models:
+ found = [position for _wall, position in capture_portal.barriers([model], LAPTOP)]
+ self.assertTrue(found, model)
+ for position in found:
+ self.assertTrue(mutter_accepts(position, LAPTOP), (model, position))
+ self.assertFalse(mutter_accepts((0, 0, 3199, 0), LAPTOP)) # the panel's pixels, not its logical size
+ self.assertFalse(mutter_accepts((1601, 0, 1601, 899), LAPTOP)) # a pixel past the edge
+ self.assertFalse(mutter_accepts((800, 0, 800, 899), LAPTOP)) # across the display
+
class Clock:
def __init__(self):
@@ -111,15 +143,108 @@ class MemoryTokens:
self.token = token
+LAPTOP = [Rect(0, 0, 1600, 900)] # a 3200x1800 panel at scale 2.0 in mutter's logical layout
+
+
+def _adjacency(m, x1, y1, x2, y2):
+ """mutter 50.0 get_barrier_adjacency (src/backends/meta-input-capture-session.c), line for line."""
+ x_min, x_max, y_min, y_max = min(x1, x2), max(x1, x2), min(y1, y2), max(y1, y2)
+ if x1 == x2:
+ if x1 < m.x or x1 > m.x + m.width or y_max < m.y or y_min >= m.y + m.height:
+ return "none"
+ if x1 in (m.x, m.x + m.width):
+ return "partial" if y_max > m.y + m.height or y_min < m.y else "contained"
+ return "overlap"
+ if y1 == y2:
+ if y1 < m.y or y1 > m.y + m.height or x_max < m.x or x_min >= m.x + m.width:
+ return "none"
+ if y1 in (m.y, m.y + m.height):
+ return "partial" if x_max > m.x + m.width or x_min < m.x else "contained"
+ return "overlap"
+ return "none"
+
+
+def mutter_accepts(barrier, monitors):
+ """mutter 50.0 check_barrier over the logical monitors, the first being primary."""
+ x1, y1, x2, y2 = barrier
+ if (x1 != x2 and y1 != y2) or (x1 == x2 and y1 == y2):
+ return False
+ adjacent = False
+ for m in monitors:
+ found = _adjacency(m, x1, y1, x2, y2)
+ if found in ("overlap", "partial") or found == "contained" and adjacent:
+ return False
+ adjacent = adjacent or found == "contained"
+ if adjacent and y1 == y2:
+ rightmost = monitors[0]
+ while True:
+ beside = [m for m in monitors if m.x == rightmost.x + rightmost.width
+ and m.y < rightmost.y + rightmost.height and rightmost.y < m.y + m.height]
+ if not beside:
+ break
+ rightmost = beside[0]
+ fake = Rect(rightmost.x + rightmost.width, rightmost.y, rightmost.width, rightmost.height)
+ if _adjacency(fake, x1, y1, x2, y2) != "none":
+ return False
+ return adjacent
+
+
+class GnomeBus(FakeBus):
+ """The InputCapture portal as mutter 50 and xdg-desktop-portal-gnome 50 run it: Enable and every
+ added barrier need a session that is not enabled; ClearBarriers works in any state; Disable needs
+ an enabled session and sends no Disabled signal. `refused` collects each barrier id it refused,
+ `wasted` each Enable or Disable mutter would have refused."""
+
+ def __init__(self, monitors, **kwargs):
+ super().__init__(**kwargs)
+ self.monitors = monitors
+ self.enabled = False
+ self.refused = []
+ self.wasted = []
+ self.answers["SetPointerBarriers"] = self._barriers
+
+ def _barriers(self, body):
+ failed = []
+ for item in body[2]:
+ wanted = item["position"][1]
+ if self.enabled or not mutter_accepts(wanted, self.monitors):
+ failed.append(item["barrier_id"][1])
+ self.refused.extend(failed)
+ return 0, {"failed_barriers": failed}
+
+ def call(self, path, interface, method, signature, body):
+ # The frontend calls Enable and Disable on the backend without waiting, so mutter's
+ # "Already enabled" and "Session not enabled" reach only the journal, never Beamer.
+ if method in ("Enable", "Disable"):
+ if self.enabled == (method == "Enable"):
+ self.wasted.append(method)
+ self.enabled = method == "Enable"
+ return super().call(path, interface, method, signature, body)
+
+ def monitors_change(self):
+ """Mutter disables the session on a monitor change and says only ZonesChanged."""
+ self.enabled = False
+ self.emit(portal.OBJECT_PATH, capture_portal.INTERFACE, "ZonesChanged", (SESSION, {}))
+
+ def disabled_signal(self):
+ """Mutter 50 never sends Disabled; KWin does."""
+ self.enabled = False
+ self.emit(portal.OBJECT_PATH, capture_portal.INTERFACE, "Disabled", (SESSION, {}))
+
+
class Harness:
"""A Hooks on a fake portal, its callbacks recorded, and a sender stand-in that crosses after
- `push_to_cross` pushes, as the zone model does."""
-
- def __init__(self, version=1, models=None, push_to_cross=2, tokens=None):
- self.bus = FakeBus(versions={capture_portal.INTERFACE: version})
+ `push_to_cross` pushes, as the zone model does. `gnome` makes the portal GNOME's, on the zone
+ the laptop reports."""
+
+ def __init__(self, version=1, models=None, push_to_cross=2, tokens=None, gnome=False):
+ if gnome:
+ self.bus = GnomeBus(LAPTOP, versions={capture_portal.INTERFACE: version})
+ else:
+ self.bus = FakeBus(versions={capture_portal.INTERFACE: version})
+ self.bus.answers["SetPointerBarriers"] = (0, {"failed_barriers": []})
self.bus.answers["CreateSession"] = (0, {"session_handle": SESSION, "capabilities": 3})
- self.bus.answers["GetZones"] = (0, {"zones": [(1920, 1080, 0, 0)], "zone_set": 7})
- self.bus.answers["SetPointerBarriers"] = (0, {"failed_barriers": []})
+ self.bus.answers["GetZones"] = (0, {"zones": [(1600, 900, 0, 0)] if gnome else [(1920, 1080, 0, 0)], "zone_set": 7})
self.bus.returns["CreateSession2"] = (vardict({"session_handle": SESSION}),)
self.bus.returns["ConnectToEIS"] = (99,)
self.ei = FakeEi()
@@ -187,6 +312,85 @@ class HooksTest(unittest.TestCase):
self.harness = Harness(**kwargs)
return self.harness
+ def test_kde_releases_an_unselected_third_without_forwarding_input(self):
+ with mock.patch.dict(os.environ, {"XDG_CURRENT_DESKTOP": "KDE"}):
+ h = self.make(models=[return_edge.PartEdge("right", {"middle"})])
+ h.start()
+ h.bus.emit(portal.OBJECT_PATH, capture_portal.INTERFACE, "Activated",
+ (SESSION, vardict({"activation_id": 3, "cursor_position": (1940.0, 100.0)})))
+ wait_for(lambda: h.releases(), what="unselected KDE edge to be released")
+ self.assertEqual(h.releases(), [(3, (1919.0, 100.0))])
+ self.assertEqual((h.keys, h.mice, h.motions), ([], [], []))
+ self.assertFalse(h.hooks.holding)
+
+ def test_kde_selected_third_accepts_overshoot_and_a_missing_barrier_id(self):
+ with mock.patch.dict(os.environ, {"XDG_CURRENT_DESKTOP": "KDE"}):
+ h = self.make(models=[return_edge.PartEdge("right", {"middle"})])
+ h.start()
+ placed = h.bus.made("SetPointerBarriers")[-1][2]
+ self.assertEqual(placed[0]["position"], ("(iiii)", (1920, 0, 1920, 1079)))
+ h.activate(x=1940.0, y=500.0, barrier=0)
+ self.assertTrue(h.hooks.holding)
+ self.assertEqual(h.hooks._press.wall, "right")
+
+ def test_rejected_kde_sequence_drops_early_and_late_input_but_keeps_a_new_sequence(self):
+ with mock.patch.dict(os.environ, {"XDG_CURRENT_DESKTOP": "KDE"}):
+ h = self.make(models=[return_edge.PartEdge("right", {"middle"})])
+ h.start()
+ hooks = h.hooks
+ hooks._ei_event(("start", h.pointer, 3))
+ hooks._ei_event(("motion", h.pointer, 10.0, 0.0))
+ hooks._activated({"activation_id": 3, "cursor_position": (1920.0, 100.0)})
+ hooks._ei_event(("motion", h.pointer, 10.0, 0.0))
+ hooks._ei_event(("start", h.keyboard, 3))
+ hooks._ei_event(("key", h.keyboard, 30, True))
+ self.assertEqual(hooks._early, [])
+ self.assertEqual((h.keys, h.mice, h.motions), ([], [], []))
+ hooks._ei_event(("stop", h.pointer))
+ self.assertIn(3, hooks._rejected)
+ hooks._ei_event(("stop", h.keyboard))
+ self.assertNotIn(3, hooks._rejected)
+ hooks._ei_event(("start", h.pointer, 4))
+ hooks._ei_event(("motion", h.pointer, 10.0, 0.0))
+ hooks._activated({"activation_id": 4, "cursor_position": (1920.0, 500.0)})
+ self.assertEqual(h.motions, [(10.0, 0.0)])
+
+ def test_kde_selection_checks_the_actual_monitor_edge(self):
+ with mock.patch.dict(os.environ, {"XDG_CURRENT_DESKTOP": "KDE"}):
+ h = self.make(models=[return_edge.PartEdge("right", {"middle"})])
+ h.start()
+ h.hooks._placed = [("right", (1920, 0, 1920, 1079)), ("right", (4000, 0, 4000, 1079))]
+ h.hooks._walls = {1: "right", 2: "right"}
+ h.hooks._selected = [("right", (1920, 360, 1920, 719))]
+ self.assertTrue(h.hooks._selected_at("right", (1940, 500)))
+ self.assertFalse(h.hooks._selected_at("right", (4000, 500)))
+
+ def test_kde_does_not_clamp_along_edge_overshoot_into_a_selected_end_third(self):
+ with mock.patch.dict(os.environ, {"XDG_CURRENT_DESKTOP": "KDE"}):
+ h = self.make(models=[return_edge.PartEdge("right", {"end"})])
+ h.start()
+ self.assertFalse(h.hooks._selected_at("right", (1940, 2000)))
+
+ def test_kde_rejection_without_an_activation_id_drops_a_late_start(self):
+ with mock.patch.dict(os.environ, {"XDG_CURRENT_DESKTOP": "KDE"}):
+ h = self.make(models=[return_edge.PartEdge("right", {"middle"})])
+ h.start()
+ h.hooks._activated({"cursor_position": (1920.0, 100.0)})
+ h.hooks._ei_event(("start", h.pointer, 3))
+ h.hooks._ei_event(("motion", h.pointer, 10.0, 0.0))
+ self.assertEqual(h.hooks._early, [])
+ h.hooks._ei_event(("stop", h.pointer))
+ h.hooks._activated({"activation_id": 4, "cursor_position": (1920.0, 500.0)})
+ h.hooks._ei_event(("start", h.pointer, 4))
+ h.hooks._ei_event(("motion", h.pointer, 10.0, 0.0))
+ self.assertEqual(h.motions, [(10.0, 0.0)])
+
+ def test_kde_missing_barrier_id_allows_large_normal_axis_overshoot(self):
+ with mock.patch.dict(os.environ, {"XDG_CURRENT_DESKTOP": "KDE"}):
+ h = self.make(models=[return_edge.PartEdge("right", {"middle"})])
+ h.start()
+ self.assertEqual(h.hooks._wall_at((2420, 500)), "right")
+
def test_the_barriers_go_on_the_zones_and_the_session_is_enabled(self):
h = self.make()
h.start()
@@ -329,6 +533,65 @@ class HooksTest(unittest.TestCase):
wait_for(lambda: len(h.bus.made("SetPointerBarriers")) == 3, what="the barriers back")
wait_for(lambda: len(h.bus.made("Enable")) == enables + 1, what="enabled again")
+ def test_gnome_barriers_replaced_on_an_enabled_session_disable_it_first_and_none_is_refused(self):
+ h = self.make(gnome=True, models=[return_edge.ReturnEdge("bottom")])
+ h.start()
+ self.assertEqual(h.bus.made("SetPointerBarriers")[0][2][0]["position"], ("(iiii)", (0, 900, 1599, 900)))
+ h.models = [return_edge.ReturnEdge("bottom"), return_edge.ReturnEdge("left")]
+ wait_for(lambda: len(h.bus.made("Enable")) == 2, what="the session enabled again")
+ names = [method for _interface, method, _body in h.bus.calls if method in ("Enable", "Disable", "SetPointerBarriers")]
+ self.assertEqual(names, ["SetPointerBarriers", "Enable", "Disable", "SetPointerBarriers", "Enable"])
+ self.assertEqual(len(h.bus.made("SetPointerBarriers")[1][2]), 2)
+ self.assertEqual((h.bus.refused, h.bus.wasted), ([], []))
+ self.assertTrue(h.bus.enabled and h.hooks._session.enabled)
+ self.assertEqual(h.failures, [])
+
+ def test_gnome_held_edges_and_their_return_leave_the_barriers_standing(self):
+ h = self.make(gnome=True, models=[return_edge.ReturnEdge("bottom"), return_edge.ReturnEdge("left")])
+ h.start()
+ models = h.models
+ h.models = []
+ wait_for(lambda: len(h.bus.made("SetPointerBarriers")) == 2, what="the barriers removed")
+ self.assertEqual(h.bus.made("SetPointerBarriers")[1][2], [])
+ h.models = models
+ wait_for(lambda: len(h.bus.made("Enable")) == 2, what="enabled again")
+ self.assertEqual(len(h.bus.made("SetPointerBarriers")[2][2]), 2)
+ self.assertEqual(len(h.bus.made("Disable")), 1)
+ self.assertEqual(h.bus.refused, [])
+ self.assertTrue(h.bus.enabled)
+ self.assertEqual(h.failures, [])
+
+ def test_after_a_monitor_change_the_barriers_are_set_without_a_disable(self):
+ h = self.make(gnome=True)
+ h.start()
+ h.bus.monitors_change()
+ wait_for(lambda: len(h.bus.made("Enable")) == 2, what="the session enabled again")
+ self.assertEqual(len(h.bus.made("SetPointerBarriers")), 2)
+ self.assertEqual(h.bus.made("Disable"), [])
+ self.assertEqual((h.bus.refused, h.bus.wasted), ([], []))
+ self.assertTrue(h.bus.enabled)
+ self.assertEqual(h.failures, [])
+
+ def test_after_a_disabled_signal_the_barriers_are_set_without_a_disable(self):
+ h = self.make(gnome=True)
+ h.start()
+ h.bus.disabled_signal()
+ wait_for(lambda: len(h.bus.made("Enable")) == 2, what="the session enabled again")
+ self.assertEqual(h.bus.made("Disable"), [])
+ self.assertEqual((h.bus.refused, h.bus.wasted), ([], []))
+ self.assertEqual(h.failures, [])
+
+ def test_a_disable_the_portal_refuses_is_logged_and_the_barriers_are_still_set(self):
+ h = self.make(models=[return_edge.ReturnEdge("bottom")])
+ h.start()
+ h.bus.failures["Disable"] = portal.PortalError("Disable: Failed")
+ with self.assertLogs(capture_portal.LOGGER, level="WARNING") as logs:
+ h.models = [return_edge.ReturnEdge("bottom"), return_edge.ReturnEdge("left")]
+ wait_for(lambda: len(h.bus.made("Enable")) == 2, what="the barriers set again")
+ self.assertEqual(len(h.bus.made("SetPointerBarriers")), 2)
+ self.assertIn("Could not disable", "\n".join(logs.output))
+ self.assertEqual(h.failures, [])
+
def test_a_stop_while_input_is_away_lets_go_and_ends_the_connection(self):
h = self.make()
h.start()
diff --git a/win_app/tests/test_capture_sender.py b/win_app/tests/test_capture_sender.py
new file mode 100644
index 0000000..63809db
--- /dev/null
+++ b/win_app/tests/test_capture_sender.py
@@ -0,0 +1,89 @@
+"""Capture events pass through the Qt shell to the real sender, without a desktop."""
+
+from pathlib import Path
+import sys
+from types import SimpleNamespace
+import unittest
+from unittest import mock
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+import capture_win
+import kvm_bridge_win
+import platform_parts
+import sender
+from core import protocol
+from links_rig import B, Rig
+
+
+class Keymap:
+ def keysym(self, keycode, mods, group):
+ return ord("a") if keycode == 38 else 0
+
+ def text(self, keysym):
+ return chr(keysym) if keysym else None
+
+ def core_mods(self, mods):
+ return mods
+
+
+def shell(rig, capture):
+ return SimpleNamespace(sender=rig.sender, _trigger=capture.Trigger())
+
+
+def check_linux_key(capture, session, code, name, us):
+ rig = Rig()
+ assert rig.sender.set_redirecting(True)
+ application = shell(rig, capture)
+ hooks = capture.Hooks(
+ lambda *args: kvm_bridge_win.WindowsApplication._on_hook_key(application, *args),
+ lambda *_: False,
+ lambda *_: None,
+ )
+ if session == "x11":
+ hooks._connection = SimpleNamespace(keymap=Keymap())
+
+ def feed(down):
+ hooks._key(code + 8, down, 0, 0, True)
+ else:
+ hooks._keymap = Keymap()
+ device = object()
+
+ def feed(down):
+ hooks._key_event(code, down, device)
+
+ feed(True)
+ feed(False)
+ expected = {"key": name}
+ if us is not None:
+ expected["us"] = us
+ assert rig.sent(B, protocol.MSG_KEYDOWN) == [{"type": protocol.MSG_KEYDOWN, "data": expected}]
+ assert rig.sent(B, protocol.MSG_KEYUP) == [{"type": protocol.MSG_KEYUP, "data": expected}]
+
+
+class CaptureSenderTests(unittest.TestCase):
+ def check_backend(self, session):
+ capture = platform_parts.load("linux", {"XDG_SESSION_TYPE": session}).capture
+ with mock.patch.object(kvm_bridge_win, "capture_win", capture), mock.patch.object(sender, "OWN_PLATFORM", "linux"):
+ for code, name, us in ((30, "a", "a"), (28, "enter", None), (42, "shift", None)):
+ with self.subTest(key=name):
+ check_linux_key(capture, session, code, name, us)
+
+ def test_x11_capture_key_press_and_release_reach_sender(self):
+ self.check_backend("x11")
+
+ def test_wayland_capture_key_press_and_release_reach_sender(self):
+ self.check_backend("wayland")
+
+ def test_windows_dead_key_and_composed_text_still_reach_sender(self):
+ rig = Rig()
+ rig.links.caps_of[B] = frozenset({"text"})
+ assert rig.sender.set_redirecting(True)
+ application = shell(rig, capture_win)
+ callback = kvm_bridge_win.WindowsApplication._on_hook_key
+ with mock.patch.object(kvm_bridge_win, "capture_win", capture_win):
+ assert callback(application, capture_win.DeadKey("^"), True, 0xDD)
+ assert rig.sent(B, protocol.MSG_KEYDOWN) == []
+ assert rig.sent(B, protocol.MSG_TEXT) == []
+ assert callback(application, capture_win.TextInput("^x"), True, 0x58)
+ assert rig.sent(B, protocol.MSG_TEXT) == [{"type": protocol.MSG_TEXT, "data": {"text": "^x"}}]
diff --git a/win_app/tests/test_capture_win.py b/win_app/tests/test_capture_win.py
index a38fd0e..ec7a9b7 100644
--- a/win_app/tests/test_capture_win.py
+++ b/win_app/tests/test_capture_win.py
@@ -22,7 +22,17 @@ def names_only(vk, scan, state):
return {VK_A: "a"}.get(vk)
+class HookPoint(ctypes.Structure):
+ _fields_ = [("x", ctypes.c_long), ("y", ctypes.c_long)]
+
+
class NameTests(unittest.TestCase):
+ def test_browser_search_and_app_launch_keys_are_captured(self):
+ state = KeyboardState()
+ self.assertEqual(key_name(0xAA, 0, state, names_only), "browser_search")
+ self.assertEqual(key_name(0xB4, 0, state, names_only), "mail")
+ self.assertEqual(key_name(0xB6, 0, state, names_only), "launch_app1")
+
def test_ctrl_leaves_this_pc_as_command(self):
# The semantic swap happens here and nowhere else: the Mac injects
# exactly the name it is given.
@@ -182,6 +192,133 @@ class NameTests(unittest.TestCase):
self.assertEqual(key_name(0x45, 0, state, translate, down=True), "ê")
+class InjectedHookTests(unittest.TestCase):
+ class HookData(ctypes.Structure):
+ _fields_ = [
+ ("vkCode", ctypes.c_ulong),
+ ("scanCode", ctypes.c_ulong),
+ ("flags", ctypes.c_ulong),
+ ("time", ctypes.c_ulong),
+ ("dwExtraInfo", ctypes.c_size_t),
+ ]
+
+ class MouseData(ctypes.Structure):
+ _fields_ = [
+ ("pt", HookPoint),
+ ("mouseData", ctypes.c_ulong),
+ ("flags", ctypes.c_ulong),
+ ("time", ctypes.c_ulong),
+ ("dwExtraInfo", ctypes.c_size_t),
+ ]
+
+ def test_only_beamer_injected_keys_are_ignored(self):
+ on_key = Mock(return_value=True)
+ hooks = capture_win.Hooks(on_key, Mock(), Mock())
+ user32 = Mock()
+ user32.CallNextHookEx.return_value = 99
+ marked = self.HookData(0x41, 0x1E, capture_win.LLKHF_INJECTED, 0, INJECTED_MARK)
+ foreign = self.HookData(0x41, 0x1E, capture_win.LLKHF_INJECTED, 0, 123)
+
+ with patch.object(capture_win, "KBDLLHOOKSTRUCT", self.HookData, create=True), \
+ patch.object(capture_win, "user32", user32), \
+ patch.object(capture_win, "key_name", return_value="a"):
+ marked_result = hooks._keyboard_proc(capture_win.HC_ACTION, capture_win.WM_KEYDOWN, ctypes.byref(marked))
+ foreign_result = hooks._keyboard_proc(capture_win.HC_ACTION, capture_win.WM_KEYDOWN, ctypes.byref(foreign))
+
+ self.assertEqual((marked_result, foreign_result), (99, 1))
+ on_key.assert_called_once_with("a", True, 0x41, "a")
+
+ def test_foreign_injected_mouse_buttons_and_wheel_pass_but_moves_do_not(self):
+ on_mouse = Mock(return_value=True)
+ hooks = capture_win.Hooks(Mock(), on_mouse, Mock())
+ user32 = Mock()
+ user32.CallNextHookEx.return_value = 99
+ marked_button = self.MouseData(HookPoint(5, 7), 0, capture_win.LLMHF_INJECTED, 0, INJECTED_MARK)
+ foreign_button = self.MouseData(HookPoint(5, 7), 0, capture_win.LLMHF_INJECTED, 0, 123)
+ foreign_wheel = self.MouseData(HookPoint(5, 7), 120 << 16, capture_win.LLMHF_INJECTED, 0, 123)
+ foreign_move = self.MouseData(HookPoint(5, 7), 0, capture_win.LLMHF_INJECTED, 0, 123)
+
+ with patch.object(capture_win, "MSLLHOOKSTRUCT", self.MouseData, create=True), \
+ patch.object(capture_win, "user32", user32):
+ results = (
+ hooks._mouse_proc(capture_win.HC_ACTION, 0x0201, ctypes.byref(marked_button)),
+ hooks._mouse_proc(capture_win.HC_ACTION, 0x0201, ctypes.byref(foreign_button)),
+ hooks._mouse_proc(capture_win.HC_ACTION, 0x020A, ctypes.byref(foreign_wheel)),
+ hooks._mouse_proc(capture_win.HC_ACTION, capture_win.WM_MOUSEMOVE, ctypes.byref(foreign_move)),
+ )
+
+ self.assertEqual(results, (99, 1, 1, 99))
+ self.assertEqual(on_mouse.call_count, 2)
+
+ def test_releasing_one_of_two_alt_keys_keeps_the_mac_switcher_open(self):
+ from links_rig import B, Rig
+
+ rig = Rig()
+ rig.sender.set_redirecting(True)
+ rig.flush()
+ rig.links.sent.clear()
+ hooks = capture_win.Hooks(rig.sender.on_key, Mock(), Mock())
+ user32 = Mock()
+ user32.CallNextHookEx.return_value = 99
+ events = [
+ (0xA4, capture_win.WM_KEYDOWN),
+ (0xA5, capture_win.WM_KEYDOWN),
+ (0x09, capture_win.WM_KEYDOWN),
+ (0xA4, capture_win.WM_KEYUP),
+ (0x09, capture_win.WM_KEYUP),
+ (0xA5, capture_win.WM_KEYUP),
+ ]
+ data = [self.HookData(vk, 0, 0, 0, 0) for vk, _kind in events]
+ key_names = {0xA4: "alt", 0xA5: "alt_r", 0x09: "tab"}
+ with patch.object(capture_win, "KBDLLHOOKSTRUCT", self.HookData, create=True), \
+ patch.object(capture_win, "user32", user32), \
+ patch.object(capture_win, "key_name", side_effect=lambda vk, *_args: key_names[vk]):
+ for item, (_vk, kind) in zip(data, events):
+ hooks._keyboard_proc(capture_win.HC_ACTION, kind, ctypes.byref(item))
+
+ keys = [(message["type"], message["data"].get("key")) for message in rig.sent(B)
+ if message["type"] in ("keydown", "keyup")]
+ self.assertEqual(keys.count(("keyup", "cmd")), 1)
+ self.assertEqual(keys[-1], ("keyup", "cmd"))
+
+ def test_alt_tab_to_mac_is_swallowed_and_uses_command_for_the_hold(self):
+ from links_rig import B, Rig
+
+ rig = Rig()
+ rig.sender.set_redirecting(True)
+ hooks = capture_win.Hooks(rig.sender.on_key, Mock(), Mock())
+ user32 = Mock()
+ user32.CallNextHookEx.return_value = 99
+ events = [
+ (0xA4, 0, capture_win.WM_KEYDOWN),
+ (0x09, 0, capture_win.WM_KEYDOWN),
+ (0x09, 0, capture_win.WM_KEYDOWN),
+ (0xA0, 0, capture_win.WM_KEYDOWN),
+ (0x09, 0, capture_win.WM_KEYDOWN),
+ (0x09, 0, capture_win.WM_KEYUP),
+ (0xA0, 0, capture_win.WM_KEYUP),
+ (0xA4, 0, capture_win.WM_KEYUP),
+ ]
+ data = [self.HookData(vk, 0, flags, 0, 0) for vk, flags, _kind in events]
+ key_names = {0xA4: "alt", 0x09: "tab", 0xA0: "shift"}
+ with patch.object(capture_win, "KBDLLHOOKSTRUCT", self.HookData, create=True), \
+ patch.object(capture_win, "user32", user32), \
+ patch.object(capture_win, "key_name", side_effect=lambda vk, *_args: key_names[vk]):
+ results = [
+ hooks._keyboard_proc(capture_win.HC_ACTION, kind, ctypes.byref(item))
+ for item, (_vk, _flags, kind) in zip(data, events)
+ ]
+
+ self.assertEqual(results, [1] * len(events))
+ keys = [(message["type"], message["data"].get("key")) for message in rig.sent(B)
+ if message["type"] in ("keydown", "keyup")]
+ self.assertEqual(keys, [
+ ("keydown", "alt"), ("keyup", "alt"), ("keydown", "cmd"),
+ ("keydown", "tab"), ("keydown", "tab"), ("keydown", "shift"),
+ ("keydown", "tab"), ("keyup", "tab"), ("keyup", "shift"), ("keyup", "cmd"),
+ ])
+
+
@unittest.skipUnless(sys.platform == "win32", "ToUnicodeEx needs Windows")
class LayoutTests(unittest.TestCase):
"""Against the real layout. The state passed in is the one the hook keeps,
@@ -220,15 +357,54 @@ class TriggerTests(unittest.TestCase):
def test_two_taps_inside_the_window_fire_once(self):
trigger = Trigger("cmd_r", "double_tap", 300)
self.assertIsNone(trigger.feed("cmd_r", True, 1.00))
+ self.assertIsNone(trigger.feed("cmd_r", False, 1.05))
self.assertEqual(trigger.feed("cmd_r", True, 1.20), TOGGLE)
+ self.assertIsNone(trigger.feed("cmd_r", False, 1.25))
# The pair is spent: a third tap starts a new one rather than firing.
self.assertIsNone(trigger.feed("cmd_r", True, 1.30))
def test_a_slow_second_tap_does_not_fire(self):
trigger = Trigger("cmd_r", "double_tap", 300)
trigger.feed("cmd_r", True, 1.0)
+ trigger.feed("cmd_r", False, 1.1)
self.assertIsNone(trigger.feed("cmd_r", True, 2.0))
+ def test_holding_the_key_never_toggles(self):
+ # Windows' default autorepeat: the first repeat at 0.5 s, then every 33 ms. Before 1.5.2
+ # this returned TOGGLE at 0.533, 0.599, 0.665 ... while the key was held.
+ trigger = Trigger("cmd_r", "double_tap", 300)
+ self.assertIsNone(trigger.feed("cmd_r", True, 0.0))
+ held = [0.5 + 0.033 * n for n in range(60)]
+ self.assertEqual([trigger.feed("cmd_r", True, at) for at in held], [None] * len(held))
+ self.assertIsNone(trigger.feed("cmd_r", False, 2.5))
+ # After the release, a real double-tap still fires.
+ self.assertIsNone(trigger.feed("cmd_r", True, 3.0))
+ self.assertIsNone(trigger.feed("cmd_r", False, 3.05))
+ self.assertEqual(trigger.feed("cmd_r", True, 3.2), TOGGLE)
+
+ def test_a_held_second_tap_toggles_once(self):
+ trigger = Trigger("cmd_r", "double_tap", 300)
+ trigger.feed("cmd_r", True, 1.0)
+ trigger.feed("cmd_r", False, 1.05)
+ self.assertEqual(trigger.feed("cmd_r", True, 1.2), TOGGLE)
+ self.assertEqual([trigger.feed("cmd_r", True, 1.7 + 0.033 * n) for n in range(30)], [None] * 30)
+
+ def test_a_key_held_while_the_shortcut_is_rearmed_does_not_toggle(self):
+ # The bridge reconfigures the trigger on every key while the shortcut is off.
+ trigger = Trigger("cmd_r", "double_tap", 300)
+ trigger.feed("cmd_r", True, 1.0)
+ trigger.configure("cmd_r", "double_tap", 300)
+ self.assertEqual([trigger.feed("cmd_r", True, 1.5 + 0.033 * n) for n in range(30)], [None] * 30)
+
+ def test_a_key_pressed_while_disarmed_and_held_into_arming_is_not_a_tap(self):
+ # Pressed with the shortcut off, so feed never saw the press; its autorepeat after
+ # arming must not count as the first tap of a pair a later single tap would complete.
+ trigger = Trigger("cmd_r", "double_tap", 300)
+ trigger.disarmed("cmd_r", True)
+ self.assertIsNone(trigger.feed("cmd_r", True, 1.5))
+ self.assertIsNone(trigger.feed("cmd_r", False, 1.55))
+ self.assertIsNone(trigger.feed("cmd_r", True, 1.7))
+
def test_another_key_is_not_the_trigger(self):
trigger = Trigger("cmd_r", "double_tap", 300)
trigger.feed("cmd_r", True, 1.0)
diff --git a/win_app/tests/test_capture_win_seam.py b/win_app/tests/test_capture_win_seam.py
new file mode 100644
index 0000000..48e350d
--- /dev/null
+++ b/win_app/tests/test_capture_win_seam.py
@@ -0,0 +1,96 @@
+import ctypes
+import unittest
+from unittest.mock import Mock, patch
+
+import capture_win
+from core.return_edge import PartEdge, Rect, ReturnEdge
+
+
+class HookPoint(ctypes.Structure):
+ _fields_ = [("x", ctypes.c_long), ("y", ctypes.c_long)]
+
+
+class MouseData(ctypes.Structure):
+ _fields_ = [
+ ("pt", HookPoint),
+ ("mouseData", ctypes.c_ulong),
+ ("flags", ctypes.c_ulong),
+ ("time", ctypes.c_ulong),
+ ("dwExtraInfo", ctypes.c_size_t),
+ ]
+
+
+class InternalSeamTests(unittest.TestCase):
+ def setUp(self):
+ self.left = Rect(0, 0, 100, 100)
+ self.right = Rect(100, 0, 100, 100)
+ self.monitors = [self.left, self.right]
+ self.display_map = {"left": self.left}
+
+ def test_an_armed_display_edge_clips_to_the_source_monitor(self):
+ edge = ReturnEdge("right", display="left")
+ self.assertEqual(
+ capture_win.internal_seam_position((105, 50), self.monitors, self.display_map, [edge]),
+ (99, 50),
+ )
+
+ def test_only_the_armed_display_edge_holds_and_only_on_its_third(self):
+ edge = PartEdge("right", {"start"}, display="left")
+ self.assertEqual(
+ capture_win.internal_seam_position((105, 20), self.monitors, self.display_map, [edge]),
+ (99, 20),
+ )
+ self.assertIsNone(
+ capture_win.internal_seam_position((105, 80), self.monitors, self.display_map, [edge])
+ )
+ self.assertIsNone(
+ capture_win.internal_seam_position((105, 20), self.monitors, self.display_map, [])
+ )
+
+ def test_top_and_bottom_seams_are_clipped_too(self):
+ upper, lower = Rect(0, 0, 100, 100), Rect(0, 100, 100, 100)
+ top_edge = ReturnEdge("top", display="lower")
+ bottom_edge = ReturnEdge("bottom", display="upper")
+ self.assertEqual(
+ capture_win.internal_seam_position((50, 95), [upper, lower], {"lower": lower}, [top_edge]),
+ (50, 100),
+ )
+ self.assertEqual(
+ capture_win.internal_seam_position((50, 105), [upper, lower], {"upper": upper}, [bottom_edge]),
+ (50, 99),
+ )
+
+ def test_mouse_hook_restores_the_cursor_and_swallows_the_seam_move(self):
+ on_mouse = Mock(return_value=False)
+ on_seam = Mock(return_value=(99, 50))
+ hooks = capture_win.Hooks(Mock(), on_mouse, Mock(), on_seam=on_seam)
+ user32 = Mock()
+ user32.SetCursorPos.return_value = 1
+ data = MouseData(HookPoint(105, 50), 0, 0, 0, 0)
+
+ with patch.object(capture_win, "MSLLHOOKSTRUCT", MouseData, create=True), \
+ patch.object(capture_win, "user32", user32):
+ result = hooks._mouse_proc(capture_win.HC_ACTION, capture_win.WM_MOUSEMOVE, ctypes.byref(data))
+
+ self.assertEqual(result, 1)
+ user32.SetCursorPos.assert_called_once_with(99, 50)
+ on_mouse.assert_not_called()
+
+ def test_a_set_cursor_failure_fails_open(self):
+ on_mouse = Mock(return_value=False)
+ hooks = capture_win.Hooks(Mock(), on_mouse, Mock(), on_seam=Mock(return_value=(99, 50)))
+ user32 = Mock()
+ user32.SetCursorPos.return_value = 0
+ user32.CallNextHookEx.return_value = 99
+ data = MouseData(HookPoint(105, 50), 0, 0, 0, 0)
+
+ with patch.object(capture_win, "MSLLHOOKSTRUCT", MouseData, create=True), \
+ patch.object(capture_win, "user32", user32):
+ result = hooks._mouse_proc(capture_win.HC_ACTION, capture_win.WM_MOUSEMOVE, ctypes.byref(data))
+
+ self.assertEqual(result, 99)
+ on_mouse.assert_called_once()
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/win_app/tests/test_choice_fill.py b/win_app/tests/test_choice_fill.py
new file mode 100644
index 0000000..a626045
--- /dev/null
+++ b/win_app/tests/test_choice_fill.py
@@ -0,0 +1,71 @@
+"""A selected Vernier choice is filled with the current palette's ink: black in Light, as in Dark it
+is the light ink. It took the dark palette's in both, so Light showed no fill (Linux, 06-10)."""
+
+import os
+import sys
+import unittest
+from pathlib import Path
+
+os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from PySide6.QtGui import QColor
+from PySide6.QtWidgets import QApplication, QWidget
+
+import theme
+import tokens
+import widgets
+
+
+class ChoiceFillTests(unittest.TestCase):
+ @classmethod
+ def setUpClass(cls):
+ cls.app = QApplication.instance() or QApplication([])
+ cls.app.setStyle("Fusion")
+ cls.app.setFont(theme.font(theme.TYPE["body"]))
+
+ def setUp(self):
+ self.previous_stylesheet = self.app.styleSheet()
+ theme.set_dark(True)
+ theme.apply_stylesheet(self.app)
+ self.host = QWidget()
+
+ def tearDown(self):
+ self.host.close()
+ self.host.deleteLater()
+ self.app.setStyleSheet(self.previous_stylesheet)
+ theme.set_dark(True)
+
+ def assert_selected_fill(self, button, expected):
+ self.app.processEvents()
+ image = button.grab().toImage()
+ dpr = image.devicePixelRatio()
+ self.assertEqual(image.pixelColor(round(8 * dpr), round(8 * dpr)), QColor(expected))
+
+ def assert_label_ink(self, button, expected):
+ # The label is painted by ActionButton.paintEvent, not the stylesheet: it must follow the
+ # palette too, or Light shows black text on the black fill.
+ image = button.grab().toImage()
+ want = QColor(expected)
+ near = sum(1 for x in range(image.width()) for y in range(image.height())
+ if max(abs(image.pixelColor(x, y).red() - want.red()),
+ abs(image.pixelColor(x, y).green() - want.green()),
+ abs(image.pixelColor(x, y).blue() - want.blue())) < 24)
+ self.assertGreater(near, 10)
+
+ def test_settings_choice_fill_matches_selected_colour_in_both_themes(self):
+ choice = widgets.Choice((("one", "First option"), ("two", "Second option")), 2, "one", parent=self.host)
+ choice.view.resize(choice.view.sizeHint())
+ self.host.resize(choice.view.sizeHint())
+ self.host.show()
+ for dark in (True, False):
+ with self.subTest(dark=dark):
+ theme.set_dark(dark)
+ theme.apply_stylesheet(self.app)
+ self.app.processEvents()
+ palette = tokens.PALETTE if dark else tokens.PALETTE_LIGHT
+ self.assert_selected_fill(choice._buttons["one"], palette["ink"])
+ self.assert_label_ink(choice._buttons["one"], palette["ground"])
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/win_app/tests/test_click_focus.py b/win_app/tests/test_click_focus.py
index 8fa3956..0ec9445 100644
--- a/win_app/tests/test_click_focus.py
+++ b/win_app/tests/test_click_focus.py
@@ -38,7 +38,7 @@ class ClickFocusTests(unittest.TestCase):
cls.app.setStyleSheet(theme.stylesheet())
def setUp(self):
- scratch = ROOT / "renders" / "test-working"
+ scratch = ROOT / "win_app" / "renders" / "test-working"
scratch.mkdir(parents=True, exist_ok=True)
self.folder = tempfile.TemporaryDirectory(prefix="beamer-click-focus-", dir=scratch)
self.window = SyntheticWindow(write_synthetic_settings(Path(self.folder.name)))
diff --git a/win_app/tests/test_clipboard_portal.py b/win_app/tests/test_clipboard_portal.py
new file mode 100644
index 0000000..5493991
--- /dev/null
+++ b/win_app/tests/test_clipboard_portal.py
@@ -0,0 +1,87 @@
+"""set_contents on the link's reader thread: it never waits for the RemoteDesktop session. The
+desktop's consent dialog can hold the session up for longer than the sender waits for an
+acknowledgement, so a clipboard arriving before the session is up is dropped at once, not waited on
+(Fedora, 10-10-2026: a 2 s wait stalled input and the Mac ended the link)."""
+
+import os
+import sys
+import threading
+import time
+import unittest
+from unittest import mock
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+
+import clipboard_portal
+import inject_portal
+
+# Well under core.link.ACK_STALL_SECONDS (1.5), which core.link needs PyNaCl to import.
+QUICK_SECONDS = 0.2
+STUB_WAIT_SECONDS = 0.6
+
+
+class StubRemote:
+ """Stands in for inject_portal.Remote. `ask`, like the real one, starts the session and waits
+ for it (here STUB_WAIT_SECONDS) unless it is ready, then runs the work on a stub session."""
+
+ def __init__(self, ready):
+ self.ready = threading.Event()
+ if ready:
+ self.ready.set()
+ self.asked = 0
+ self.session = mock.Mock(changes=5)
+ self.session.set_selection.return_value = True
+
+ def ask(self, work, default=None, **_kwargs):
+ self.asked += 1
+ if not self.ready.is_set():
+ time.sleep(STUB_WAIT_SECONDS)
+ return default
+ return work(self.session)
+
+
+class SetContentsTest(unittest.TestCase):
+ def setUp(self):
+ clipboard_portal.forget_sync()
+ self.saved = inject_portal._remote
+
+ def tearDown(self):
+ inject_portal._remote = self.saved
+
+ def timed(self):
+ started = time.monotonic()
+ result = clipboard_portal.set_contents("hello", None)
+ return result, time.monotonic() - started
+
+ def test_a_session_not_started_is_not_waited_on_and_not_started(self):
+ stub = StubRemote(ready=False)
+ inject_portal._remote = None
+ with mock.patch.object(inject_portal, "remote", return_value=stub):
+ result, elapsed = self.timed()
+ self.assertFalse(result)
+ self.assertLess(elapsed, QUICK_SECONDS)
+ self.assertEqual(stub.asked, 0)
+
+ def test_a_session_started_but_not_ready_is_not_waited_on(self):
+ stub = StubRemote(ready=False)
+ inject_portal._remote = stub
+ with mock.patch.object(inject_portal, "remote", return_value=stub):
+ result, elapsed = self.timed()
+ self.assertFalse(result)
+ self.assertLess(elapsed, QUICK_SECONDS)
+ self.assertEqual(stub.asked, 0)
+
+ def test_a_ready_session_still_takes_the_clipboard(self):
+ stub = StubRemote(ready=True)
+ inject_portal._remote = stub
+ with mock.patch.object(inject_portal, "remote", return_value=stub):
+ self.assertTrue(clipboard_portal.set_contents("hello\r\nthere", None))
+ stub.session.set_selection.assert_called_once()
+ offer = stub.session.set_selection.call_args[0][0]
+ self.assertEqual(offer["text/plain"], b"hello\nthere")
+ self.assertEqual(clipboard_portal._synced, 5)
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/win_app/tests/test_crossing_fix_pass.py b/win_app/tests/test_crossing_fix_pass.py
new file mode 100644
index 0000000..563355c
--- /dev/null
+++ b/win_app/tests/test_crossing_fix_pass.py
@@ -0,0 +1,170 @@
+"""Regressions from the ledger review and the seven offscreen states."""
+
+import threading
+import unittest
+from unittest import mock
+
+from PySide6.QtCore import QPoint, Qt
+from PySide6.QtGui import QImage
+from PySide6.QtTest import QTest
+
+import app_config
+import kvm_bridge_win as kvm
+import theme
+from core import protocol
+import test_crossing_page_parity as parity
+
+
+class CrossingFixPass(unittest.TestCase):
+ setUp = parity.CrossingPageParityTests.setUp
+ tearDown = parity.CrossingPageParityTests.tearDown
+ _open_window = parity.CrossingPageParityTests._open_window
+ _close_window = parity.CrossingPageParityTests._close_window
+ _stop_patches = parity.CrossingPageParityTests._stop_patches
+
+ def test_keys_preserves_a_concurrent_link_save_and_other_peer_choices(self):
+ peer = self.peers[0]["id"]
+ load = app_config.load_settings
+ started, finished = threading.Event(), threading.Event()
+ threads = []
+ def link_save():
+ started.set()
+ with app_config.SETTINGS_LOCK:
+ saved = load(self.path)
+ saved["peers"][0]["label"] = "Name learned on link"
+ saved["peers"][1]["shortcut_cycle"] = False
+ app_config.write_settings(self.path, saved)
+ finished.set()
+ def keys_read(path):
+ saved = load(path)
+ if not threads:
+ thread = threading.Thread(target=link_save)
+ threads.append(thread)
+ thread.start()
+ self.assertTrue(started.wait(1))
+ finished.wait(.15)
+ return saved
+ with mock.patch.object(app_config, "load_settings", side_effect=keys_read):
+ self.window._set_shortcut_cycle(peer, False)
+ threads[0].join(2)
+ self.assertFalse(threads[0].is_alive())
+ saved = load(self.path)
+ self.assertEqual(saved["peers"][0].get("label"), "Name learned on link")
+ self.assertFalse(saved["peers"][0]["shortcut_cycle"])
+ self.assertFalse(saved["peers"][1]["shortcut_cycle"])
+
+ def test_link_announcement_arranges_before_picture_without_early_target_send(self):
+ peer = protocol.read_id(self.peers[0]["id"])
+ for gap in (False, True):
+ with self.subTest(gap=gap):
+ saved = app_config.load_settings(self.path)
+ if gap:
+ saved["layout"][self.peers[0]["id"]]["x"] = 600
+ app_config.write_settings(self.path, saved)
+ self.window._read_crossing()
+ sent = []
+ with mock.patch.object(self.window, "_peer_caps", return_value={peer: {"layout", "settings"}}), \
+ mock.patch.object(self.window, "_layout_capable", return_value={self.window._config.machine_id, self.peers[0]["id"]}), \
+ mock.patch.object(self.window, "_send_to", side_effect=lambda target, message: sent.append((target, message))):
+ messages = self.window._announce(peer)
+ self.assertEqual([message["type"] for target, message in sent if target == peer], [])
+ kinds = [message["type"] for message in messages]
+ self.assertLess(kinds.index("arrangement"), kinds.index("settings"))
+
+ def test_worker_own_displays_reads_a_copy_of_the_gui_cache(self):
+ from display_map_fixture import refresh_own_displays
+ desktop = mock.Mock()
+ desktop.display_map.return_value = {"screen": {"x": 0, "y": 0, "w": 160, "h": 100}}
+ with mock.patch.object(self.window, "_refresh_own_displays",
+ refresh_own_displays.__get__(self.window)), \
+ mock.patch.object(self.window.sender, "_desktop_module", return_value=desktop), \
+ mock.patch.object(kvm.platform, "system", return_value="Linux"):
+ self.window._displays_changed()
+ desktop.display_map.reset_mock()
+ result = []
+ thread = threading.Thread(target=lambda: result.append(self.window._own_displays()))
+ thread.start()
+ thread.join(2)
+ self.assertEqual(result, [{"screen": {"x": 0, "y": 0, "w": 160, "h": 100}}])
+ desktop.display_map.assert_not_called()
+ result[0].clear()
+ self.assertTrue(self.window._own_displays())
+
+ def test_escape_cancels_jump_and_restores_empty_or_saved_chip(self):
+ row = self.window.crossing_ledger.rows[self.peers[0]["id"]]
+ for value, text in (("", "Set a key"), ("alt+f18", "Alt F18")):
+ with self.subTest(value=value):
+ self.window._ledger_jump(row.peer, value)
+ row.jump.click()
+ self.assertTrue(self.window.sender.jump_recording)
+ QTest.keyClick(row.jump, Qt.Key.Key_Escape)
+ self.assertFalse(row.jump.armed)
+ self.assertFalse(self.window.sender.jump_recording)
+ self.assertEqual(row.jump.key.text(), text)
+ self.assertFalse(row.jump.hint.isVisible())
+ self.assertEqual(row.jump.value, value)
+
+ def test_empty_jump_uses_quiet_sans_text_and_keeps_recorded_chip(self):
+ row = self.window.crossing_ledger.rows[self.peers[0]["id"]]
+ self.assertEqual(row.jump.property("vernier"), "plain")
+ self.assertEqual(row.jump.key.font().family(), theme.font(theme.TYPE["note"]).family())
+ self.window._ledger_jump(row.peer, "alt+f18")
+ self.assertEqual(row.jump.property("vernier"), "keycap")
+ parity.settle(self.window)
+ self.assertEqual(row.clear.font().weight(), 400)
+ row.clear.click()
+ self.assertEqual(row.jump.property("vernier"), "plain")
+
+ def test_checked_keys_indicator_has_a_visible_dark_tick(self):
+ check = self.window.crossing_ledger.rows[self.peers[0]["id"]].cycle
+ check.setChecked(True)
+ image = QImage(check.size(), QImage.Format.Format_ARGB32)
+ image.fill(Qt.GlobalColor.transparent)
+ check.render(image)
+ dark = sum(1 for y in range(max(0, check.height() // 2 - 5), min(check.height(), check.height() // 2 + 5))
+ for x in range(4, 14) if image.pixelColor(x, y).lightnessF() < .2)
+ self.assertGreater(dark, 5)
+
+ def test_hint_gap_is_twelve_pixels_with_and_without_corner(self):
+ for width in (900, 960, 640):
+ self.window.resize(width, 760)
+ for corner in (False, True):
+ with self.subTest(width=width, corner=corner):
+ self.window._write_ways(self.peers[0]["id"], corner=corner, corner_at="top_left")
+ parity.settle(self.window)
+ canvas, hint = self.window.atlas_canvas, self.window.atlas_canvas_hint
+ root = self.window.ways_module
+ bottom = canvas.mapTo(root, QPoint(0, canvas.height())).y()
+ self.assertEqual(hint.mapTo(root, QPoint()).y() - bottom, 12)
+
+ def test_wrapped_edge_text_has_room_for_every_line_and_detail(self):
+ row = self.window.crossing_ledger.rows[self.peers[0]["id"]]
+ self.window._ledger_edge(row.peer)
+ self.window._ledger_third(row.peer, "middle")
+ parity.settle(self.window)
+ self.assertGreaterEqual(row.edge_value.height(), row.edge_value.heightForWidth(row.edge_value.width()))
+ self.assertGreaterEqual(row.edge_text.height(), row.edge_text.layout().heightForWidth(row.edge_text.width()))
+
+ def test_narrow_jump_stays_beside_its_label(self):
+ self.window.resize(640, 700)
+ parity.settle(self.window)
+ row = self.window.crossing_ledger.rows[self.peers[0]["id"]]
+ self.assertLess(row.jump.x(), 60)
+
+ def test_wide_ledger_keeps_its_column_width_and_headers(self):
+ self.window.resize(960, 760)
+ parity.settle(self.window)
+ self.assertFalse(self.window.crossing_ledger.narrow)
+ self.assertTrue(self.window.crossing_ledger.header.isVisible())
+ self.assertEqual(self.window.atlas_canvas.height(), 260)
+
+ def test_map_background_is_ground(self):
+ canvas = self.window.atlas_canvas
+ image = QImage(canvas.size(), QImage.Format.Format_ARGB32)
+ image.fill(Qt.GlobalColor.transparent)
+ canvas.render(image)
+ self.assertEqual(image.pixelColor(20, 20).name(), theme.colour("ground"))
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/win_app/tests/test_crossing_header_resize.py b/win_app/tests/test_crossing_header_resize.py
new file mode 100644
index 0000000..6c360c0
--- /dev/null
+++ b/win_app/tests/test_crossing_header_resize.py
@@ -0,0 +1,84 @@
+"""1.5.2 rc10: the Crossing page's selected-machine header went side by side at a fixed 120 DIP for its
+text, under the "Selected machine" eyebrow's own 124 on Windows, and side by side it asked for its
+side-by-side minimum. Shown first at a narrow width, before ColumnFit pins the column, that minimum held
+the page wider than the scroll area's viewport, which kept the header side by side, while stacked was
+stable too; QScrollArea's cached minimum lagged each switch, so it resized the page between the two with
+no Python frame in between until the native stack overflowed (0xC00000FD on the rig). On the Mac the
+loop never starts, so this fails only on Windows if the bug returns, and fails rather than crashes."""
+
+import unittest
+
+from PySide6.QtCore import QEvent, QObject
+from PySide6.QtWidgets import QBoxLayout
+
+import test_settings_layout_acceptance as acceptance
+
+
+class ResizeCounter(QObject):
+ """Counts a widget's resizes. Past the cap it swallows them, which ends a runaway loop as a test
+ failure on any stack size instead of a crash; installed after QScrollArea's own filter, so it runs
+ first."""
+
+ CAP = 200
+
+ def __init__(self, widget) -> None:
+ super().__init__(widget)
+ self.count = 0
+ widget.installEventFilter(self)
+
+ def eventFilter(self, _watched, event) -> bool:
+ if event.type() == QEvent.Type.Resize:
+ self.count += 1
+ return self.count > self.CAP
+ return False
+
+
+class CrossingHeaderResizeTests(unittest.TestCase):
+ setUpClass = acceptance.SettingsLayoutAcceptance.__dict__["setUpClass"]
+ setUp = acceptance.SettingsLayoutAcceptance.setUp
+ tearDown = acceptance.SettingsLayoutAcceptance.tearDown
+ settle = acceptance.SettingsLayoutAcceptance.settle
+ set_size = acceptance.SettingsLayoutAcceptance.set_size
+ page_scroll = acceptance.SettingsLayoutAcceptance.page_scroll
+
+ def test_header_direction_never_holds_the_page_open(self):
+ scroll = self.window.stack.widget(self.window._page_indexes["crossing"])
+ header = self.window.crossing_ledger
+ counter = ResizeCounter(scroll.widget())
+ # rc10's path: the page is first shown narrow, before ColumnFit has pinned its column, with
+ # the header built side by side.
+ self.set_size(320)
+ for width in (320, *range(326, 720, 6), *range(714, 320, -6)):
+ counter.count = 0
+ self.set_size(width)
+ if width == 320:
+ self.page_scroll("crossing")
+ with self.subTest(width=width):
+ self.assertTrue(header.isVisible())
+ self.assertLess(counter.count, ResizeCounter.CAP, "the page resized without end")
+ self.assertLessEqual(scroll.widget().width(), scroll.viewport().width())
+ self.assertLessEqual(header.minimumSizeHint().width(), header.width())
+
+ def test_long_unbroken_machine_name_elides_at_320_dip_without_widening_header(self):
+ full_name = "M" * 60
+ self.window._peer_entries[0]["name"] = full_name
+ self.window._reflect_ways()
+ self.set_size(320)
+ self.page_scroll("crossing")
+
+ header = self.window.crossing_ledger
+ name = header.rows[self.window._peer_entries[0]["id"]].name
+ with self.subTest("visible text is elided"):
+ self.assertTrue(name.text().endswith("…"))
+ self.assertLess(name.fontMetrics().horizontalAdvance(name.text()), name.width() + 1)
+ with self.subTest("full name remains available"):
+ self.assertEqual(name.toolTip(), full_name)
+ self.assertEqual(name.accessibleName(), full_name)
+ with self.subTest("header still asks only for its stacked minimum"):
+ self.assertLessEqual(header.minimumSizeHint().width(), header.width())
+ self.assertLessEqual(header.width(), self.window.stack.widget(
+ self.window._page_indexes["crossing"]
+ ).width())
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/win_app/tests/test_crossing_ledger.py b/win_app/tests/test_crossing_ledger.py
new file mode 100644
index 0000000..934556c
--- /dev/null
+++ b/win_app/tests/test_crossing_ledger.py
@@ -0,0 +1,206 @@
+"""Section 9: ledger controls round trip through saved intent and the map."""
+
+import copy
+import unittest
+from itertools import combinations
+
+from PySide6.QtCore import QPoint, Qt
+from PySide6.QtGui import QAccessible, QImage
+from PySide6.QtTest import QTest
+from PySide6.QtWidgets import QApplication, QWidget
+
+import app_config
+from core import ways
+import test_crossing_page_parity as parity
+
+
+def picked(window, peer):
+ return [third for third, button in window.crossing_ledger.rows[peer].edge_glyph.buttons.items()
+ if button.isChecked()]
+
+
+def band_point(canvas, third, side="right"):
+ rect = canvas.tile_rect(canvas._own_id())
+ fraction = {"start": 1 / 6, "middle": 1 / 2, "end": 5 / 6}[third]
+ if side in ("left", "right"):
+ return QPoint(round(rect.left() if side == "left" else rect.right()), round(rect.top() + rect.height() * fraction))
+ return QPoint(round(rect.left() + rect.width() * fraction), round(rect.top() if side == "top" else rect.bottom()))
+
+
+def paint(canvas):
+ image = QImage(canvas.size(), QImage.Format.Format_ARGB32)
+ image.fill(Qt.GlobalColor.transparent)
+ canvas.render(image)
+ return image
+
+
+class CrossingLedgerTests(unittest.TestCase):
+ setUp = parity.CrossingPageParityTests.setUp
+ tearDown = parity.CrossingPageParityTests.tearDown
+ _open_window = parity.CrossingPageParityTests._open_window
+ _close_window = parity.CrossingPageParityTests._close_window
+ _stop_patches = parity.CrossingPageParityTests._stop_patches
+
+ def test_seven_thirds_combinations_round_trip_and_match_map(self):
+ peer = self.peers[0]["id"]
+ for size in (1, 2, 3):
+ for subset in combinations(ways.PARTS, size):
+ with self.subTest(subset=subset):
+ window = self.window
+ if picked(window, peer):
+ window.crossing_ledger.rows[peer].edge_text.click()
+ window.crossing_ledger.rows[peer].edge_text.click()
+ for third in ways.PARTS:
+ if third not in subset:
+ window.crossing_ledger.rows[peer].edge_glyph.buttons[third].click()
+ held = ways.ways(app_config.load_settings(self.path), peer)
+ self.assertEqual(ways.picked_thirds(held["methods"], held["parts"]), list(subset))
+ self.assertEqual(picked(window, peer), list(subset))
+ self.assertEqual(window.atlas_canvas.states[peer]["thirds"], list(subset))
+ self._close_window()
+ self._open_window()
+ self.assertEqual(picked(self.window, peer), list(subset))
+
+ def test_last_third_off_and_click_while_off_on_ledger_and_map(self):
+ peer = self.peers[0]["id"]
+ for surface in ("ledger", "map"):
+ with self.subTest(surface=surface):
+ window = self.window
+ row = window.crossing_ledger.rows[peer]
+ if not picked(window, peer):
+ row.edge_text.click()
+ def click(third):
+ if surface == "ledger":
+ row.edge_glyph.buttons[third].click()
+ else:
+ QTest.mouseClick(window.atlas_canvas, Qt.MouseButton.LeftButton, pos=band_point(window.atlas_canvas, third))
+ for third in ways.PARTS:
+ click(third)
+ self.assertEqual(picked(window, peer), [])
+ self.assertEqual(row.edge_value.text(), "Off")
+ self.assertFalse(window.atlas_canvas.states[peer]["crosses"])
+ click("middle")
+ self.assertEqual(picked(window, peer), ["middle"])
+ self.assertEqual(row.edge_value.text(), "Middle third")
+ row.edge_text.click()
+ row.edge_text.click()
+ self.assertEqual(picked(window, peer), list(ways.PARTS))
+
+ def test_each_corner_on_and_off_round_trips(self):
+ peer = self.peers[0]["id"]
+ for corner in ways.CORNERS:
+ for on in (True, False):
+ with self.subTest(corner=corner, on=on):
+ self.window.crossing_ledger.rows[peer].corner_glyph.buttons[corner].click()
+ held = ways.ways(app_config.load_settings(self.path), peer)
+ self.assertEqual("corner" in held["methods"], on)
+ self.assertEqual(self.window.atlas_canvas.states[peer]["corner_way"], corner if on else "")
+ self._close_window()
+ self._open_window()
+ self.assertEqual(self.window.crossing_ledger.rows[peer].corner_glyph.buttons[corner].isChecked(), on)
+
+ def test_corner_moves_refuses_held_dot_and_pads_have_both_opacities(self):
+ first, second = [entry["id"] for entry in self.peers]
+ rows = self.window.crossing_ledger.rows
+ rows[first].corner_glyph.buttons["top_left"].click()
+ rows[first].corner_glyph.buttons["bottom_right"].click()
+ self.assertFalse(rows[first].corner_glyph.buttons["top_left"].isChecked())
+ before = app_config.load_settings(self.path)
+ self.assertFalse(rows[second].corner_glyph.buttons["bottom_right"].isEnabled())
+ self.assertEqual(rows[second].corner_glyph.buttons["bottom_right"].toolTip(), "MacBook Pro's corner")
+ rows[second].corner_glyph.buttons["bottom_right"].click()
+ self.assertEqual(app_config.load_settings(self.path), before)
+ rows[second].corner_glyph.buttons["bottom_left"].click()
+ self.window._choose_machine(second)
+ paint(self.window.atlas_canvas)
+ self.assertEqual(set(self.window.atlas_canvas.corner_marks), {(first, "bottom_right", .55), (second, "bottom_left", 1.0)})
+
+ def test_seam_and_track_stop_at_corner_halo(self):
+ peer = self.peers[0]["id"]
+ self.window._ledger_edge(peer)
+ self.window._ledger_corner(peer, "top_right")
+ self.window._ledger_third(peer, "start")
+ canvas = self.window.atlas_canvas
+ paint(canvas)
+ rect = canvas.tile_rect(canvas._own_id())
+ right_paths = [path for path in canvas.seam_paths if path[0] == "right"]
+ self.assertTrue(right_paths)
+ self.assertAlmostEqual(min(one.y() for _side, one, _two, _alpha, _width in right_paths), rect.top() + 11)
+
+ def test_shortcut_cycle_and_jump_chord_round_trip(self):
+ peer = self.peers[0]["id"]
+ row = self.window.crossing_ledger.rows[peer]
+ row.cycle.click()
+ row.jump.click()
+ QTest.keyClick(row.jump, Qt.Key.Key_F18, Qt.KeyboardModifier.AltModifier)
+ saved = next(entry for entry in app_config.load_settings(self.path)["peers"] if entry["id"] == peer)
+ self.assertFalse(saved["shortcut_cycle"])
+ self.assertEqual(saved["jump_key"], "alt+f18")
+ self._close_window()
+ self._open_window()
+ row = self.window.crossing_ledger.rows[peer]
+ self.assertFalse(row.cycle.isChecked())
+ self.assertEqual(row.jump.key.text(), "Alt F18")
+ self.assertTrue(row.clear.isVisible())
+ row.clear.click()
+ self.assertEqual(row.jump.key.text(), "Set a key")
+
+ def test_offline_and_left_out_rows_keep_intent_and_put_back_controls(self):
+ peer = self.peers[0]["id"]
+ self.window._ledger_edge(peer)
+ row = self.window.crossing_ledger.rows[peer]
+ self.window._live = lambda _peer: False
+ self.window._reflect_ways()
+ self.assertEqual(row.effect.opacity(), .5)
+ self.assertEqual(row.status.text(), "macOS · Offline, ways kept")
+ self.assertTrue(row.edge_text.isEnabled())
+ self.window._canvas_left_out(peer, True)
+ self.assertIs(row, self.window.crossing_ledger.rows[peer])
+ self.assertEqual(row.status.text(), "macOS · Left out")
+ self.assertEqual(row.leave.text(), "Put back")
+ self.assertFalse(row.edge_text.isEnabled())
+ self.assertEqual(picked(self.window, peer), list(ways.PARTS))
+ row.leave.click()
+ self.assertTrue(row.edge_text.isEnabled())
+
+ def test_narrow_has_no_horizontal_scroll_and_all_controls_fit(self):
+ self.window.resize(640, 700)
+ parity.settle(self.window)
+ ledger = self.window.crossing_ledger
+ self.assertTrue(ledger.narrow)
+ self.assertTrue(ledger.header.isHidden())
+ scroll = self.window.stack.currentWidget()
+ self.assertEqual(scroll.horizontalScrollBar().maximum(), 0)
+ for row in ledger.rows.values():
+ for control in (*row.cells, row.rename, row.leave, row.cycle, row.jump):
+ rect = control.mapTo(ledger, QPoint())
+ self.assertGreaterEqual(rect.x(), 0)
+ self.assertLessEqual(rect.x() + control.width(), ledger.width())
+
+ def test_accessibility_table_headers_and_named_stateful_controls(self):
+ ledger = self.window.crossing_ledger
+ self.assertEqual(QAccessible.queryAccessibleInterface(ledger).role(), QAccessible.Role.Table)
+ row = ledger.rows[self.peers[0]["id"]]
+ self.assertEqual(QAccessible.queryAccessibleInterface(row).role(), QAccessible.Role.Row)
+ self.assertEqual(QAccessible.queryAccessibleInterface(row.machine).role(), QAccessible.Role.RowHeader)
+ headers = ledger.header.findChildren(QWidget)
+ self.assertEqual([w.accessibleName() for w in headers if w.property("ledger_role") == "columnheader"], ["Machine", "Edge", "Corner", "Keys"])
+ for button in (*row.edge_glyph.buttons.values(), *row.corner_glyph.buttons.values()):
+ self.assertIn(", off", button.accessibleName())
+ self.assertEqual(QAccessible.queryAccessibleInterface(button).role(), QAccessible.Role.CheckBox)
+
+ def test_selection_and_cell_updates_keep_all_rows_in_place(self):
+ ledger = self.window.crossing_ledger
+ rows = dict(ledger.rows)
+ before = parity.descendants(ledger)
+ for peer in rows:
+ QTest.mouseClick(rows[peer].name, Qt.MouseButton.LeftButton)
+ self.assertEqual(self.window.atlas_canvas.selected, peer)
+ self.assertTrue(rows[peer].selected)
+ rows[peer].corner_glyph.buttons["top_left"].click()
+ self.assertEqual(ledger.rows, rows)
+ self.assertEqual(parity.descendants(ledger).keys(), before.keys())
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/win_app/tests/test_crossing_matrix.py b/win_app/tests/test_crossing_matrix.py
index 560e825..22897f7 100644
--- a/win_app/tests/test_crossing_matrix.py
+++ b/win_app/tests/test_crossing_matrix.py
@@ -280,13 +280,28 @@ class ArrangementHeldByBothTests(unittest.TestCase):
self.page = types.SimpleNamespace(
_config=default_config(), config_path=self.path, _on_alert=lambda title, message: None,
_pull_peer_fields=lambda: self.refreshed.append("pulled"),
- sender=types.SimpleNamespace(refresh=lambda: self.refreshed.append("sender")),
- server=types.SimpleNamespace(peers_changed=lambda: self.refreshed.append("server")),
+ sender=types.SimpleNamespace(refresh=lambda: self.refreshed.append("sender"),
+ update_config=lambda _: self.refreshed.append("updated")),
+ server=types.SimpleNamespace(peers_changed=lambda: self.refreshed.append("server"),
+ rearm=lambda: self.refreshed.append("rearmed")),
_tell=lambda peer: self.refreshed.append("answered"),
_live=lambda peer: True,
+ _gone=lambda peer: False,
+ _design_peer_caps=lambda: {},
+ _merge_layout_peers=lambda original, compiled: [
+ {entry.get("id"): entry for entry in compiled}.get(entry.get("id"), entry)
+ for entry in original
+ ],
_read_crossing=lambda: None,
+ _send_same=lambda **_: None,
_crossing_settings=lambda: app_config.load_settings(self.path),
)
+ self.page._config.machine_id = self.own
+ self.page._crossing_event_args = lambda: dict(platform="pc", capable={self.own},
+ live=self.page._live, gone=self.page._gone, now=1000)
+ self.page._carry_crossing = types.MethodType(kvm_bridge_win.WindowsApplication._carry_crossing, self.page)
+ self.page._reflect_ways = lambda: None
+ self.page._reflect_look = lambda: None
def arrive(self, edge, stamp, by=None):
kvm_bridge_win.WindowsApplication._on_arrangement(self.page, self.peer, edge, stamp, by or self.peer)
@@ -297,7 +312,7 @@ class ArrangementHeldByBothTests(unittest.TestCase):
def test_a_newer_arrangement_is_applied_as_this_pcs_opposite_edge(self):
self.arrive("top", 200)
self.assertEqual(self.side(), "bottom")
- self.assertEqual(self.refreshed, ["pulled", "sender", "server", "answered"])
+ self.assertEqual(self.refreshed, ["updated", "sender", "server", "rearmed", "answered"])
def test_an_older_arrangement_is_ignored(self):
self.arrive("top", 50)
@@ -311,19 +326,6 @@ class ArrangementHeldByBothTests(unittest.TestCase):
self.arrive("top", 200)
self.assertEqual(self.refreshed, [])
- def test_a_change_made_here_is_stamped_and_sent_to_that_machine(self):
- window = real_window(self.path)
- self.addCleanup(window.server.stop)
- told = []
- window._send_to = lambda peer, message: told.append((peer, message)) or False
- window._set_arrangement("top")
- entry = json.loads(self.path.read_text(encoding="utf-8"))["peers"][0]
- self.assertEqual((entry["side"], entry["side_by"]), ("top", self.own))
- self.assertGreater(entry["side_set_at"], 100)
- peer, message = told[0]
- self.assertEqual(peer, harness.B)
- self.assertEqual(message["data"], {"edge": "top", "set_at": entry["side_set_at"], "by": self.own, "way_back": True})
-
def test_a_fresh_config_holds_no_edge_though_the_crossing_page_offers_right(self):
# Pinned known gap (G3 in the report).
self.assertEqual(default_config().mac_return_edge, "")
@@ -350,6 +352,5 @@ class WaysReachTheDesignPageTests(unittest.TestCase):
looked = []
window._reflect_look = lambda: looked.append(sorted(window._ways_in()))
window._ways_changed("corner", True)
- window._set_part("start", True)
- self.assertEqual(len(looked), 2)
+ self.assertEqual(len(looked), 1)
self.assertIn("corner", looked[0])
diff --git a/win_app/tests/test_crossing_name_elision.py b/win_app/tests/test_crossing_name_elision.py
new file mode 100644
index 0000000..7433182
--- /dev/null
+++ b/win_app/tests/test_crossing_name_elision.py
@@ -0,0 +1,87 @@
+"""Long peer names fit in the wrapped Crossing summary."""
+
+import os
+import sys
+import unittest
+from pathlib import Path
+
+os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+sys.path.append(str(Path(__file__).resolve().parents[2]))
+
+from PySide6.QtCore import Qt
+from PySide6.QtGui import QTextLayout, QTextOption
+from PySide6.QtWidgets import QApplication, QLabel, QWidget
+
+import kvm_bridge_win
+
+
+LONG_NAME = "M" * 48
+
+
+class CrossingNameElisionTests(unittest.TestCase):
+ @classmethod
+ def setUpClass(cls):
+ cls.app = QApplication.instance() or QApplication([])
+
+ def make_summary_label(self):
+ page = QWidget()
+ page.resize(640, 400)
+ label = QLabel(page)
+ label.setWordWrap(True)
+ label.setGeometry(0, 0, 360, 100)
+ self.addCleanup(page.deleteLater)
+ return label
+
+ def summary_text(self, label, name):
+ return kvm_bridge_win.ways_summary_for_label(
+ label, ["edge"], "", [], "top_left", "Right Ctrl", "double_tap", name
+ )
+
+ def test_long_name_is_elided_and_wrapped_lines_fit_the_640_pixel_page(self):
+ label = self.make_summary_label()
+ label.setText(self.summary_text(label, LONG_NAME))
+ self.assertIn("…", label.text())
+
+ option = QTextOption(Qt.AlignmentFlag.AlignLeft)
+ option.setWrapMode(QTextOption.WrapMode.WordWrap)
+ layout = QTextLayout(label.text(), label.font(), label)
+ layout.setTextOption(option)
+ layout.beginLayout()
+ widths = []
+ while True:
+ line = layout.createLine()
+ if not line.isValid():
+ break
+ line.setLineWidth(label.contentsRect().width())
+ widths.append(line.naturalTextWidth())
+ layout.endLayout()
+ self.assertTrue(widths)
+ self.assertLessEqual(max(widths), label.contentsRect().width())
+
+ def test_short_name_stays_in_full(self):
+ label = self.make_summary_label()
+ label.setText(self.summary_text(label, "Studio PC"))
+ self.assertIn("Studio PC", label.text())
+ self.assertNotIn("…", label.text())
+
+ def test_a_label_laid_out_after_its_text_is_set_elides_on_its_resize(self):
+ # The Crossing page is hidden at start, so the sentence is set before the label has a width.
+ page = QWidget()
+ self.addCleanup(page.deleteLater)
+ label = QLabel(page)
+ label.setWordWrap(True)
+ refresh = lambda: label.setText(self.summary_text(label, LONG_NAME))
+ label.resize(0, 0)
+ hook = kvm_bridge_win._OnResize(label, refresh)
+ refresh()
+ self.assertIn(LONG_NAME, label.text())
+ label.resize(360, 100)
+ page.show()
+ self.app.processEvents()
+ self.assertIn("…", label.text())
+ self.assertIsNotNone(hook)
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/win_app/tests/test_crossing_outcomes.py b/win_app/tests/test_crossing_outcomes.py
new file mode 100644
index 0000000..32691c5
--- /dev/null
+++ b/win_app/tests/test_crossing_outcomes.py
@@ -0,0 +1,83 @@
+"""The PC carries shared crossing outcomes through save, engines and wire messages."""
+import copy
+import tempfile
+import unittest
+from pathlib import Path
+from unittest import mock
+
+import app_config
+import kvm_bridge_win as kvm
+from core import crossing_state, protocol, ways
+from core.tests import responder_harness as h
+
+
+class CrossingOutcomes(unittest.TestCase):
+ def test_pairing_after_empty_start_adds_a_tile_and_saves_the_peer(self):
+ with tempfile.TemporaryDirectory() as folder:
+ window = mock.Mock()
+ window.config_path = Path(folder) / "settings.json"
+ saved = app_config.load_settings(window.config_path)
+ window._own_displays.return_value = {}
+ window._layout_capable.return_value = {saved["machine_id"]}
+ window._carry_crossing.side_effect = lambda out, **_: app_config.write_settings(window.config_path, out["settings"])
+ entry = h.entry(h.B, "Studio", side="right")
+ kvm.WindowsApplication._store_peer(window, entry, None)
+ result = app_config.load_settings(window.config_path)
+ self.assertEqual(result["peers"][0]["id"], entry["id"])
+ self.assertIn(entry["id"], result["layout"])
+
+ def test_picture_peer_arrangement_keeps_position_and_side(self):
+ with tempfile.TemporaryDirectory() as folder:
+ path = Path(folder) / "settings.json"
+ settings = app_config.migrate(None, machine_id=protocol.id_text(h.HERE))
+ peer = protocol.id_text(h.B)
+ settings["peers"] = [h.entry(h.B, "Studio", side="right")]
+ settings = crossing_state.paired(settings, platform="pc", own_displays={}, now=100)["settings"]
+ app_config.write_settings(path, settings)
+ before = app_config.load_settings(path)
+ changed, notices = app_config.apply_arrangement(path, peer, "top", 200, peer,
+ False, capable={peer})
+ after = app_config.load_settings(path)
+ self.assertTrue(changed)
+ self.assertEqual(notices, [])
+ self.assertEqual(after["layout"], before["layout"])
+ self.assertEqual(after["peers"][0]["side"], before["peers"][0]["side"])
+ self.assertFalse(after["peers"][0]["way_back"])
+
+ def test_outcome_rebuilds_and_rearms_before_messages(self):
+ calls = []
+ window = mock.Mock()
+ window.config_path = Path("synthetic")
+ window._config = app_config.default_config()
+ window.sender.update_config.side_effect = lambda *_: calls.append("update")
+ window.sender.refresh.side_effect = lambda: calls.append("refresh")
+ window.server.peers_changed.side_effect = lambda: calls.append("peers")
+ window.server.rearm.side_effect = lambda: calls.append("rearm")
+ window._tell.side_effect = lambda p: calls.append(("tell", p))
+ window._send_same.side_effect = lambda **kw: calls.append(("picture", kw))
+ saved = app_config.migrate(None)
+ outcome = crossing_state.migrate(saved, "pc")
+ outcome.update(changed=True, tell=["peer"], send_picture=True, forward_picture=True)
+ with mock.patch.object(app_config, "write_settings", side_effect=lambda *_: calls.append("save")):
+ kvm.WindowsApplication._carry_crossing(window, outcome, source=protocol.id_text(h.B), arrived={"layout": 1})
+ self.assertEqual(calls[:6], ["save", "update", "refresh", "peers", "rearm", ("tell", "peer")])
+ self.assertEqual(calls[6:], [("picture", {"layout_only": True}),
+ ("picture", {"source": h.B, "data": {"layout": 1}, "layout_only": True})])
+
+ def test_load_migrates_legacy_intent_once(self):
+ with tempfile.TemporaryDirectory() as folder:
+ path = Path(folder) / "settings.json"
+ settings = app_config.migrate(None, machine_id=protocol.id_text(h.HERE))
+ peer = protocol.id_text(h.B)
+ settings["peers"] = [h.entry(h.B, "Studio", side="right")]
+ settings["zones"] = [{"peer": peer, "kind": "edge", "off": True, "page_off": True}]
+ app_config.write_settings(path, settings)
+ saved = app_config.load_settings(path)
+ self.assertFalse(saved["peers"][0]["ways"]["edge"])
+ saved["zones"] = [{"peer": peer, "kind": "edge"}]
+ app_config.write_settings(path, saved)
+ self.assertFalse(app_config.load_settings(path)["peers"][0]["ways"]["edge"])
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/win_app/tests/test_crossing_page_parity.py b/win_app/tests/test_crossing_page_parity.py
new file mode 100644
index 0000000..f796c8b
--- /dev/null
+++ b/win_app/tests/test_crossing_page_parity.py
@@ -0,0 +1,242 @@
+"""Crossing parity and repaint stability with synthetic linked desktop peers."""
+
+import base64
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+from unittest.mock import patch
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from PySide6.QtCore import QCoreApplication, QEvent, QObject, QPoint, Qt
+from PySide6.QtTest import QTest
+from PySide6.QtWidgets import QApplication, QCheckBox, QLabel, QWidget
+
+import app_config
+import diagram
+import kvm_bridge_win as kvm
+import motion
+import pages_win
+import theme
+import widgets
+from core import pairing, peerlist
+from core.receiver import ServerState
+
+
+def settle(window):
+ for child in window.crossing_document.findChildren(QWidget):
+ animation = motion._runs(child).get("shown")
+ if animation is not None:
+ animation.setCurrentTime(animation.duration())
+ for _ in range(8):
+ QCoreApplication.sendPostedEvents(None, QEvent.Type.DeferredDelete)
+ QCoreApplication.sendPostedEvents(None, QEvent.Type.LayoutRequest)
+ QApplication.processEvents()
+
+
+def descendants(root):
+ return {id(widget): widget for widget in root.findChildren(QWidget)}
+
+
+def position(widget, root):
+ return widget.mapTo(root, QPoint())
+
+
+class CrossingPageParityTests(unittest.TestCase):
+ def setUp(self):
+ self.app = QApplication.instance() or QApplication([])
+ theme.init_fonts()
+ self.app.setFont(theme.font(theme.TYPE["body"]))
+ self.patches = []
+ for name, value in (("installed_exe", lambda: Path("Beamer.exe")),
+ ("is_enabled", lambda: False),
+ ("can_run_for_current_user", lambda: False)):
+ patcher = patch.object(kvm.autostart_win, name, value)
+ patcher.start()
+ self.patches.append(patcher)
+ self.addCleanup(self._stop_patches)
+ temp_root = Path(__file__).resolve().parents[1] / '.test-tmp'
+ temp_root.mkdir(parents=True, exist_ok=True)
+ self.tempdir = tempfile.TemporaryDirectory(dir=temp_root)
+ self.addCleanup(self.tempdir.cleanup)
+ settings = app_config.migrate({"appearance": "dark", "name": "Studio Linux", "peers": [], "check_updates": False})
+ settings.update(name="Studio Linux", check_updates=False)
+ self.peers = []
+ for index, (name, platform) in enumerate((("MacBook Pro", "macos"), ("Desktop PC", "windows"))):
+ token = base64.urlsafe_b64encode(bytes([40 + index]) * 32).decode("ascii").rstrip("=")
+ entry = pairing.peer_entry(bytes([index + 1]) * 16, name, platform, 24820 + index,
+ token, f"192.168.1.{10 + index}", 1791321600 + index)
+ entry["linked"] = True
+ peerlist.add_peer(settings, entry)
+ self.peers.append(entry)
+ self.path = Path(self.tempdir.name) / "settings.json"
+ app_config.write_settings(self.path, settings)
+ app_config.set_ways(self.path, self.peers[0]["id"], side="right", methods=[], parts=[], corner="top_left")
+ app_config.set_ways(self.path, self.peers[1]["id"], side="left", methods=[], parts=[], corner="top_left")
+ settings = app_config.load_settings(self.path)
+ own = settings["machine_id"]
+ settings["layout"] = {own: {"x": 0, "y": 0, "w": 160, "h": 100},
+ self.peers[0]["id"]: {"x": 160, "y": 0, "w": 160, "h": 100},
+ self.peers[1]["id"]: {"x": -160, "y": 0, "w": 160, "h": 100}}
+ app_config.write_settings(self.path, settings)
+ self._open_window()
+
+ def _open_window(self):
+ self.window = kvm.WindowsApplication(self.path)
+ self.window.full_screen_timer.stop()
+ self.window.refresh_timer.stop()
+ self.window._set_status(ServerState.CONNECTED, "Connected to 192.168.1.10")
+ self.window.sender.links.up = lambda _peer: True
+ self.window.sender._sock = object()
+ self.window.sender.refresh = lambda: None
+ self.window.server.peers_changed = lambda: None
+ self.window._sync_sending = lambda: None
+ self.window._read_crossing()
+ self.window._chosen = self.peers[0]["id"]
+ self.window._reflect_ways()
+ self.window.setAttribute(Qt.WidgetAttribute.WA_DontShowOnScreen, True)
+ self.window.resize(900, 700)
+ self.window.show()
+ self.window._select_page("crossing")
+ settle(self.window)
+
+ def _stop_patches(self):
+ for patcher in reversed(self.patches):
+ patcher.stop()
+
+ def tearDown(self):
+ self._close_window()
+
+ def _close_window(self):
+ self.window.sender._sock = None
+ self.window.close()
+ self.window.deleteLater()
+ QCoreApplication.sendPostedEvents(None, QEvent.Type.DeferredDelete)
+ self.app.processEvents()
+
+ def test_option_changes_keep_widgets_and_paint_one_batch(self):
+ window, peer = self.window, self.peers[0]["id"]
+ document = window.crossing_document
+ row = window.crossing_ledger.rows[peer]
+ previous = descendants(document)
+ for change in (
+ lambda: window._ledger_edge(peer),
+ lambda: window._ledger_third(peer, "middle"),
+ lambda: window._ledger_corner(peer, "top_right"),
+ lambda: window._ledger_corner(peer, "top_right"),
+ lambda: window._set_shortcut_cycle(peer, False),
+ lambda: window._choose_machine(self.peers[1]["id"]),
+ lambda: window._canvas_left_out(peer, True),
+ lambda: window._canvas_left_out(peer, False),
+ ):
+ batches = []
+ original = document.setUpdatesEnabled
+ with patch.object(document, "setUpdatesEnabled", lambda value: (batches.append(value), original(value))[1]):
+ change()
+ settle(window)
+ self.assertEqual(batches, [False, True])
+ self.assertIs(window.crossing_ledger.rows[peer], row)
+ self.assertEqual(descendants(document).keys(), previous.keys())
+
+ def test_guard_restores_updates_after_failure_and_respects_an_outer_freeze(self):
+ document = self.window.crossing_document
+ with patch.object(self.window.atlas_canvas, "set_tiles", side_effect=RuntimeError("Synthetic refresh failure")):
+ with self.assertRaisesRegex(RuntimeError, "Synthetic refresh failure"):
+ self.window._reflect_ways()
+ self.assertTrue(document.updatesEnabled())
+ self.assertEqual(self.window._crossing_update_depth, 0)
+ document.setUpdatesEnabled(False)
+ self.window._reflect_ways()
+ self.assertFalse(document.updatesEnabled())
+ document.setUpdatesEnabled(True)
+
+ def test_ledger_and_modules_match_the_reference_order(self):
+ window = self.window
+ peer = self.peers[0]["id"]
+ window._ledger_edge(peer)
+ row = window.crossing_ledger.rows[peer]
+ self.assertEqual(row.edge_value.text(), "Whole edge")
+ self.assertEqual(row.corner_value.text(), "None")
+ self.assertEqual(row.cycle.text(), "Right Ctrl")
+ self.assertEqual(row.jump.key.text(), "Set a key")
+ self.assertTrue(row.corner_glyph.buttons["top_left"].isEnabled())
+ self.assertFalse(hasattr(window, "way_boxes"))
+ self.assertFalse(hasattr(window, "left_out_shelf"))
+ sequence = (window.ways_module, window.pointer_module, window.resistance_module, window.shortcut_module)
+ ys = [position(item, window.crossing_document).y() for item in sequence]
+ self.assertEqual(ys, sorted(ys))
+ self.assertFalse(hasattr(window, "route_readout"))
+
+ def test_edge_toggle_keeps_corner_pointer_and_jump_visible(self):
+ window, peer = self.window, self.peers[0]["id"]
+ row = window.crossing_ledger.rows[peer]
+ watched = (row.corner_cell, window.pointer_module, row.jump)
+ for on in (True, False):
+ window._ways_changed("edge", on)
+ settle(window)
+ self.assertTrue(all(not widget.isHidden() for widget in watched))
+ self.assertEqual(window.dragging_switch.isEnabled(), on)
+
+ def test_edge_off_clears_map_crossing_and_reticking_restores_the_whole_edge(self):
+ window, peer = self.window, self.peers[0]["id"]
+ window._ledger_edge(peer)
+ window._ledger_third(peer, "middle")
+ window._ledger_edge(peer)
+ state = window.atlas_canvas.states[peer]
+ self.assertFalse(state["crosses"])
+ self.assertTrue(state["edge_off"])
+ self.assertEqual(window.crossing_ledger.rows[peer].edge_value.text(), "Off")
+ window._ledger_edge(peer)
+ self.assertTrue(window.atlas_canvas.states[peer]["crosses"])
+ self.assertEqual(window.crossing_ledger.rows[peer].edge_value.text(), "Whole edge")
+
+ def test_shortcut_settings_and_figures_keep_their_order(self):
+ window = self.window
+ module = window.shortcut_module
+ sequence = (window.trigger_recorder, window.trigger_style_row, window.shortcut_target_row,
+ window.shortcut_target_note, window.double_tap_row, window.style_hint)
+ self.assertEqual([position(item, module).y() for item in sequence],
+ sorted(position(item, module).y() for item in sequence))
+ self.assertIsInstance(window.resistance_readout, widgets.Figure)
+ self.assertIsInstance(window.double_tap_readout, widgets.Figure)
+ self.assertEqual(window.double_tap_slider.ticks, (50, 150, 300, 600, 1000))
+
+ def test_ledger_controls_fit_at_640_and_900(self):
+ for width in (640, 900):
+ self.window.resize(width, 700)
+ settle(self.window)
+ ledger = self.window.crossing_ledger
+ for row in ledger.rows.values():
+ for control in (*row.cells, row.rename, row.leave, row.jump, row.cycle):
+ point = position(control, ledger)
+ self.assertGreaterEqual(point.x(), 0)
+ self.assertLessEqual(point.x() + control.width(), ledger.width() + 1)
+
+ def test_keys_tick_supports_keyboard_and_accessibility(self):
+ row = self.window.crossing_ledger.rows[self.peers[0]["id"]]
+ self.assertEqual(row.cycle.toolTip(), "In the shortcut's cycle")
+ self.assertEqual(row.cycle.focusPolicy(), Qt.FocusPolicy.StrongFocus)
+ checked = row.cycle.isChecked()
+ row.cycle.setFocus()
+ QTest.keyClick(row.cycle, Qt.Key.Key_Space)
+ self.assertNotEqual(row.cycle.isChecked(), checked)
+
+ def test_shelved_machine_keeps_its_row_and_put_back_action(self):
+ window, peer = self.window, self.peers[0]["id"]
+ row = window.crossing_ledger.rows[peer]
+ window._canvas_left_out(peer, True)
+ self.assertIs(window.crossing_ledger.rows[peer], row)
+ self.assertEqual(row.leave.text(), "Put back")
+ self.assertIn("Left out", row.status.text())
+ row.leave.click()
+ self.assertIs(window.crossing_ledger.rows[peer], row)
+ self.assertEqual(row.leave.text(), "Leave out")
+
+ def test_destination_note_matches_the_mac(self):
+ for mode, hold, expected in (
+ ("last", False, "With Hold, input goes to the last machine."),
+ ("next", True, "With Hold, input goes to the first ready machine in order."),
+ ("next", False, "The order follows the tiles from top to bottom, then left to right. This PC is always in the cycle."),
+ ):
+ self.assertEqual(pages_win.shortcut_destination_note(mode, hold), expected)
diff --git a/win_app/tests/test_design_sliders.py b/win_app/tests/test_design_sliders.py
new file mode 100644
index 0000000..4c546b8
--- /dev/null
+++ b/win_app/tests/test_design_sliders.py
@@ -0,0 +1,74 @@
+import os
+import sys
+import unittest
+from pathlib import Path
+
+os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from PySide6.QtCore import Qt
+from PySide6.QtTest import QTest
+from PySide6.QtWidgets import QApplication
+
+import kvm_bridge_win
+import app_config
+from core import effects
+
+
+class LengthSizeSliderTests(unittest.TestCase):
+ def setUp(self):
+ self.app = QApplication.instance() or QApplication([])
+ self.length = kvm_bridge_win._DesignChoiceSlider(
+ "Length", 25, 250, 5, 100, (0.5, 1.0, 2.0), effects.LENGTHS)
+ self.size = kvm_bridge_win._DesignChoiceSlider(
+ "Size", 20, 80, 1, 1000, (0.03, 0.045, 0.06), effects.SIZES)
+
+ def tearDown(self):
+ self.length.slider.close()
+ self.size.slider.close()
+
+ def test_slider_detent_and_keyboard_step(self):
+ control = self.length
+ control.set_numeric(0.53)
+ control._snap(53)
+ self.assertEqual(control.numeric_value(), 0.5)
+ slider = control.slider
+ slider.setValue(100)
+ QTest.keyClick(slider, Qt.Key.Key_Right)
+ self.assertEqual(slider.value(), 105)
+
+ def test_slider_can_be_disabled_while_following_another_design(self):
+ self.length.set_enabled(False)
+ self.assertFalse(self.length.slider.isEnabled())
+ self.length.set_enabled(True)
+ self.assertTrue(self.length.slider.isEnabled())
+
+ def test_design_sliders_keep_their_logical_width_cap(self):
+ self.assertEqual(self.length.view.maximumWidth(), 240)
+ self.assertEqual(self.size.view.maximumWidth(), 240)
+
+ def test_playback_and_depth_readouts_keep_fixed_width(self):
+ length, size = effects.design_slider_readouts("beam", 2.0, 0.06, 1920, 1080)
+ length_readout, size_readout = kvm_bridge_win.design_readout(), kvm_bridge_win.design_readout()
+ length_readout.setText(length)
+ size_readout.setText(size)
+ self.assertEqual(length_readout.text(), "1.2 s")
+ self.assertTrue(size_readout.text().endswith(" pt"))
+ self.assertEqual(length_readout.width(), 58)
+ self.assertEqual(size_readout.width(), 58)
+ self.assertEqual(effects.play_through_seconds("beam", 2.0), 1.2)
+ self.assertIn("playback time", self.length.slider.accessibleDescription())
+
+ def test_preset_only_windows_settings_migrate_and_round_trip_both_forms(self):
+ config = app_config.config_from_dict({
+ "host": "192.0.2.1", "port": 51820, "auth_token": "synthetic",
+ "effect_length": "long", "effect_size": "small",
+ })
+ saved = app_config.config_to_dict(config)
+ self.assertEqual((saved["effect_pace"], saved["effect_size_fraction"],
+ saved["effect_length"], saved["effect_size"]),
+ (2.0, 0.03, "long", "small"))
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/win_app/tests/test_design_tiles.py b/win_app/tests/test_design_tiles.py
index 39d77bf..473881f 100644
--- a/win_app/tests/test_design_tiles.py
+++ b/win_app/tests/test_design_tiles.py
@@ -2,19 +2,23 @@
import colorsys
import os
+import sys
import tempfile
import unittest
from pathlib import Path
+from unittest import mock
os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
try:
- from PySide6.QtCore import QCoreApplication, QEvent, QPoint, QPointF
- from PySide6.QtGui import QColor, QEnterEvent, QPalette
+ from PySide6.QtCore import QCoreApplication, QEvent, QPoint, QPointF, QRectF
+ from PySide6.QtGui import QColor, QEnterEvent, QImage, QPainter, QPalette
from PySide6.QtWidgets import QApplication, QWidget
+ sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
import kvm_bridge_win
import theme
- from test_settings_layout_acceptance import SyntheticWindow, write_synthetic_settings
+ import tokens
+ from test_settings_layout_acceptance import SyntheticWindow, responder_harness, write_synthetic_settings
except ImportError:
kvm_bridge_win = None
@@ -53,11 +57,10 @@ class DesignTilesTest(unittest.TestCase):
self.app = QApplication.instance() or QApplication([])
theme.init_fonts()
self.app.setFont(theme.font(theme.TYPE["body"]))
- scratch = Path(__file__).resolve().parents[2] / "renders" / "test-working"
- scratch.mkdir(parents=True, exist_ok=True)
- self.folder = tempfile.TemporaryDirectory(dir=scratch)
+ self.folder = tempfile.TemporaryDirectory()
folder = Path(self.folder.name)
- self.window = SyntheticWindow(write_synthetic_settings(folder))
+ with mock.patch.object(responder_harness, "free_port", return_value=24820):
+ self.window = SyntheticWindow(write_synthetic_settings(folder))
self.window.full_screen_timer.stop()
self.window.refresh_timer.stop()
self.window._select_page("design")
@@ -99,7 +102,7 @@ class DesignTilesTest(unittest.TestCase):
tile.mapTo(self.choice.view, QPoint()).y(), tile.width(), tile.height())
for group in self.choice.groups.values() for value, tile in group._tiles.items()}
- def test_hover_is_neutral_and_selected_has_accent_and_an_extra_cue(self):
+ def test_hover_is_neutral_and_selected_has_a_circle_badge_before_its_name(self):
self.window.resize(1200, 900)
self.choice.set_value("beam")
self.settle()
@@ -112,14 +115,11 @@ class DesignTilesTest(unittest.TestCase):
"hover's border contains the selection accent")
self.assertGreater(accent_pixels(selected, border_points(selected)), 20)
scale = selected.devicePixelRatio()
- badge = [(x, y) for x in range(selected.width() - round(26 * scale),
- selected.width() - round(4 * scale))
- for y in range(round(4 * scale), round(26 * scale))]
- badge_extra = accent_pixels(selected, badge) - accent_pixels(unselected, badge)
- middle = selected.width() // 2
- thicker_ring = accent_pixels(selected, [(middle, y) for y in range(round(4 * scale))])
- self.assertTrue(badge_extra >= 20 * scale * scale or thicker_ring >= round(3 * scale),
- f"selection has no extra cue: badge delta {badge_extra}, ring pixels {thicker_ring}")
+ name = self.choice.tile("glow").name_label.geometry()
+ check = [(x, y) for x in range(round(name.x() * scale), round((name.x() + 16) * scale))
+ for y in range(round(name.y() * scale), round(name.bottom() * scale))]
+ badge_extra = accent_pixels(selected, check) - accent_pixels(unselected, check)
+ self.assertGreaterEqual(badge_extra, 100 * scale * scale, "selection has no filled badge before its name")
def test_hover_background_brightens_in_both_appearances(self):
previous = theme.is_dark()
diff --git a/win_app/tests/test_desktop_portal_cache.py b/win_app/tests/test_desktop_portal_cache.py
new file mode 100644
index 0000000..f660190
--- /dev/null
+++ b/win_app/tests/test_desktop_portal_cache.py
@@ -0,0 +1,38 @@
+"""Wayland input readers consume Qt geometry captured by the GUI thread."""
+
+import threading
+import unittest
+from unittest import mock
+
+from PySide6.QtWidgets import QApplication
+from core.return_edge import Rect
+import desktop_portal
+
+
+class DesktopPortalCache(unittest.TestCase):
+ def test_worker_readers_never_enumerate_qt_screens(self):
+ app = QApplication.instance() or QApplication([])
+ desktop_portal.set_zones([])
+ desktop_portal.set_regions([])
+ desktop_portal.refresh_qt_screens()
+ expected = desktop_portal.display_map()
+ results = []
+ with mock.patch("PySide6.QtGui.QGuiApplication.screens", side_effect=AssertionError("worker Qt read")) as screens:
+ thread = threading.Thread(target=lambda: results.append((desktop_portal.display_map(), desktop_portal.monitors())))
+ thread.start()
+ thread.join(2)
+ screens.assert_not_called()
+ self.assertEqual(results[0][0], expected)
+
+ def test_gui_refresh_updates_geometry_and_keeps_portal_zone_precedence(self):
+ app = QApplication.instance() or QApplication([])
+ desktop_portal.refresh_qt_screens()
+ self.assertTrue(desktop_portal.display_map())
+ zone = Rect(10, 20, 300, 200)
+ desktop_portal.set_zones([zone])
+ self.addCleanup(desktop_portal.set_zones, [])
+ self.assertEqual(desktop_portal.monitors(), [zone])
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/win_app/tests/test_dormant_rows.py b/win_app/tests/test_dormant_rows.py
new file mode 100644
index 0000000..260bbc2
--- /dev/null
+++ b/win_app/tests/test_dormant_rows.py
@@ -0,0 +1,246 @@
+import os
+import sys
+import unittest
+import copy
+import tempfile
+from types import SimpleNamespace
+from pathlib import Path
+from unittest import mock
+
+os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+sys.path.insert(0, str(Path(__file__).resolve().parents[2] / "win_app"))
+
+from PySide6.QtWidgets import QApplication
+
+import peers_view
+import pages_win
+import kvm_bridge_win
+from machines_win import PairingSheet, PeerRow
+from core import pairing
+from core import protocol
+from core.tests import responder_harness as harness
+import app_config
+
+
+APP = QApplication.instance() or QApplication([])
+
+
+class DormantRowTests(unittest.TestCase):
+ def test_dormant_machines_mark_overview_and_crossing_for_attention(self):
+ self.assertEqual(pages_win.dots(False, None, dormant=True),
+ {"overview": "amber", "crossing": "amber"})
+
+ def test_row_shows_needs_repair_and_reason(self):
+ state = peers_view.describe({"dormant": True, "dormant_reason": "forgotten", "send": True}, "Desk",
+ up=False, driving=False, input_there=False, kind="unreachable", status="offline",
+ waking=False)
+ self.assertEqual((state.word, state.detail), ("Needs re-pair", "The other machine no longer has this pairing."))
+
+ def test_peer_row_exposes_a_repair_action(self):
+ called = []
+ row = PeerRow("token", lambda *_: None, lambda *_: None, lambda *_: None, lambda *_: None,
+ lambda *_: None, on_repair=called.append)
+ self.assertTrue(hasattr(row, "repair_button"))
+ self.assertIn("Re-pair", row.repair_button.text())
+ state = peers_view.describe({"dormant": True, "dormant_reason": "forgotten", "send": True}, "Desk",
+ up=False, driving=False, input_there=False, kind="none", status="", waking=False)
+ row.refresh({"id": "id", "name": "Desk", "port": 24820, "dormant": True,
+ "dormant_reason": "forgotten"}, "Desk", state, "Windows", cycle_mode="last")
+ self.assertFalse(row.repair_button.isHidden())
+ row.repair_button.click()
+ self.assertEqual(called, ["token"])
+
+ def test_re_pair_opens_the_existing_sheet_for_the_saved_address(self):
+ app = SimpleNamespace(
+ _peer_entries=[{"token": "token", "host": "192.0.2.10"}],
+ _hide_addresses=lambda: False,
+ _pairing_open=False,
+ sheet=SimpleNamespace(address=mock.Mock(), setVisible=mock.Mock()),
+ machines=SimpleNamespace(set_pairing_open=mock.Mock()),
+ _refresh_pairing=mock.Mock(),
+ _select_page=mock.Mock(),
+ )
+
+ kvm_bridge_win.WindowsApplication._re_pair(app, "token")
+
+ self.assertTrue(app._pairing_open)
+ app.sheet.address.setText.assert_called_once_with("192.0.2.10")
+ app.sheet.setVisible.assert_called_once_with(True)
+ app.machines.set_pairing_open.assert_called_once_with(True)
+ app._refresh_pairing.assert_called_once_with()
+
+ def test_programmatic_repair_selection_checks_the_real_discovery_button(self):
+ selected = []
+ sheet = PairingSheet(lambda: None, lambda: None, lambda *args: None, selected.append)
+ sheet.set_machines([
+ {"name": "Desk", "address": "192.0.2.10", "platform": "windows",
+ "pairing": pairing.PAIRING_V3, "pair_id": "pair"},
+ {"name": "Other", "address": "192.0.2.11", "platform": "windows",
+ "pairing": pairing.PAIRING_V3, "pair_id": "other"},
+ ])
+ sheet.code.setText("123456")
+
+ sheet._pick("192.0.2.10")
+
+ self.assertEqual(sheet.chosen_machine()["address"], "192.0.2.10")
+ self.assertTrue(sheet.pair_button.isEnabled())
+ self.assertEqual(selected[-1]["address"], "192.0.2.10")
+
+ def test_re_pair_with_hidden_addresses_selects_the_saved_discovery_machine(self):
+ machines = [
+ {"name": "Desk", "address": "192.0.2.10", "platform": "windows",
+ "pairing": pairing.PAIRING_V3, "pair_id": "pair"},
+ {"name": "Other", "address": "192.0.2.11", "platform": "windows",
+ "pairing": pairing.PAIRING_V3, "pair_id": "other"},
+ ]
+ selected = []
+ sheet = PairingSheet(lambda: None, lambda: None, lambda *args: None, selected.append)
+ sheet.set_machines(machines)
+ sheet.code.setText("123456")
+ sheet._pick("192.0.2.11")
+ app = SimpleNamespace(
+ _peer_entries=[{"token": "token", "host": "192.0.2.10"}],
+ _hide_addresses=lambda: True,
+ _pairing_open=False,
+ _shown=lambda text: text,
+ pairing=SimpleNamespace(machines=lambda: machines),
+ sheet=sheet,
+ machines=SimpleNamespace(set_pairing_open=mock.Mock()),
+ _refresh_pairing=lambda: sheet.set_machines(machines),
+ _select_page=mock.Mock(),
+ )
+
+ kvm_bridge_win.WindowsApplication._re_pair(app, "token")
+
+ self.assertEqual(sheet.chosen_machine()["address"], "192.0.2.10")
+ self.assertTrue(sheet.pair_button.isEnabled())
+ self.assertEqual(selected[-1]["address"], "192.0.2.10")
+
+
+class DormantCrossingTests(unittest.TestCase):
+ def setUp(self):
+ self.directory = tempfile.TemporaryDirectory()
+ self.addCleanup(self.directory.cleanup)
+ self.path = Path(self.directory.name) / "settings.json"
+ self.peer = protocol.id_text(harness.B)
+ self.other = protocol.id_text(harness.C)
+ self.own = protocol.id_text(harness.HERE)
+ settings = app_config.migrate(None, machine_id=self.own)
+ settings["peers"] = [harness.entry(harness.B, "Desk", side="right", dormant=True,
+ dormant_reason="forgotten"),
+ harness.entry(harness.C, "Other", side="left")]
+ settings["zones"] = [{"peer": self.peer, "kind": "edge"}, {"peer": self.other, "kind": "edge"}]
+ settings["layout"] = {self.own: {"x": 0, "y": 0, "w": 160, "h": 100},
+ self.peer: {"x": 160, "y": 0, "w": 160, "h": 100},
+ self.other: {"x": -160, "y": 0, "w": 160, "h": 100}}
+ app_config.write_settings(self.path, settings)
+ with mock.patch.object(kvm_bridge_win.WindowsApplication, "_build_tray", lambda window: setattr(window, "tray", mock.Mock())), \
+ mock.patch.object(kvm_bridge_win.WindowsApplication, "_refresh_window"):
+ self.window = kvm_bridge_win.WindowsApplication(self.path)
+ self.window.full_screen_timer.stop()
+ self.addCleanup(self.window.server.stop)
+ self.addCleanup(self.window.deleteLater)
+
+ def test_persisted_dormant_peer_is_off_the_map_but_kept_in_the_ledger(self):
+ window = self.window
+ self.assertIn(self.peer, window.atlas_canvas.shelf_ids)
+ self.assertNotIn(self.peer, window.atlas_canvas.tiles)
+ self.assertIn(self.peer, window.crossing_ledger.rows)
+ window._choose_machine(self.peer)
+ self.assertTrue(window.crossing_ledger.rows[self.peer].selected)
+ self.assertFalse(hasattr(window, "left_out_shelf"))
+ self.assertFalse(hasattr(window, "dormant_note"))
+
+ def test_dormant_tile_cannot_be_moved_with_the_canvas_keyboard(self):
+ from PySide6.QtCore import Qt
+ from PySide6.QtTest import QTest
+
+ canvas = self.window.atlas_canvas
+ canvas.selected = self.peer
+ before = copy.deepcopy(canvas.tiles)
+ self.assertIn(self.peer, canvas.shelf_ids)
+ self.assertNotIn(self.peer, canvas.tiles)
+ QTest.keyClick(canvas, Qt.Key.Key_Down)
+ self.assertEqual(canvas.tiles, before)
+ self.assertIn(self.peer, canvas.shelf_ids)
+
+ def test_dormant_position_does_not_block_an_active_edge_snap(self):
+ settings = app_config.load_settings(self.path)
+ tiles = copy.deepcopy(settings["layout"])
+ tiles[self.other]["x"] = 166
+ tiles[self.other]["y"] = 17
+ with mock.patch.object(self.window, "_tell"), mock.patch.object(self.window, "_send_same"), \
+ mock.patch.object(self.window.sender, "refresh"):
+ self.assertTrue(self.window._layout_dropped(tiles, self.other))
+ saved = app_config.load_settings(self.path)
+ self.assertEqual(saved["layout"][self.other]["x"], 160)
+ self.assertEqual(saved["layout"][self.peer], settings["layout"][self.peer])
+ self.assertEqual([zone for zone in saved["zones"] if zone["peer"] == self.peer],
+ [zone for zone in settings["zones"] if zone["peer"] == self.peer])
+
+ def test_incoming_layout_moves_shelved_positions_but_keeps_local_intent(self):
+ from core import settings_sync
+
+ settings = app_config.load_settings(self.path)
+ settings["peers"][1]["in_use"] = False
+ settings["peers"].append(harness.entry(harness.D, "Sender", side="right"))
+ settings["layout"][protocol.id_text(harness.D)] = {"x": 0, "y": 120, "w": 160, "h": 100}
+ settings["zones"].append({"peer": protocol.id_text(harness.D), "kind": "edge"})
+ app_config.write_settings(self.path, settings)
+ settings = app_config.load_settings(self.path)
+ window = self.window
+ window._peer_entries = settings["peers"]
+ source = protocol.id_text(harness.D)
+ window._peer_caps = lambda: {harness.D: {"settings", "layout"}}
+ window._design_peer_caps = lambda: {source: {"settings", "layout"}}
+ original = copy.deepcopy(settings)
+ incoming = copy.deepcopy(settings["layout"])
+ incoming[self.peer]["x"] = 320
+ incoming[self.other]["x"] = -320
+ message = settings_sync.message_data(False, 0, by=source,
+ layout_state={"tiles": incoming, "set_at": 1, "by": source})
+
+ with mock.patch.object(window, "_send_same"), mock.patch.object(window, "_read_crossing"), \
+ mock.patch.object(window, "_reflect_config"), mock.patch.object(window, "_tell"), \
+ mock.patch.object(window.sender, "update_config"), mock.patch.object(window.sender, "refresh"), \
+ mock.patch.object(window.server, "peers_changed"):
+ window._on_settings(source, message)
+
+ saved = app_config.load_settings(self.path)
+ self.assertEqual(saved["layout"][self.peer], incoming[self.peer])
+ self.assertEqual(saved["layout"][self.other], incoming[self.other])
+ for peer in (self.peer, self.other):
+ self.assertEqual(next(p["ways"] for p in saved["peers"] if p["id"] == peer),
+ next(p["ways"] for p in original["peers"] if p["id"] == peer))
+ self.assertEqual([zone for zone in saved["zones"] if zone["peer"] == peer],
+ [zone for zone in original["zones"] if zone["peer"] == peer])
+
+ def test_repair_keeps_label_layout_zones_and_left_out_after_reloading(self):
+ settings = app_config.load_settings(self.path)
+ old = copy.deepcopy(settings["peers"][0])
+ settings["peers"][0]["label"] = "Office"
+ settings["peers"][0].update(left_out=True, left_out_ways=["edge"])
+ app_config.write_settings(self.path, settings)
+ repaired = pairing.peer_entry(harness.B, "Desk", "macos", 24820, harness.token(5), "192.0.2.20", 100)
+ self.window._store_peer(repaired, old)
+ saved = app_config.load_settings(self.path)
+ self.assertEqual(saved["peers"][0]["label"], "Office")
+ self.assertTrue(saved["peers"][0]["left_out"])
+ self.assertNotIn("left_out_ways", saved["peers"][0])
+ self.assertEqual(saved["peers"][0]["ways"], settings["peers"][0]["ways"])
+ from display_map_fixture import display_fields
+ self.assertEqual(saved["zones"], [dict(zone, **display_fields(self.window))
+ for zone in settings["zones"]])
+ expected_layout = copy.deepcopy(settings["layout"])
+ displays = self.window._own_displays()
+ if displays:
+ expected_layout[self.own]["displays"] = {
+ key: {"x": rect.x, "y": rect.y, "w": rect.width, "h": rect.height}
+ for key, rect in displays.items()
+ }
+ self.assertEqual(saved["layout"], expected_layout)
+ self.assertNotIn("dormant", saved["peers"][0])
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/win_app/tests/test_edge_glow.py b/win_app/tests/test_edge_glow.py
index 7fa82c8..7e33dc1 100644
--- a/win_app/tests/test_edge_glow.py
+++ b/win_app/tests/test_edge_glow.py
@@ -119,6 +119,7 @@ class PreviewLoopHoverTests(unittest.TestCase):
self.loop.run(False)
def test_every_tile_holds_a_still_until_one_is_hovered(self):
+ self.assertFalse(self.loop._timer.isActive())
self.loop._tick()
self.assertEqual([tile.state.pressure for tile in self.tiles], [edge_glow.PreviewLoop.HOLD] * 2)
self.assertFalse(any(self.loop.playing(tile) for tile in self.tiles))
@@ -130,6 +131,7 @@ class PreviewLoopHoverTests(unittest.TestCase):
def test_the_hovered_tile_plays_on_from_its_still_and_settles_back(self):
self.loop.hover(self.tiles[1])
+ self.assertTrue(self.loop._timer.isActive())
self.loop._hovered_at -= edge_glow.PreviewLoop.INTENT_S
self.loop._tick()
self.assertTrue(self.loop.playing(self.tiles[1]))
diff --git a/win_app/tests/test_effect_fires.py b/win_app/tests/test_effect_fires.py
index 8328421..d84d4e4 100644
--- a/win_app/tests/test_effect_fires.py
+++ b/win_app/tests/test_effect_fires.py
@@ -24,6 +24,7 @@ import sys
import unittest
from types import SimpleNamespace
from unittest import mock
+from PySide6.QtCore import QPointF, QRect
sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
@@ -41,7 +42,7 @@ def _owner(edge_glow=True, glow_style="glow", glow_colour="signal", shortcut_arr
config = SimpleNamespace(
edge_glow=edge_glow, glow_style=glow_style, glow_colour=glow_colour,
shortcut_arrival=shortcut_arrival, shortcut_arrival_style=shortcut_arrival_style, effect_length="normal",
- effect_size=effect_size,
+ effect_size=effect_size, effect_pace=1.0, effect_size_fraction=0.045,
)
return SimpleNamespace(_closing=False, _config=config, effects=effects, glow=glow)
@@ -60,24 +61,31 @@ class PressureRoutingTest(unittest.TestCase):
kvm_bridge_win.WindowsApplication._on_pressure(owner, "left", 0.4, False)
overlay.push.assert_called_once_with("left", 0.4, False, part=None)
+ def test_sender_pressure_is_sent_to_effects_and_the_local_resistance_strip(self):
+ owner = SimpleNamespace(bridge=SimpleNamespace(
+ pressure=mock.Mock(), local_pressure=mock.Mock()))
+ kvm_bridge_win.WindowsApplication._relay_sender_pressure(owner, "top", 0.4, False, "start")
+ owner.bridge.pressure.emit.assert_called_once_with("top", 0.4, False, "start")
+ owner.bridge.local_pressure.emit.assert_called_once_with("top", 0.4, False, "start")
+
def test_an_edge_push_reaches_edge_glow_when_the_style_is_glow(self):
owner = _owner(glow_style="glow", glow_colour="ocean", glow=mock.Mock())
owner._effect_overlay = mock.Mock(return_value=None)
kvm_bridge_win.WindowsApplication._on_pressure(owner, "left", 0.4, False)
- owner.glow.configure.assert_called_once_with("glow", "ocean", "normal", "medium")
+ owner.glow.configure.assert_called_once_with("glow", "ocean", "normal", "medium", 1.0, 0.045)
owner.glow.set_pressure.assert_called_once_with("left", 0.4, False, None)
def test_a_beam_style_push_configures_the_glow_as_beam(self):
owner = _owner(glow_style="beam", glow=mock.Mock())
owner._effect_overlay = mock.Mock(return_value=None)
kvm_bridge_win.WindowsApplication._on_pressure(owner, "left", 0.4, False)
- owner.glow.configure.assert_called_once_with("beam", "signal", "normal", "medium")
+ owner.glow.configure.assert_called_once_with("beam", "signal", "normal", "medium", 1.0, 0.045)
def test_the_selected_size_reaches_the_glow_renderer(self):
owner = _owner(glow_style="glow", glow=mock.Mock(), effect_size="large")
owner._effect_overlay = mock.Mock(return_value=None)
kvm_bridge_win.WindowsApplication._on_pressure(owner, "left", 0.4, False)
- owner.glow.configure.assert_called_once_with("glow", "signal", "normal", "large")
+ owner.glow.configure.assert_called_once_with("glow", "signal", "normal", "large", 1.0, 0.045)
def test_an_effect_that_failed_earlier_falls_back_to_plain_glow(self):
"""_on_pressure's own comment: an effect that failed earlier in the run falls back to
@@ -86,7 +94,7 @@ class PressureRoutingTest(unittest.TestCase):
owner = _owner(glow_style="wormhole", glow_colour="mono", glow=mock.Mock())
owner._effect_overlay = mock.Mock(return_value=None)
kvm_bridge_win.WindowsApplication._on_pressure(owner, "left", 0.4, False)
- owner.glow.configure.assert_called_once_with("glow", "mono", "normal", "medium")
+ owner.glow.configure.assert_called_once_with("glow", "mono", "normal", "medium", 1.0, 0.045)
def test_a_part_of_the_edge_push_passes_the_part_through_to_the_overlay(self):
owner = _owner(glow_style="rupture")
@@ -117,6 +125,31 @@ class PressureRoutingTest(unittest.TestCase):
kvm_bridge_win.WindowsApplication._on_pressure(owner, "left", 1.0, True)
overlay.push.assert_called_once_with("left", 1.0, True, part=None)
+ @mock.patch.dict(os.environ, {"DISPLAY": ":0"})
+ def test_wayland_pressure_passes_the_authoritative_cursor_to_a_native_overlay(self):
+ owner = _owner(glow_style="rupture")
+ overlay = mock.Mock()
+ owner._effect_overlay = mock.Mock(return_value=overlay)
+ with mock.patch.object(kvm_bridge_win.platform_parts, "WAYLAND", True), \
+ mock.patch.object(kvm_bridge_win.platform_parts.desktop, "cursor_position", return_value=(7.5, 91.0)):
+ kvm_bridge_win.WindowsApplication._on_pressure(owner, "left", 0.4, False)
+
+ overlay.push.assert_called_once_with("left", 0.4, False, cursor=QPointF(7.5, 91.0), part=None)
+
+ @mock.patch.dict(os.environ, {"DISPLAY": ":0"})
+ def test_wayland_pressure_passes_cursor_and_desktop_bounds_to_the_proxy(self):
+ owner = _owner(glow_style="rupture")
+ overlay = kvm_bridge_win.EffectOverlayX11Proxy()
+ overlay.push = mock.Mock()
+ owner._effect_overlay = mock.Mock(return_value=overlay)
+ box = QRect(-1920, 0, 3840, 2160)
+ with mock.patch.object(kvm_bridge_win.platform_parts, "WAYLAND", True), \
+ mock.patch.object(kvm_bridge_win.platform_parts.desktop, "cursor_position", return_value=(7.5, 91.0)), \
+ mock.patch.object(kvm_bridge_win, "desktop_box", return_value=box):
+ kvm_bridge_win.WindowsApplication._on_pressure(owner, "left", 0.4, False)
+
+ overlay.push.assert_called_once_with("left", 0.4, False, cursor=QPointF(7.5, 91.0), part=None, desk=box)
+
def test_a_crossing_carries_crossed_true_through_to_the_glow(self):
owner = _owner(glow_style="glow", glow=mock.Mock())
owner._effect_overlay = mock.Mock(return_value=None)
diff --git a/win_app/tests/test_effect_overlay_fixed.py b/win_app/tests/test_effect_overlay_fixed.py
new file mode 100644
index 0000000..fe31ef0
--- /dev/null
+++ b/win_app/tests/test_effect_overlay_fixed.py
@@ -0,0 +1,221 @@
+import os
+import sys
+import unittest
+from pathlib import Path
+from unittest import mock
+
+os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from PySide6.QtCore import QPoint, QRect
+from PySide6.QtGui import QImage, QPainter
+from PySide6.QtWidgets import QApplication
+
+import effect_overlay
+from core import effects
+
+
+class FakeTimer:
+ def __init__(self):
+ self.active = False
+
+ def isActive(self):
+ return self.active
+
+ def start(self):
+ self.active = True
+
+ def setInterval(self, _interval):
+ pass
+
+ def stop(self):
+ self.active = False
+
+
+class Frames:
+ def __init__(self, frames, busy=True):
+ self.values = iter(frames)
+ self.busy_values = iter(busy) if isinstance(busy, (list, tuple)) else None
+ self.busy = busy[0] if self.busy_values is not None else busy
+
+ def frames(self, *_args):
+ if self.busy_values is not None:
+ self.busy = next(self.busy_values, self.busy)
+ return next(self.values, [])
+
+
+class FixedGeometryTests(unittest.TestCase):
+ @classmethod
+ def setUpClass(cls):
+ cls.app = QApplication.instance() or QApplication([])
+
+ def overlay(self, fixed=True, desk=QRect(0, 0, 320, 200)):
+ overlay = effect_overlay.EffectOverlay(fixed_geometry=fixed)
+ overlay._timer = FakeTimer()
+ overlay._desk = QRect(desk)
+ overlay._displays = [(0.0, 0.0, float(desk.width()), float(desk.height()))]
+ overlay._fx = effects.effect("discharge")
+ overlay._palette = app_palette()
+ return overlay
+
+ def test_discharge_keeps_desktop_geometry_and_stays_visible_through_departure_and_arrival(self):
+ desk = QRect(0, 0, 320, 200)
+ overlay = self.overlay(desk=desk)
+ now = [10.0]
+ geometries = []
+ visibility = []
+ with mock.patch.object(effect_overlay.time, "monotonic", side_effect=lambda: now[0]), \
+ mock.patch.object(effect_overlay, "desktop_box", return_value=QRect(desk)), \
+ mock.patch.object(effect_overlay, "system_reduced_motion", return_value=False), \
+ mock.patch.object(effect_overlay, "system_dark", return_value=True):
+ overlay.configure("discharge", "signal")
+ overlay.push("right", 1.0, True, effect_overlay.QPointF(319, 100))
+ for step in range(1, 55):
+ now[0] = 10.0 + step * 0.05
+ overlay._tick()
+ geometries.append(QRect(overlay.geometry()))
+ if overlay.player.busy:
+ visibility.append(not overlay.isHidden())
+ now[0] = 13.0
+ overlay.arrive("edge", "left", effect_overlay.QPointF(1, 100))
+ for step in range(1, 55):
+ now[0] = 13.0 + step * 0.05
+ overlay._tick()
+ geometries.append(QRect(overlay.geometry()))
+ if overlay.player.busy:
+ visibility.append(not overlay.isHidden())
+ overlay.stop()
+ self.assertTrue(geometries)
+ self.assertTrue(all(frame == desk for frame in geometries))
+ self.assertTrue(all(visibility))
+
+ def test_each_dirty_update_covers_current_pen_bounds_and_the_previous_frame(self):
+ overlay = self.overlay()
+ frame1 = [bounded_fill(10, 20, 30, 40), bounded_fill(45, 50, 60, 70)]
+ frame2 = [bounded_fill(210, 120, 235, 145)]
+ overlay.player = Frames([frame1, frame2])
+ updates = []
+ overlay.update = lambda rect=None: updates.append(QRect(rect))
+ with mock.patch.object(effect_overlay.time, "monotonic", return_value=1.0):
+ overlay._tick()
+ overlay._tick()
+ self.assertEqual(len(updates), 2)
+ for pen in frame1:
+ x0, y0, x1, y1 = pen.bounds
+ expected = QRect(int(x0) - 2, int(y0) - 2, int(x1 - x0) + 4, int(y1 - y0) + 4)
+ self.assertTrue(updates[0].contains(expected))
+ previous = QRect(8, 18, 54, 54)
+ self.assertTrue(updates[1].contains(previous))
+ self.assertTrue(updates[1].contains(QRect(208, 118, 29, 29)))
+
+ def test_fixed_and_resized_overlays_render_the_same_desktop_pixels(self):
+ desk = QRect(0, 0, 320, 200)
+ pens = [bounded_fill(40, 30, 90, 75), bounded_fill(70, 55, 120, 100)]
+ fixed = self.overlay(True, desk)
+ fixed.setGeometry(desk)
+ fixed._pens, fixed._offset = pens, (0.0, 0.0)
+ resized = self.overlay(False, desk)
+ resized.setGeometry(QRect(38, 28, 84, 74))
+ resized._pens, resized._offset = pens, (38.0, 28.0)
+
+ images = []
+ for widget, offset in ((fixed, QPoint(0, 0)), (resized, QPoint(38, 28))):
+ image = QImage(desk.size(), QImage.Format.Format_ARGB32_Premultiplied)
+ image.fill(0)
+ painter = QPainter(image)
+ widget.render(painter, offset)
+ painter.end()
+ images.append(image)
+ fixed.hide()
+ resized.hide()
+ self.assertEqual(images[0], images[1])
+
+ def test_finished_effect_updates_the_last_dirty_rect_then_hides(self):
+ overlay = self.overlay()
+ last = [bounded_fill(25, 35, 80, 90)]
+ overlay.player = Frames([last, []], busy=[True, False])
+ requests = []
+ real_update = overlay.update
+
+ def record_update(rect=None):
+ requests.append(QRect(rect))
+ real_update(rect)
+
+ overlay.update = record_update
+ with mock.patch.object(effect_overlay.time, "monotonic", return_value=2.0):
+ overlay._tick()
+ self.app.processEvents()
+ self.assertFalse(overlay.isHidden())
+ overlay._tick()
+ image = QImage(overlay.size(), QImage.Format.Format_ARGB32_Premultiplied)
+ image.fill(0)
+ painter = QPainter(image)
+ overlay.render(painter, QPoint(0, 0))
+ painter.end()
+ self.assertEqual(image.pixelColor(50, 60).alpha(), 0)
+ self.app.processEvents()
+ self.assertTrue(requests[-1].contains(QRect(23, 33, 59, 59)))
+ self.assertTrue(overlay.isHidden())
+ overlay.stop()
+
+ def test_spark_effect_departures_and_arrivals_draw_around_supplied_points(self):
+ desk = QRect(0, 0, 320, 200)
+ centre = (160.0, 100.0)
+ edge_points = {
+ "left": (1.0, 57.0), "right": (318.0, 143.0),
+ "top": (73.0, 1.0), "bottom": (247.0, 198.0),
+ }
+ now = [10.0]
+ with mock.patch.object(effect_overlay.time, "monotonic", side_effect=lambda: now[0]), \
+ mock.patch.object(effect_overlay, "desktop_box", return_value=QRect(desk)), \
+ mock.patch.object(effect_overlay, "system_reduced_motion", return_value=False), \
+ mock.patch.object(effect_overlay, "system_dark", return_value=True), \
+ mock.patch.object(effect_overlay.QCursor, "pos", return_value=QPoint(160, 100)):
+ for style in ("flint", "filings", "discharge"):
+ for edge, location in edge_points.items():
+ for phase in ("departure", "arrival"):
+ overlay = self.overlay(True, desk)
+ overlay.configure(style, "signal")
+ point = effect_overlay.QPointF(*location)
+ if phase == "departure":
+ overlay.push(edge, 1.0, True, point)
+ else:
+ overlay.arrive("edge", edge, point)
+ drawn = []
+ for step in range(1, 7):
+ now[0] += 0.05
+ overlay._tick()
+ drawn.extend(pen.bounds for pen in overlay._pens if hasattr(pen, "bounds"))
+ overlay.stop()
+ self.assertTrue(drawn, (style, edge, phase))
+ self.assertTrue(any(distance_to_bounds(location, bounds) <= 60 for bounds in drawn),
+ (style, edge, phase, location))
+ self.assertFalse(any(contains(centre, bounds) for bounds in drawn),
+ (style, edge, phase, centre))
+
+
+def bounded_fill(x0, y0, x1, y1):
+ pen = effects.Pen()
+ pen.fillRect(x0, y0, x1 - x0, y1 - y0)
+ pen.bounds = (float(x0), float(y0), float(x1), float(y1))
+ return pen
+
+
+def app_palette():
+ return [(1.0, 0.1, 0.0, 1.0), (1.0, 0.8, 0.1, 1.0)]
+
+
+def distance_to_bounds(point, bounds):
+ x0, y0, x1, y1 = bounds
+ dx = max(x0 - point[0], 0.0, point[0] - x1)
+ dy = max(y0 - point[1], 0.0, point[1] - y1)
+ return (dx * dx + dy * dy) ** 0.5
+
+
+def contains(point, bounds):
+ x0, y0, x1, y1 = bounds
+ return x0 <= point[0] <= x1 and y0 <= point[1] <= y1
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/win_app/tests/test_effect_overlay_x11.py b/win_app/tests/test_effect_overlay_x11.py
new file mode 100644
index 0000000..ba0b1a2
--- /dev/null
+++ b/win_app/tests/test_effect_overlay_x11.py
@@ -0,0 +1,180 @@
+import json
+import os
+import sys
+import unittest
+from pathlib import Path
+from unittest import mock
+
+os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+import effect_overlay_x11
+from PySide6.QtCore import QPointF, QRect
+
+
+class FakeStdin:
+ def __init__(self):
+ self.lines = []
+
+ def write(self, line):
+ self.lines.append(line)
+
+ def flush(self):
+ pass
+
+ def close(self):
+ pass
+
+
+class FakeProcess:
+ def __init__(self, returncode=None):
+ self.stdin = FakeStdin()
+ self.stdout = None
+ self.returncode = returncode
+
+ def poll(self):
+ return self.returncode
+
+ def wait(self, timeout=None):
+ self.returncode = 0
+ return self.returncode
+
+ def terminate(self):
+ self.returncode = -1
+
+
+class ProxyTests(unittest.TestCase):
+ def setUp(self):
+ self.process = FakeProcess()
+ self.failed = []
+ self.proxy = effect_overlay_x11.EffectOverlayX11Proxy(
+ on_failure=lambda: self.failed.append(True), popen=lambda *args, **kwargs: self.process
+ )
+
+ def test_calls_write_the_helper_protocol(self):
+ self.proxy.configure("flint", "ocean", "long", "large", 1.35, 0.052)
+ self.proxy.push("right", 0.7, False, part="end")
+ self.proxy.arrive("edge", "left", 768, 432, [0, 0, 1536, 864])
+ self.proxy.crossed_in()
+ self.proxy.switched(384, 216, [0, 0, 1536, 864], "match")
+ self.proxy.configure_glow("beam", "sunset", "short", "small", 0.75, 0.03)
+ self.proxy.set_pressure("bottom", 1.0, True, "start")
+ self.proxy.stop()
+
+ self.assertEqual([json.loads(line) for line in self.process.stdin.lines], [
+ {"op": "effect_configure", "style": "flint", "colour": "ocean", "length": "long", "size": "large",
+ "effect_pace": 1.35, "size_fraction": 0.052},
+ {"op": "push", "edge": "right", "pressure": 0.7, "crossed": False, "part": "end"},
+ {"op": "arrive", "method": "edge", "edge": "left", "x": 768, "y": 432, "desk": [0, 0, 1536, 864]},
+ {"op": "crossed_in"},
+ {"op": "switched", "x": 384, "y": 216, "desk": [0, 0, 1536, 864], "choice": "match"},
+ {"op": "glow_configure", "style": "beam", "colour": "sunset", "length": "short", "size": "small",
+ "effect_pace": 0.75, "size_fraction": 0.03},
+ {"op": "glow_pressure", "edge": "bottom", "pressure": 1.0, "crossed": True, "part": "start"},
+ {"op": "stop"},
+ ])
+
+ def test_push_with_cursor_serialises_the_cursor_and_desktop_bounds(self):
+ self.proxy.push("right", 0.7, False, cursor=QPointF(1590, 440), desk=QRect(100, -20, 1600, 900))
+
+ self.assertEqual(json.loads(self.process.stdin.lines[0]), {
+ "op": "push", "edge": "right", "pressure": 0.7, "crossed": False, "part": None,
+ "x": 1590, "y": 440, "desk": [100, -20, 1600, 900],
+ })
+
+ def test_push_without_cursor_keeps_the_existing_protocol(self):
+ self.proxy.push("right", 0.7, False, part="end")
+
+ self.assertEqual(json.loads(self.process.stdin.lines[0]), {
+ "op": "push", "edge": "right", "pressure": 0.7, "crossed": False, "part": "end",
+ })
+
+ def test_helper_exit_marks_proxy_failed_once(self):
+ self.proxy.configure("flint", "ocean")
+ self.process.returncode = 1
+ self.proxy.check_process()
+ self.proxy.check_process()
+
+ self.assertTrue(self.proxy.failed)
+ self.assertEqual(self.failed, [True])
+
+ @unittest.skipIf(sys.platform == "win32", "select() on a pipe is POSIX only; the helper runs only on Linux")
+ def test_helper_failure_message_marks_proxy_failed(self):
+ read_fd, write_fd = os.pipe()
+ self.process.stdout = os.fdopen(read_fd, "r")
+ os.write(write_fd, b"failed effect\n")
+ os.close(write_fd)
+
+ self.proxy.configure("flint", "ocean")
+ self.proxy.check_process()
+
+ self.assertTrue(self.proxy.failed)
+ self.assertEqual(self.failed, [True])
+
+ def test_helper_start_failure_marks_proxy_failed(self):
+ proxy = effect_overlay_x11.EffectOverlayX11Proxy(
+ on_failure=lambda: self.failed.append(True),
+ popen=lambda *args, **kwargs: (_ for _ in ()).throw(OSError("unavailable")),
+ )
+ proxy.configure("flint", "ocean")
+
+ self.assertTrue(proxy.failed)
+ self.assertEqual(self.failed, [True])
+
+
+class DispatchTests(unittest.TestCase):
+ def test_dispatch_maps_points_by_fraction_and_calls_the_overlays(self):
+ overlay = mock.Mock()
+ glow = mock.Mock()
+ commands = [
+ {"op": "effect_configure", "style": "flint", "colour": "ocean", "length": "normal", "size": "medium",
+ "effect_pace": 1.4, "size_fraction": 0.055},
+ {"op": "push", "edge": "right", "pressure": 0.5, "crossed": False, "part": None,
+ "x": 778, "y": 452, "desk": [10, 20, 1536, 864]},
+ {"op": "arrive", "method": "edge", "edge": "left", "x": 768, "y": 432, "desk": [0, 0, 1536, 864]},
+ {"op": "crossed_in"},
+ {"op": "switched", "x": 384, "y": 216, "desk": [0, 0, 1536, 864], "choice": "match"},
+ {"op": "glow_configure", "style": "beam", "colour": "sunset", "length": "short", "size": "small",
+ "effect_pace": 0.8, "size_fraction": 0.025},
+ {"op": "glow_pressure", "edge": "bottom", "pressure": 1.0, "crossed": True, "part": "end"},
+ {"op": "stop"},
+ ]
+
+ class Bounds:
+ def x(self): return 100
+ def y(self): return -50
+ def width(self): return 3072
+ def height(self): return 1728
+
+ for command in commands[:-1]:
+ effect_overlay_x11.dispatch(command, overlay, glow, Bounds(), lambda x, y: (x, y))
+
+ self.assertEqual(overlay.configure.call_args.args,
+ ("flint", "ocean", "normal", "medium", 1.4, 0.055))
+ self.assertEqual(overlay.push.call_args, mock.call("right", 0.5, False, cursor=(1636, 814), part=None))
+ effect_overlay_x11.dispatch(
+ {"op": "push", "edge": "left", "pressure": 0.2, "crossed": False}, overlay, glow, Bounds(),
+ lambda x, y: (x, y)
+ )
+ self.assertEqual(overlay.push.call_args, mock.call("left", 0.2, False, part=None))
+ self.assertEqual(overlay.arrive.call_args.args, ("edge", "left", (1636, 814)))
+ self.assertEqual(overlay.switched.call_args.args, ((868, 382), "match"))
+ self.assertEqual(glow.configure.call_args.args,
+ ("beam", "sunset", "short", "small", 0.8, 0.025))
+ self.assertEqual(glow.set_pressure.call_args, mock.call("bottom", 1.0, True, "end"))
+ overlay.crossed_in.assert_called_once_with()
+ self.assertTrue(effect_overlay_x11.dispatch(commands[-1], overlay, glow, Bounds()))
+ overlay.stop.assert_called_once_with()
+ glow.hide.assert_called_once_with()
+
+
+class BridgeSelectionTests(unittest.TestCase):
+ def test_proxy_is_selected_only_for_wayland_with_display(self):
+ available = effect_overlay_x11.available
+ self.assertTrue(available(True, {"DISPLAY": ":0"}))
+ self.assertFalse(available(True, {}))
+ self.assertFalse(available(False, {"DISPLAY": ":0"}))
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/win_app/tests/test_effect_preview_timeline.py b/win_app/tests/test_effect_preview_timeline.py
new file mode 100644
index 0000000..ae70b2e
--- /dev/null
+++ b/win_app/tests/test_effect_preview_timeline.py
@@ -0,0 +1,100 @@
+import os
+import sys
+from pathlib import Path
+import unittest
+from unittest.mock import patch
+
+os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(ROOT))
+sys.path.insert(0, str(ROOT / "win_app"))
+
+from PySide6.QtCore import QRectF
+from PySide6.QtGui import QColor, QImage, QPainter
+from PySide6.QtWidgets import QApplication
+
+import effect_previews
+import theme
+from core import effects
+
+
+class EffectPreviewTimelineTests(unittest.TestCase):
+ @classmethod
+ def setUpClass(cls):
+ cls.app = QApplication.instance() or QApplication([])
+
+ def _frame_at(self, picture, now, playing_since=None, reduced=False):
+ picture.resize(180, effect_previews.STILL_HEIGHT)
+ picture.playing_since = playing_since
+ picture._image = None
+ frames = []
+ picture._paint_still = lambda _painter, t, still=False: frames.append((t, still))
+ with patch.object(effect_previews.time, "monotonic", return_value=now), \
+ patch.object(effect_previews, "system_reduced_motion", return_value=reduced), \
+ patch.object(effect_previews, "QPainter"):
+ picture.paintEvent(None)
+ return frames[-1]
+
+ def test_crossing_preview_stays_on_its_canonical_still_until_hover_intent_expires(self):
+ picture = effect_previews.EffectStill("rupture", ("#ff0000",))
+ with patch.object(effects, "still_time", return_value=1.9):
+ idle = self._frame_at(picture, 100.0)
+ intent = self._frame_at(picture, 100.05, playing_since=100.1)
+ self.assertEqual(idle, (1.9, True))
+ self.assertEqual(intent, (1.9, True))
+
+ def test_crossing_preview_starts_at_approach_zero_then_uses_live_elapsed_time(self):
+ picture = effect_previews.EffectStill("rupture", ("#ff0000",))
+ with patch.object(effects, "still_time", return_value=1.9):
+ approach = self._frame_at(picture, 100.15, playing_since=100.1)
+ live = self._frame_at(picture, 100.8, playing_since=100.1)
+ self.assertAlmostEqual(approach[0], 0.05)
+ self.assertFalse(approach[1])
+ self.assertAlmostEqual(live[0], 0.7)
+ self.assertFalse(live[1])
+
+ def test_reduced_motion_returns_to_the_canonical_still_during_playback(self):
+ picture = effect_previews.EffectStill("rupture", ("#ff0000",))
+ with patch.object(effects, "still_time", return_value=1.9):
+ frame = self._frame_at(picture, 100.8, playing_since=100.1, reduced=True)
+ self.assertEqual(frame, (1.9, True))
+
+ def test_switch_preview_continues_from_its_existing_still(self):
+ picture = effect_previews.SwitchStill("match", "rupture", ("#ff0000",))
+ with patch.object(effects, "still_time", return_value=0.8):
+ frame = self._frame_at(picture, 100.3, playing_since=100.1)
+ self.assertAlmostEqual(frame[0], 1.0)
+ self.assertFalse(frame[1])
+
+ def test_reduced_motion_keeps_a_switch_on_its_canonical_still(self):
+ picture = effect_previews.SwitchStill("match", "rupture", ("#ff0000",))
+ with patch.object(effects, "still_time", return_value=0.8):
+ frame = self._frame_at(picture, 100.3, playing_since=100.1, reduced=True)
+ self.assertEqual(frame, (0.8, True))
+
+ def test_specimen_screens_use_the_card_ground_while_live_scenes_keep_the_dark_ground(self):
+ original_appearance = theme.is_dark()
+ theme.set_dark(False)
+ ground = theme.colour("ground")
+ view = QRectF(0, 0, 200, 100)
+
+ def render(scene):
+ image = QImage(200, 100, QImage.Format.Format_ARGB32_Premultiplied)
+ image.fill(0)
+ painter = QPainter(image)
+ effect_previews.paint_scene(painter, QRectF(0, 0, 200, 100), view, scene, 11, False)
+ painter.end()
+ return image
+
+ scene = {"screens": [(0, 0, 200, 100, "mac")], "pens": [], "pointer": None, "notch": None}
+ try:
+ specimen = render(dict(scene, seam=(100, 0, 100, 100)))
+ self.assertEqual(specimen.pixelColor(50, 50), ground)
+ self.assertEqual(specimen.pixelColor(100, 50), QColor(theme.colour("rule")))
+ self.assertEqual(render(scene).pixelColor(50, 50), QColor(effects.PREVIEW_TILE_GROUND))
+ finally:
+ theme.set_dark(original_appearance)
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/win_app/tests/test_eliding_text.py b/win_app/tests/test_eliding_text.py
index d493d8c..29ab28a 100644
--- a/win_app/tests/test_eliding_text.py
+++ b/win_app/tests/test_eliding_text.py
@@ -112,20 +112,6 @@ class ElidingTextGeometryTests(unittest.TestCase):
self.assertGreaterEqual(button.height(), button.heightForWidth(button.width()))
self.assertEqual(button.accessibleName(), f"Machine, {LONG_NAME}")
- def test_replacing_machine_choices_hides_the_old_container_before_deferred_deletion(self):
- from PySide6.QtWidgets import QWidget
- holder = QWidget()
- slot = QVBoxLayout(holder)
- previous = widgets.Choice((), 1, "")
- slot.addWidget(previous.view)
- holder.show()
- self.addCleanup(holder.deleteLater)
- self.settle()
- owner = SimpleNamespace(_machine_items=(), machine_choice=previous, _machine_slot=slot,
- _choose_machine=lambda *_: None)
- kvm.WindowsApplication._rebuild_machine_choice(owner, (("first", LONG_NAME), ("second", "Desk")))
- self.assertTrue(previous.view.isHidden())
-
def test_short_machine_name_stays_readable_between_long_names(self):
self.app.setStyleSheet(theme.stylesheet())
choice = widgets.Choice((("first", LONG_NAME[:48]), ("short", "Desk"),
diff --git a/win_app/tests/test_frame_clock.py b/win_app/tests/test_frame_clock.py
new file mode 100644
index 0000000..f3e13c3
--- /dev/null
+++ b/win_app/tests/test_frame_clock.py
@@ -0,0 +1,50 @@
+import os
+import sys
+import unittest
+from pathlib import Path
+from types import SimpleNamespace
+from unittest import mock
+
+os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from PySide6.QtCore import Qt
+from PySide6.QtWidgets import QApplication
+
+import frame_clock
+
+
+class FrameClockTests(unittest.TestCase):
+ @classmethod
+ def setUpClass(cls):
+ cls.app = QApplication.instance() or QApplication([])
+
+ def test_interval_uses_the_screen_refresh_rate_floor(self):
+ for rate, expected in ((120.0, 8), (60.0, 16), (0.0, 16)):
+ screen_rate = rate
+ with self.subTest(rate=rate), mock.patch.object(
+ frame_clock.QGuiApplication, "screens",
+ return_value=[] if rate == 0.0 else [SimpleNamespace(refreshRate=lambda: screen_rate)]):
+ self.assertEqual(frame_clock.frame_interval_ms(), expected)
+
+ def test_with_no_widget_the_fastest_screen_paces_the_clock(self):
+ screens = [SimpleNamespace(refreshRate=lambda: 60.0), SimpleNamespace(refreshRate=lambda: 120.0)]
+ with mock.patch.object(frame_clock.QGuiApplication, "screens", return_value=screens):
+ self.assertEqual(frame_clock.frame_interval_ms(), 8)
+
+ def test_frame_timer_is_precise_and_uses_the_widget_rate(self):
+ widget = object()
+ with mock.patch.object(frame_clock, "refresh_rate", return_value=120.0):
+ timer = frame_clock.frame_timer(None, lambda: None, widget)
+ self.assertEqual(timer.interval(), 8)
+ self.assertEqual(timer.timerType(), Qt.TimerType.PreciseTimer)
+
+ def test_design_previews_play_at_sixty_at_most(self):
+ with mock.patch.object(frame_clock, "refresh_rate", return_value=120.0):
+ self.assertEqual(frame_clock.frame_interval_ms(max_rate=frame_clock.PREVIEW_MAX_RATE), 16)
+ with mock.patch.object(frame_clock, "refresh_rate", return_value=50.0):
+ self.assertEqual(frame_clock.frame_interval_ms(max_rate=frame_clock.PREVIEW_MAX_RATE), 20)
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/win_app/tests/test_global_shortcut.py b/win_app/tests/test_global_shortcut.py
new file mode 100644
index 0000000..53a3e45
--- /dev/null
+++ b/win_app/tests/test_global_shortcut.py
@@ -0,0 +1,83 @@
+"""The Shortcut tile controls saved global intent and the real sender's trigger."""
+
+import unittest
+from types import SimpleNamespace
+from unittest.mock import patch
+
+import app_config
+import capture_win
+import kvm_bridge_win as kvm
+from core import settings_sync, ways
+from links_rig import Rig
+import test_crossing_page_parity as parity
+
+
+class GlobalShortcutTests(unittest.TestCase):
+ setUp = parity.CrossingPageParityTests.setUp
+ tearDown = parity.CrossingPageParityTests.tearDown
+ _open_window = parity.CrossingPageParityTests._open_window
+ _close_window = parity.CrossingPageParityTests._close_window
+ _stop_patches = parity.CrossingPageParityTests._stop_patches
+
+ def test_tile_toggles_saved_methods_and_stops_and_starts_shortcut_input(self):
+ window = self.window
+ self.assertTrue(hasattr(window, "shortcut_tile"), "global Shortcut control is missing")
+ tile = window.shortcut_tile
+ self.assertTrue(tile.isChecked())
+ before = app_config.load_settings(self.path)
+ rig = Rig(machine_id=window._config.machine_id)
+ shell = SimpleNamespace(sender=rig.sender, _trigger=capture_win.Trigger("ctrl_r", "hold", 300))
+ for on in (False, True, False):
+ tile.click()
+ saved = app_config.load_settings(self.path)
+ loaded = app_config.load_config(self.path)
+ self.assertEqual("shortcut" in window._config.crossing_methods, on)
+ self.assertEqual("shortcut" in loaded.crossing_methods, on)
+ self.assertEqual(window.sender.shortcut_armed, on)
+ for peer in self.peers:
+ self.assertEqual(ways.ways(saved, peer["id"]), ways.ways(before, peer["id"]))
+ rig.sender.update_config(loaded)
+ kvm.WindowsApplication._on_hook_key(shell, "ctrl_r", True)
+ self.assertEqual(rig.sender.redirecting, on)
+ kvm.WindowsApplication._on_hook_key(shell, "ctrl_r", False)
+ self.assertFalse(rig.sender.redirecting)
+ self._close_window()
+ self._open_window()
+ self.assertFalse(self.window.shortcut_tile.isChecked())
+ self.window.shortcut_tile.click()
+ self._close_window()
+ self._open_window()
+ self.assertTrue(self.window.shortcut_tile.isChecked())
+
+ def test_shared_shortcut_arrivals_reflect_without_a_local_toggle(self):
+ window = self.window
+ self.assertTrue(hasattr(window, "shortcut_tile"), "global Shortcut control is missing")
+ peer = self.peers[0]["id"]
+ original_tile = window.shortcut_tile
+ with patch.object(window, "_ways_changed", side_effect=AssertionError("reflection saved a local toggle")):
+ for stamp, on, key in ((100, False, "alt_r"), (101, True, "cmd_r")):
+ message = settings_sync.message_data(True, stamp, {"shortcut": on, "trigger_key": key},
+ by=peer, groups=["shortcut"])
+ window._on_settings(peer, message)
+ self.assertIs(window.shortcut_tile, original_tile)
+ self.assertEqual(window.shortcut_tile.isChecked(), on)
+ self.assertEqual(window.sender.shortcut_armed, on)
+ saved = app_config.load_settings(self.path)
+ self.assertEqual("shortcut" in app_config.load_config(self.path).crossing_methods, on)
+ self.assertEqual(saved["same_set_at"], stamp)
+ self.assertEqual(saved["same_by"], peer)
+ title = "Right Alt" if key == "alt_r" else "Right Ctrl"
+ self.assertEqual(window.shortcut_tile.detail.text(), f"{title}, to where input last went")
+
+ def test_tile_is_first_and_key_detail_tracks_local_recording(self):
+ window = self.window
+ self.assertTrue(hasattr(window, "shortcut_tile"), "global Shortcut control is missing")
+ self.assertIs(window.shortcut_module.body.itemAt(1).widget(), window.shortcut_tile)
+ self.assertEqual(window.shortcut_tile.text(), "Shortcut")
+ self.assertEqual(window.shortcut_tile.detail.text(), "Right Ctrl, to where input last went")
+ window._record_trigger("key", kvm.TRIGGER_VKS["alt_r"])
+ self.assertEqual(window.shortcut_tile.accessibleDescription(), "Right Alt, to where input last went")
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/win_app/tests/test_hook_key_repeat.py b/win_app/tests/test_hook_key_repeat.py
index e5e3463..5a585fe 100644
--- a/win_app/tests/test_hook_key_repeat.py
+++ b/win_app/tests/test_hook_key_repeat.py
@@ -10,6 +10,7 @@ from types import SimpleNamespace
sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
import capture_win
+from core.capture_types import DeadKey, TextInput
from core import protocol
from capture_win import Trigger
from links_rig import B, Rig, make_config
@@ -75,6 +76,25 @@ class HeldTriggerRepeatTests(unittest.TestCase):
self.assertFalse(dispatch(trigger, self.link_sender, "cmd_r", True))
self.assertFalse(dispatch(trigger, self.link_sender, "cmd_r", False))
+ def test_holding_the_double_tap_trigger_at_home_never_sends_input_away(self):
+ # Before 1.5.2 the second autorepeat inside the window was a double-tap, and every one
+ # after flipped input again. At home the held key is an ordinary key, repeats included.
+ trigger = Trigger("cmd_r", "double_tap", 300)
+ for _ in range(20):
+ self.assertFalse(dispatch(trigger, self.link_sender, "cmd_r", True))
+ self.assertFalse(self.link_sender.redirecting)
+ self.assertFalse(dispatch(trigger, self.link_sender, "cmd_r", False))
+ self.assertEqual(self.rig.sent_home, [])
+
+ def test_holding_the_double_tap_trigger_while_away_keeps_input_away(self):
+ trigger = Trigger("cmd_r", "double_tap", 300)
+ self.link_sender.set_redirecting(True)
+ for _ in range(20):
+ self.assertTrue(dispatch(trigger, self.link_sender, "cmd_r", True))
+ self.assertTrue(self.link_sender.redirecting)
+ self.assertTrue(dispatch(trigger, self.link_sender, "cmd_r", False))
+ self.assertEqual(self.keys(protocol.MSG_KEYDOWN) + self.keys(protocol.MSG_KEYUP), [])
+
def test_physical_release_never_reaches_on_key_so_no_keyup_is_sent(self):
dispatch(self.trigger, self.link_sender, "alt_r", True)
dispatch(self.trigger, self.link_sender, "alt_r", True) # the repeat
diff --git a/win_app/tests/test_idle_refresh.py b/win_app/tests/test_idle_refresh.py
new file mode 100644
index 0000000..7d4526c
--- /dev/null
+++ b/win_app/tests/test_idle_refresh.py
@@ -0,0 +1,203 @@
+"""Idle refresh must not read unchanged files or replace an unchanged picker."""
+import os
+from pathlib import Path
+import tempfile
+import threading
+import time
+import unittest
+from unittest.mock import patch
+
+os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+from PySide6.QtWidgets import QApplication
+import app_config
+import kvm_bridge_win as kvm
+import theme
+from core import protocol
+from core.return_edge import Rect
+from core.tests import responder_harness
+
+
+class IdleRefreshTest(unittest.TestCase):
+ @classmethod
+ def setUpClass(cls):
+ cls.app = QApplication.instance() or QApplication([])
+ theme.init_fonts()
+
+ def setUp(self):
+ self.folder = tempfile.TemporaryDirectory()
+ self.addCleanup(self.folder.cleanup)
+ self.path = Path(self.folder.name) / "idle-fixture.json"
+ saved = app_config.load_settings(self.path)
+ saved["check_updates"] = False
+ app_config.write_settings(self.path, saved)
+ self.blockers = [
+ patch.object(threading.Thread, "start", side_effect=AssertionError("service started")),
+ patch.object(kvm.WindowsApplication, "_make_pairing", return_value=None),
+ patch.object(kvm.autostart_win, "installed_exe", return_value=None),
+ ]
+ for blocker in self.blockers:
+ blocker.start()
+ self.addCleanup(blocker.stop)
+ self.window = kvm.WindowsApplication(self.path)
+ self.window.refresh_timer.stop()
+ self.window.full_screen_timer.stop()
+ self.window.show()
+ self.app.processEvents()
+ for _ in range(8):
+ self.window._refresh_window()
+
+ def tearDown(self):
+ self.window.hide()
+ self.window.deleteLater()
+ self.app.processEvents()
+
+ def test_unchanged_ticks_do_not_read_settings_or_replace_model(self):
+ model = self.window.design_follow_choice.model()
+ with patch.object(app_config, "load_settings", side_effect=AssertionError("idle read")):
+ for _ in range(8):
+ self.window._refresh_window()
+ self.assertIs(self.window.design_follow_choice.model(), model)
+
+ def test_real_file_change_is_visible_on_next_tick(self):
+ saved = app_config.load_settings(self.path)
+ saved["same_before_sync"] = {"saved_at": int(time.time()), "groups": ["crossing"],
+ "values": {"resistance_px": 80}}
+ app_config.write_settings(self.path, saved)
+ self.window._refresh_window()
+ self.assertFalse(self.window.same_revert.isHidden())
+
+ def test_hidden_ticks_keep_tray_live_without_refreshing_window(self):
+ self.window.hide()
+ model = self.window.design_follow_choice.model()
+ self.window.sender.crossing_paused = True
+ with patch.object(app_config, "load_settings", side_effect=AssertionError("idle read")):
+ for _ in range(8):
+ self.window.refresh_timer.timeout.emit()
+ self.assertEqual(self.window.pause_action.text(), "Resume crossing")
+ self.assertIs(self.window.design_follow_choice.model(), model)
+
+ def test_design_model_changes_when_a_link_or_name_changes(self):
+ peer = protocol.id_text(responder_harness.B)
+ saved = app_config.load_settings(self.path)
+ saved["peers"] = [responder_harness.entry(responder_harness.B, "Peer", send=False)]
+ app_config.write_settings(self.path, saved)
+ self.window._design_peer_caps = lambda: {peer: {"design_sync", "layout"}}
+ self.window._refresh_window()
+ choice = self.window.design_follow_choice
+ self.assertEqual(choice.count(), 2)
+ self.assertEqual(choice.itemText(1), "Peer")
+ self.assertFalse(choice.model().item(1).isEnabled())
+ self.window._design_states[peer] = {}
+ self.window._refresh_window()
+ self.assertTrue(choice.model().item(1).isEnabled())
+ saved["peers"][0]["name"] = "Renamed peer"
+ app_config.write_settings(self.path, saved)
+ self.window._refresh_window()
+ self.assertEqual(choice.itemText(1), "Renamed peer")
+ self.window._design_peer_caps = lambda: {}
+ self.window._refresh_window()
+ self.assertEqual(choice.count(), 1)
+
+ def test_a_temporary_read_failure_retries_and_keeps_last_good_snapshot(self):
+ saved = app_config.load_settings(self.path)
+ saved["same_before_sync"] = {"saved_at": int(time.time()), "groups": ["crossing"],
+ "values": {"resistance_px": 80}}
+ app_config.write_settings(self.path, saved)
+ with patch.object(app_config, "load_settings", side_effect=OSError("temporary failure")):
+ self.window._refresh_window()
+ self.assertTrue(self.window.same_revert.isHidden())
+ self.window._refresh_window()
+ self.assertFalse(self.window.same_revert.isHidden())
+
+ def test_column_fit_does_not_set_an_unchanged_width(self):
+ fitter = self.window.findChildren(kvm.ColumnFit)[0]
+ fitter.fit()
+ with patch.object(fitter.column, "setFixedWidth", wraps=fitter.column.setFixedWidth) as setter:
+ fitter.fit()
+ setter.assert_not_called()
+ fitter.scroll.resize(fitter.scroll.width() + 200, fitter.scroll.height())
+ fitter.fit()
+ setter.assert_called_once()
+
+ def test_pointer_selection_selects_once(self):
+ sidebar = self.window.sidebar
+ with patch.object(sidebar, "select", wraps=sidebar.select) as select:
+ sidebar._pointer_select("design")
+ self.assertEqual(select.call_count, 1)
+ self.assertEqual(self.window._page, "design")
+
+ def test_unchanged_peer_row_skips_setters_but_changed_row_is_shown(self):
+ saved = app_config.load_settings(self.path)
+ saved["peers"] = [responder_harness.entry(responder_harness.B, "Peer", send=False)]
+ app_config.write_settings(self.path, saved)
+ self.window._refresh_window()
+ row = next(iter(self.window.machines.rows.values()))
+ with patch.object(row.left_out, "setText", wraps=row.left_out.setText) as setter:
+ self.window._refresh_window()
+ setter.assert_not_called()
+ self.window._peer_entries[0]["left_out"] = True
+ self.window._refresh_window()
+ self.assertEqual(row.left_out.text(), "Put back")
+ setter.assert_called_once()
+
+ def test_hidden_file_change_is_reflected_when_shown(self):
+ self.window.hide()
+ saved = app_config.load_settings(self.path)
+ saved["same_before_sync"] = {"saved_at": int(time.time()), "groups": ["crossing"],
+ "values": {"resistance_px": 80}}
+ app_config.write_settings(self.path, saved)
+ self.window._refresh_window()
+ self.window.show()
+ self.assertFalse(self.window.same_revert.isHidden())
+
+ def test_show_refreshes_all_state_before_processing_paint_events(self):
+ self.window.hide()
+ saved = app_config.load_settings(self.path)
+ peer = protocol.id_text(responder_harness.B)
+ saved["peers"] = [responder_harness.entry(responder_harness.B, "New peer", send=False)]
+ app_config.write_settings(self.path, saved)
+ self.window._paired = True
+ self.window._config.same_groups = ["design"]
+ self.window._config.same_on_both = True
+ self.window._status = kvm.ServerState.CONNECTED
+ self.window._status_detail = "New connection"
+ self.window._sending_detail = "Connected to the new peer"
+ self.window.sender.crossing_paused = True
+ self.window._design_peer_caps = lambda: {peer: {"design_sync", "layout"}}
+ self.window._design_states[peer] = {}
+ self.window.show()
+ self.assertEqual(self.window.status_heading.text(), kvm.STATUS_TITLES[kvm.ServerState.CONNECTED])
+ self.assertEqual(self.window.status_detail.text(), "New connection")
+ self.assertEqual(self.window.send_hint.text(), "Connected to the new peer")
+ self.assertEqual(self.window.pause_button.text(), "Resume crossing")
+ self.assertTrue(self.window.same_checks["design"].isChecked())
+ self.assertTrue(self.window.same_checks["everything"].isEnabled())
+ self.assertEqual(self.window.design_follow_choice.itemText(1), "New peer")
+ self.assertEqual(next(iter(self.window.machines.rows.values())).name.text(), "New peer")
+
+ def test_display_geometry_change_is_reconciled_without_a_file_edit(self):
+ self.window._own_display_map = {"probe": Rect(0, 0, 1920, 1080)}
+ self.window._refresh_window()
+ saved = app_config.load_settings(self.path)
+ self.assertEqual(saved["layout"][saved["machine_id"]]["displays"]["probe"],
+ {"x": 0, "y": 0, "w": 1920, "h": 1080})
+ self.window._own_display_map = {"probe": Rect(0, 0, 2560, 1440)}
+ self.window._refresh_window()
+ saved = app_config.load_settings(self.path)
+ self.assertEqual(saved["layout"][saved["machine_id"]]["displays"]["probe"]["w"], 2560)
+
+ def test_display_signal_refreshes_hardware_before_reconciling(self):
+ def changed_geometry():
+ self.window._own_display_map = {"probe": Rect(0, 0, 2560, 1440)}
+
+ with patch.object(self.window, "_refresh_own_displays", side_effect=changed_geometry) as refresh:
+ self.app.primaryScreen().geometryChanged.emit(self.app.primaryScreen().geometry())
+ refresh.assert_called_once()
+ saved = app_config.load_settings(self.path)
+ self.assertEqual(saved["layout"][saved["machine_id"]]["displays"]["probe"]["w"], 2560)
+
+ def test_restore_refreshes_state_without_waiting_for_a_tick(self):
+ self.window.showMinimized()
+ self.window._sending_detail = "Connected after minimising"
+ self.window.showNormal()
+ self.assertEqual(self.window.send_hint.text(), "Connected after minimising")
diff --git a/win_app/tests/test_inject_x11.py b/win_app/tests/test_inject_x11.py
index fd74349..2498d5f 100644
--- a/win_app/tests/test_inject_x11.py
+++ b/win_app/tests/test_inject_x11.py
@@ -69,6 +69,10 @@ class NamedKeyTest(unittest.TestCase):
self.assertEqual(plan("f24"), [(PRESS, 202)])
self.assertEqual(plan("media_play_pause"), [(PRESS, 172)])
+ def test_search_intents_open_the_gnome_activities_key(self):
+ self.assertEqual(plan("spotlight"), [(PRESS, 133)])
+ self.assertEqual(plan("spotlight", down=False), [(RELEASE, 133)])
+
def test_the_server_repeats_a_held_named_key(self):
state = KeyState()
self.assertEqual(plan("backspace", state=state), [(PRESS, 22)])
diff --git a/win_app/tests/test_input_injector.py b/win_app/tests/test_input_injector.py
index 529260e..03af069 100644
--- a/win_app/tests/test_input_injector.py
+++ b/win_app/tests/test_input_injector.py
@@ -103,6 +103,11 @@ class PlanKeyInputsChordTests(unittest.TestCase):
self.assertEqual(down_plan, [(0x45, 0x12, 0)])
self.assertEqual(char_vk_down, {"e": 0x45})
+ def test_native_media_keys_use_the_windows_virtual_key_table(self):
+ for name, vk in (("volume_up", 0xAF), ("volume_down", 0xAE), ("volume_mute", 0xAD),
+ ("media_play_pause", 0xB3), ("media_next", 0xB0), ("media_prev", 0xB1)):
+ self.assertEqual(input_injector.VK_MAP[name], vk)
+
def test_keyup_mirrors_vk_even_if_modifier_released_first(self):
mods_down = {"ctrl"}
char_vk_down = {}
diff --git a/win_app/tests/test_layout_primitives.py b/win_app/tests/test_layout_primitives.py
index d6f8d32..874ad62 100644
--- a/win_app/tests/test_layout_primitives.py
+++ b/win_app/tests/test_layout_primitives.py
@@ -11,7 +11,7 @@ sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
from PySide6.QtCore import QCoreApplication, QEvent
from PySide6.QtGui import QAccessible, QAccessibleActionInterface
from PySide6.QtTest import QTest
-from PySide6.QtWidgets import QApplication, QVBoxLayout, QWidget
+from PySide6.QtWidgets import QApplication, QGraphicsBlurEffect, QGraphicsOpacityEffect, QVBoxLayout, QWidget
import theme
import widgets
@@ -87,6 +87,44 @@ class LayoutPrimitivesTests(unittest.TestCase):
self.assertEqual(point.x(), 0)
self.assertGreaterEqual(point.y(), row.heading.height() + 8)
+ def test_sidebar_response_time_has_connected_pending_and_disconnected_states(self):
+ sidebar = widgets.Sidebar([("home", "Home", "")], lambda _key: None)
+ self.addCleanup(sidebar.deleteLater)
+
+ sidebar.set_link("signal", "Connected", response_time_ms=None, connected=True)
+ self.assertEqual(sidebar.response_time.text(), "Response: —")
+ self.assertEqual(sidebar.response_time.accessibleName(), "Response time: no fresh measurement")
+
+ sidebar.set_link("signal", "Connected", response_time_ms=24, connected=True)
+ self.assertEqual(sidebar.response_time.text(), "Response: 24 ms")
+ self.assertEqual(sidebar.response_time.accessibleName(), "Response time: 24 ms")
+
+ sidebar.set_link("quiet", "Disconnected", response_time_ms=24, connected=False)
+ self.assertFalse(sidebar.response_time.isVisible())
+ self.assertEqual(sidebar.response_time.text(), "")
+
+ def test_sidebar_response_time_fits_the_full_sidebar_at_its_minimum_width(self):
+ sidebar = widgets.Sidebar([("home", "Home", "")], lambda _key: None)
+ self.addCleanup(sidebar.deleteLater)
+ sidebar.set_link("signal", "Connected", "A machine with a long name", response_time_ms=3000, connected=True)
+ sidebar.set_window_width(640)
+ self.mount(sidebar, 640)
+ self.assertLessEqual(sidebar.response_time.fontMetrics().horizontalAdvance(sidebar.response_time.text()),
+ sidebar.response_time.width())
+ self.assertLessEqual(sidebar.response_time.geometry().right(), sidebar.width())
+
+ def test_sidebar_response_time_keeps_the_value_and_unit_visible_in_the_rail(self):
+ sidebar = widgets.Sidebar([("home", "Home", "")], lambda _key: None)
+ self.addCleanup(sidebar.deleteLater)
+ sidebar.set_window_width(600)
+ self.mount(sidebar, 600)
+ sidebar.set_link("signal", "Connected", "Bee", response_time_ms=3000, connected=True)
+ self.settle()
+ self.assertEqual(sidebar.response_time.text(), "3000 ms")
+ self.assertEqual(sidebar.response_time.accessibleName(), "Response time to Bee: 3000 ms")
+ self.assertLessEqual(sidebar.response_time.fontMetrics().horizontalAdvance(sidebar.response_time.text()),
+ sidebar.response_time.width())
+
def test_capped_segments_grow_together_to_keep_full_option_text(self):
choice = widgets.Choice((("a", "Crossing"), ("b", "Shortcut and menu")), 2, "a")
choice.set_width(240)
@@ -114,6 +152,35 @@ class LayoutPrimitivesTests(unittest.TestCase):
self.assertTrue(other.state().checked)
self.assertFalse(chosen.state().checked)
+ def test_set_enabled_on_every_refresh_tick_leaves_no_orphaned_effects(self):
+ choice = widgets.ChoiceTiles(
+ [(key, key, "Quiet", QWidget()) for key in ("a", "b")], "a", responsive=True)
+ for _ in range(500):
+ choice.set_enabled(True)
+ self.assertEqual(choice.view.findChildren(QGraphicsOpacityEffect), [])
+ for _ in range(500):
+ choice.set_enabled(False)
+ self.assertEqual(len(choice.view.findChildren(QGraphicsOpacityEffect)), 1)
+ self.assertEqual(choice.view.graphicsEffect().opacity(), 0.45)
+ choice.set_enabled(True)
+ self.assertIsNone(choice.view.graphicsEffect())
+ self.assertEqual(choice.view.findChildren(QGraphicsOpacityEffect), [])
+ self.assertTrue(all(tile.isEnabled() for tile in choice._tiles.values()))
+
+ def test_disabling_replaces_a_foreign_effect_with_the_fade(self):
+ choice = widgets.ChoiceTiles(
+ [(key, key, "Quiet", QWidget()) for key in ("a", "b")], "a", responsive=True)
+ other = QGraphicsOpacityEffect(choice.view)
+ other.setOpacity(0.8)
+ choice.view.setGraphicsEffect(other)
+ choice.set_enabled(False)
+ self.assertIsInstance(choice.view.graphicsEffect(), QGraphicsOpacityEffect)
+ self.assertEqual(choice.view.graphicsEffect().opacity(), 0.45)
+ choice.view.setGraphicsEffect(QGraphicsBlurEffect(choice.view))
+ choice.set_enabled(False)
+ self.assertIsInstance(choice.view.graphicsEffect(), QGraphicsOpacityEffect)
+ self.assertEqual(choice.view.graphicsEffect().opacity(), 0.45)
+
def test_family_rows_distribute_rounding_remainder_to_the_final_edge(self):
choice = widgets.ChoiceTiles(
[(key, key, "Quiet", QWidget()) for key in ("a", "b", "c")], "a", responsive=True)
diff --git a/win_app/tests/test_left_out_ui.py b/win_app/tests/test_left_out_ui.py
new file mode 100644
index 0000000..7eeb25e
--- /dev/null
+++ b/win_app/tests/test_left_out_ui.py
@@ -0,0 +1,52 @@
+import os
+import sys
+import unittest
+from pathlib import Path
+from types import SimpleNamespace
+
+os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from PySide6.QtWidgets import QApplication
+
+import machines_win
+import theme
+
+
+class LeftOutRowTests(unittest.TestCase):
+ @classmethod
+ def setUpClass(cls):
+ cls.app = QApplication.instance() or QApplication([])
+ theme.init_fonts()
+
+ def test_button_can_be_pressed_before_the_first_refresh(self):
+ calls = []
+ row = machines_win.PeerRow("token", *([lambda *_: None] * 3),
+ lambda token, enabled: calls.append((token, enabled)), lambda *_: None)
+
+ row.left_out.click()
+
+ self.assertEqual(calls, [("token", True)])
+
+ def test_left_out_row_explains_the_shortcut_and_offers_put_back(self):
+ calls = []
+ row = machines_win.PeerRow("token", *([lambda *_: None] * 3),
+ lambda token, enabled: calls.append((token, enabled)), lambda *_: None)
+ entry = {"token": "token", "port": 24820, "in_use": True, "left_out": True,
+ "left_out_ways": ["edge"], "send": True, "allow_drive": True}
+ state = SimpleNamespace(tone="amber", word="Linked", detail="Connected to Studio.")
+ row.refresh(entry, "Studio", state, "Mac · 192.0.2.10 · port 24820", cycle_mode="last")
+
+ self.assertEqual(row.left_out.text(), "Put back")
+ self.assertFalse(row.left_out_note.isHidden())
+ self.assertEqual(row.left_out_note.text(), "Left out of the layout. The shortcut and the menu still reach it.")
+ row.left_out.click()
+ self.assertEqual(calls, [("token", False)])
+
+ row.refresh({**entry, "left_out": False}, "Studio", state, "Mac · 192.0.2.10 · port 24820", cycle_mode="last")
+ self.assertEqual(row.left_out.text(), "Leave out")
+ self.assertTrue(row.left_out_note.isHidden())
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/win_app/tests/test_links.py b/win_app/tests/test_links.py
index 21f83f0..6d8a053 100644
--- a/win_app/tests/test_links.py
+++ b/win_app/tests/test_links.py
@@ -184,6 +184,12 @@ class TakingTests(unittest.TestCase):
self.assertEqual(focus["route"], 1)
self.assertEqual(self.rig.redirects, [True])
+ def test_a_link_ending_after_an_ack_stall_returns_pc_input_home(self):
+ self.assertTrue(self.sender.set_redirecting(True))
+ self.rig.drop(B)
+ self.assertFalse(self.sender.redirecting)
+ self.assertEqual(self.rig.redirects[-1], False)
+
def test_the_clipboard_follows_the_take_and_goes_before_any_input(self):
self.sender.set_redirecting(True)
self.sender.on_key("a", True, 0x41, "a")
@@ -524,13 +530,89 @@ class KeyTests(unittest.TestCase):
def test_the_windows_key_goes_to_a_mac_as_ctrl_in_the_semantic_style(self):
self.sender.on_key("ctrl", True, 0x5B)
- self.assertEqual(self.keys(), [("keydown", "ctrl")])
+ self.assertEqual(self.keys(), [])
+ self.sender.on_key("ctrl", False, 0x5B)
+ self.assertEqual(self.keys(), [("keydown", "ctrl"), ("keyup", "ctrl")])
+
+ def test_a_click_or_scroll_with_the_windows_key_down_carries_it_as_the_mac_modifier(self):
+ def sent():
+ return [m["type"] for m in self.rig.sent(B)
+ if m["type"] in ("keydown", "keyup", "mousedown", "mouseup", "scroll")]
+
+ self.sender.on_key("ctrl", True, 0x5B)
+ self.sender.on_button("left", True)
+ self.assertEqual(sent(), ["keydown", "mousedown"])
+ self.sender.on_button("left", False)
+ self.sender.on_key("ctrl", False, 0x5B)
+ self.assertEqual(sent()[2:], ["mouseup", "keyup"])
+ self.sender.on_key("ctrl", True, 0x5B)
+ self.sender.on_wheel(1, 0)
+ self.assertEqual(sent()[4:], ["keydown", "scroll"])
+
+ def test_windows_key_after_click_can_be_used_for_a_shortcut_without_sticking(self):
+ self.sender.on_key("ctrl", True, 0x5B)
+ self.sender.on_button("left", True)
+ self.sender.on_button("left", False)
+ self.sender.on_key("s", True, 0x53, "s")
+ self.sender.on_key("s", False, 0x53, "s")
+ self.sender.on_key("ctrl", False, 0x5B)
+ self.assertEqual(self.keys(), [
+ ("keydown", "ctrl"), ("keyup", "ctrl"),
+ ("keydown", "spotlight"), ("keyup", "spotlight"),
+ ])
+
+ def test_windows_search_and_dictation_shortcuts_become_mac_intents(self):
+ for vk, key in ((0x53, "s"), (0x48, "h")):
+ self.sender.on_key("ctrl", True, 0x5B)
+ self.sender.on_key(key, True, vk, key)
+ self.sender.on_key(key, False, vk, key)
+ self.sender.on_key("ctrl", False, 0x5B)
+ self.assertEqual(self.keys(), [
+ ("keydown", "spotlight"), ("keyup", "spotlight"),
+ ("keydown", "dictation"), ("keyup", "dictation"),
+ ])
+
+ def test_right_windows_key_shortcuts_become_mac_intents(self):
+ self.sender.on_key("ctrl_r", True, 0x5C)
+ self.sender.on_key("s", True, 0x53, "s")
+ self.sender.on_key("s", False, 0x53, "s")
+ self.sender.on_key("ctrl_r", False, 0x5C)
+ self.assertEqual(self.keys(), [("keydown", "spotlight"), ("keyup", "spotlight")])
+
+ def test_windows_shortcuts_map_safely_to_linux_or_are_dropped(self):
+ self.rig = Rig(entries=[harness.entry(B, "Linux", platform="linux", side="left")])
+ self.sender = self.rig.sender
+ self.sender.set_redirecting(True)
+ self.rig.accept_take()
+ for key, vk in (("s", 0x53), ("h", 0x48), ("n", 0x4E)):
+ self.sender.on_key("ctrl", True, 0x5B)
+ self.sender.on_key(key, True, vk, key)
+ self.sender.on_key(key, False, vk, key)
+ self.sender.on_key("ctrl", False, 0x5B)
+ self.assertEqual(self.keys(), [("keydown", "spotlight"), ("keyup", "spotlight")])
+
+ def test_windows_notifications_shortcut_is_dropped_instead_of_becoming_control_n(self):
+ self.sender.on_key("ctrl", True, 0x5B)
+ self.sender.on_key("n", True, 0x4E, "n")
+ self.sender.on_key("n", False, 0x4E, "n")
+ self.sender.on_key("ctrl", False, 0x5B)
+ self.assertEqual(self.keys(), [])
+
+ def test_windows_shift_search_remains_a_physical_shortcut(self):
+ self.sender.on_key("ctrl", True, 0x5B)
+ self.sender.on_key("shift", True, 0xA0)
+ self.sender.on_key("S", True, 0x53, "s")
+ self.sender.on_key("S", False, 0x53, "s")
+ self.sender.on_key("shift", False, 0xA0)
+ self.sender.on_key("ctrl", False, 0x5B)
+ self.assertNotIn(("keydown", "spotlight"), self.keys())
def test_positional_keeps_each_key_in_its_place(self):
self.sender.update_config(make_config(modifier_style="positional"))
self.sender.on_key("cmd", True, 0xA2)
self.sender.on_key("ctrl", True, 0x5B)
- self.assertEqual(self.keys(), [("keydown", "ctrl"), ("keydown", "cmd")])
+ self.sender.on_key("ctrl", False, 0x5B)
+ self.assertEqual(self.keys(), [("keydown", "ctrl"), ("keydown", "cmd"), ("keyup", "cmd")])
def test_mac_layout_sends_both_sides_of_each_modifier_to_the_mac_key(self):
self.sender.update_config(make_config(modifier_style="mac_layout"))
diff --git a/win_app/tests/test_linux_desktop.py b/win_app/tests/test_linux_desktop.py
new file mode 100644
index 0000000..2460a2c
--- /dev/null
+++ b/win_app/tests/test_linux_desktop.py
@@ -0,0 +1,52 @@
+import unittest
+import os
+import sys
+from pathlib import Path
+from types import SimpleNamespace
+from unittest import mock
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+import linux_desktop
+
+
+class DesktopTests(unittest.TestCase):
+ def test_desktop_tokens_are_case_insensitive_and_colon_separated(self):
+ for value in ("KDE", "kde", "KDE:Plasma", "plasma", "Something:KDE"):
+ with self.subTest(value=value):
+ self.assertEqual(linux_desktop.desktop({"XDG_CURRENT_DESKTOP": value}), "kde")
+ for value in ("GNOME", "ubuntu:GNOME", "GNOME-Classic:GNOME"):
+ with self.subTest(value=value):
+ self.assertEqual(linux_desktop.desktop({"XDG_CURRENT_DESKTOP": value}), "gnome")
+
+ def test_session_desktop_is_a_fallback_not_an_override(self):
+ self.assertEqual(linux_desktop.desktop({"XDG_SESSION_DESKTOP": "KDE"}), "kde")
+ self.assertEqual(linux_desktop.desktop({"XDG_CURRENT_DESKTOP": "GNOME", "XDG_SESSION_DESKTOP": "KDE"}), "gnome")
+ self.assertEqual(linux_desktop.desktop({"XDG_CURRENT_DESKTOP": "Xfce"}), "")
+ self.assertEqual(linux_desktop.desktop({}), "")
+ self.assertEqual(linux_desktop.desktop({"XDG_CURRENT_DESKTOP": "not-kde"}), "")
+
+
+class CrossingGuidanceTests(unittest.TestCase):
+ def test_plasma_has_kwin_guidance_and_gnome_keeps_its_extension_note(self):
+ from PySide6.QtWidgets import QApplication, QVBoxLayout, QWidget
+ import kvm_bridge_win as bridge
+
+ app = QApplication.instance() or QApplication([])
+ for name, shown, included, excluded in (
+ ("KDE", True, "KWin", "AppIndicator"),
+ ("ubuntu:GNOME", True, "AppIndicator", "KWin"),
+ ("Xfce", False, "", "KWin"),
+ ):
+ with self.subTest(desktop=name), mock.patch.dict(os.environ, {"XDG_CURRENT_DESKTOP": name}), mock.patch.object(bridge.sys, "platform", "linux"):
+ host = QWidget()
+ layout = QVBoxLayout(host)
+ view = SimpleNamespace(
+ _ways_module=lambda _: QWidget(), _pointer_module=lambda _: QWidget(), _resistance_module=lambda _: QWidget(),
+ _shortcut_module=lambda _: QWidget(), _reflect_ways=lambda: None, _reflect_other_name=lambda: None,
+ )
+ bridge.WindowsApplication._crossing_page(view, layout, bridge.default_config())
+ self.assertEqual(not view.linux_tray_note.isHidden(), shown)
+ self.assertIn(included, view.linux_tray_note.text())
+ self.assertNotIn(excluded, view.linux_tray_note.text())
+ host.deleteLater()
diff --git a/win_app/tests/test_linux_permissions.py b/win_app/tests/test_linux_permissions.py
new file mode 100644
index 0000000..8a5aae8
--- /dev/null
+++ b/win_app/tests/test_linux_permissions.py
@@ -0,0 +1,314 @@
+import os
+import sys
+import unittest
+from types import SimpleNamespace
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+import pages_win
+import capture_portal
+import inject_portal
+import portal
+from portal_fakes import FakeBus, FakeEi, vardict, wait_for
+from core.tests.app_methods import load_methods
+from PySide6.QtWidgets import QApplication, QHBoxLayout, QVBoxLayout, QWidget
+import widgets
+
+
+class MemoryTokens:
+ def read(self):
+ return ""
+
+ def write(self, _token):
+ pass
+
+
+class LinuxPermissionsTest(unittest.TestCase):
+ @classmethod
+ def setUpClass(cls):
+ cls.app = QApplication.instance() or QApplication([])
+
+ def test_card_is_only_visible_on_linux_wayland(self):
+ visible = pages_win.linux_permissions_visible
+ self.assertTrue(visible("linux", True))
+ self.assertFalse(visible("linux", False))
+ self.assertFalse(visible("win32", True))
+ self.assertFalse(visible("darwin", True))
+
+ def test_portal_reports_each_row_state(self):
+ state = pages_win.LinuxPermissionState()
+ self.assertEqual(state.status("capture"), ("not_requested", ""))
+ self.assertEqual(state.status("remote"), ("not_requested", ""))
+
+ state.report("capture", "ready")
+ state.report("remote", "refused", "The desktop refused remote control.")
+ self.assertEqual(state.status("capture"), ("ready", ""))
+ self.assertEqual(state.status("remote"), ("refused", "The desktop refused remote control."))
+
+ state.report("capture", "unavailable", "InputCapture is missing.")
+ self.assertEqual(state.status("capture"), ("unavailable", "InputCapture is missing."))
+
+ state.report("remote", "unavailable", "The session closed.", retryable=True)
+ self.assertTrue(state.can_ask_again("remote"))
+
+ def test_ask_again_resets_the_row_and_starts_a_fresh_request(self):
+ requests = []
+ state = pages_win.LinuxPermissionState()
+ for direction in ("capture", "remote"):
+ state.bind_requester(direction, lambda key=direction: requests.append(key))
+ state.report(direction, "refused", "The desktop refused the request.")
+ self.assertTrue(state.ask_again(direction))
+ self.assertEqual(state.status(direction), ("not_requested", ""))
+ self.assertEqual(requests, ["capture", "remote"])
+
+ def test_input_capture_requires_both_granted_capabilities(self):
+ for version in (1, 2):
+ with self.subTest(version=version):
+ bus = FakeBus(versions={capture_portal.INTERFACE: version})
+ if version == 2:
+ bus.returns["CreateSession2"] = (vardict({"session_handle": "/session/1"}),)
+ bus.answers["Start"] = (0, {"capabilities": capture_portal.CAP_KEYBOARD})
+ else:
+ bus.answers["CreateSession"] = (0, {
+ "session_handle": "/session/1", "capabilities": capture_portal.CAP_KEYBOARD,
+ })
+ bus.returns["ConnectToEIS"] = (99,)
+ session = capture_portal._Session(lambda: bus, lambda _fd: object(), MemoryTokens(), lambda: False)
+ session.check()
+
+ with self.assertRaises(capture_portal.CaptureUnavailable):
+ session.open()
+
+ self.assertEqual(bus.made("ConnectToEIS"), [])
+
+ @unittest.skipIf(sys.platform == "win32", "the Wayland back ends select on pipes, which Windows cannot; they run only on Linux")
+ def test_remote_desktop_refuses_partial_device_grants(self):
+ state = pages_win.LinuxPermissionState()
+ bus = FakeBus(versions={inject_portal.INTERFACE: 2, inject_portal.CLIPBOARD: 1})
+ bus.answers["CreateSession"] = (0, {"session_handle": "/session/1"})
+ bus.answers["Start"] = (0, {"devices": inject_portal.DEVICE_KEYBOARD})
+ bus.returns["ConnectToEIS"] = (99,)
+ remote = inject_portal.Remote(connect=lambda: bus, ei=lambda _fd: FakeEi(), tokens=MemoryTokens())
+ inject_portal.on_permission = lambda status, detail, retryable=False: state.report(
+ "remote", status, detail, retryable,
+ )
+ try:
+ remote.start()
+ wait_for(lambda: state.status("remote")[0] != "not_requested", what="the permission state")
+ self.assertEqual(state.status("remote")[0], "refused")
+ self.assertTrue(state.can_ask_again("remote"))
+ self.assertEqual(bus.made("ConnectToEIS"), [])
+ finally:
+ remote.stop()
+ inject_portal.on_permission = None
+
+ @unittest.skipIf(sys.platform == "win32", "the Wayland back ends select on pipes, which Windows cannot; they run only on Linux")
+ def test_capture_partial_grant_is_refused_and_retryable(self):
+ state = pages_win.LinuxPermissionState()
+ bus = FakeBus(versions={capture_portal.INTERFACE: 2})
+ bus.returns["CreateSession2"] = (vardict({"session_handle": "/session/1"}),)
+ bus.answers["Start"] = (0, {"capabilities": capture_portal.CAP_KEYBOARD})
+ hooks = capture_portal.Hooks(lambda *_args: False, lambda *_args: False, lambda *_args: None,
+ connect=lambda: bus, ei=lambda _fd: FakeEi(), tokens=MemoryTokens())
+ hooks.on_permission = lambda status, detail, retryable=False: state.report(
+ "capture", status, detail, retryable,
+ )
+ try:
+ hooks.start()
+ wait_for(lambda: state.status("capture")[0] != "not_requested", what="the partial InputCapture grant")
+ self.assertEqual(state.status("capture")[0], "refused")
+ self.assertTrue(state.can_ask_again("capture"))
+ finally:
+ hooks.stop()
+
+ @unittest.skipIf(sys.platform == "win32", "the Wayland back ends select on pipes, which Windows cannot; they run only on Linux")
+ def test_remote_ask_again_opens_a_fresh_portal_request(self):
+ state = pages_win.LinuxPermissionState()
+ buses = []
+ def connect():
+ bus = FakeBus(versions={inject_portal.INTERFACE: 2, inject_portal.CLIPBOARD: 1})
+ bus.answers["CreateSession"] = (0, {"session_handle": f"/session/{len(buses) + 1}"})
+ bus.answers["Start"] = (1, {}) if not buses else (
+ 0, {"devices": inject_portal.DEVICE_KEYBOARD | inject_portal.DEVICE_POINTER},
+ )
+ bus.returns["ConnectToEIS"] = (99,)
+ buses.append(bus)
+ return bus
+ remote = inject_portal.Remote(connect=connect, ei=lambda _fd: FakeEi(), tokens=MemoryTokens())
+ inject_portal.on_permission = lambda status, detail, retryable=False: state.report(
+ "remote", status, detail, retryable,
+ )
+ state.bind_requester("remote", remote.request_again)
+ try:
+ remote.start()
+ wait_for(lambda: state.status("remote")[0] == "refused", what="the permission refusal")
+ self.assertTrue(state.ask_again("remote"))
+ wait_for(lambda: state.status("remote")[0] == "ready", what="the fresh RemoteDesktop request")
+ self.assertEqual([len(bus.made("Start")) for bus in buses], [1, 1])
+ finally:
+ remote.stop()
+ inject_portal.on_permission = None
+
+ @unittest.skipIf(sys.platform == "win32", "the Wayland back ends select on pipes, which Windows cannot; they run only on Linux")
+ def test_capture_ask_again_opens_a_fresh_portal_request(self):
+ state = pages_win.LinuxPermissionState()
+ buses = []
+ def connect():
+ bus = FakeBus(versions={capture_portal.INTERFACE: 2})
+ bus.returns["CreateSession2"] = (vardict({"session_handle": f"/session/{len(buses) + 1}"}),)
+ bus.answers["Start"] = (1, {}) if not buses else (
+ 0, {"capabilities": capture_portal.CAP_KEYBOARD | capture_portal.CAP_POINTER},
+ )
+ bus.returns["ConnectToEIS"] = (99,)
+ bus.answers["GetZones"] = (0, {"zones": []})
+ buses.append(bus)
+ return bus
+ hooks = capture_portal.Hooks(lambda *_args: False, lambda *_args: False, lambda *_args: None,
+ connect=connect, ei=lambda _fd: FakeEi(), tokens=MemoryTokens())
+ hooks.on_permission = lambda status, detail, retryable=False: state.report(
+ "capture", status, detail, retryable,
+ )
+ state.bind_requester("capture", hooks.request_again)
+ try:
+ hooks.start()
+ wait_for(lambda: state.status("capture")[0] == "refused", what="the capture refusal")
+ self.assertEqual(state.status("capture")[0], "refused")
+ self.assertTrue(state.ask_again("capture"))
+ wait_for(lambda: state.status("capture")[0] == "ready", what="the fresh InputCapture request")
+ self.assertEqual([len(bus.made("Start")) for bus in buses], [1, 1])
+ finally:
+ hooks.stop()
+
+ def test_permissions_widget_shows_states_and_retry_visibility(self):
+ surface = self.permissions_surface("linux", True)
+ surface._overview_page(QVBoxLayout(), None)
+ module = surface.permissions_module
+ self.assertIsNotNone(surface.permissions_module)
+ for direction in ("capture", "remote"):
+ status, detail, retry = surface.permission_rows[direction]
+ self.assertEqual(status.text(), "Not requested")
+ self.assertTrue(retry.isHidden())
+ surface.permission_state.report(direction, "refused", "Access was refused.")
+ self.assertEqual(status.text(), "Refused")
+ self.assertEqual(detail.text(), "Access was refused.")
+ self.assertFalse(retry.isHidden())
+ surface.permission_state.report(direction, "unavailable", "Portal is unavailable.")
+ self.assertEqual(status.text(), "Unavailable")
+ self.assertTrue(retry.isHidden())
+ surface.permission_state.report(direction, "unavailable", "Session closed.", retryable=True)
+ self.assertFalse(retry.isHidden())
+ surface.permission_state.report(direction, "ready")
+ self.assertEqual(status.text(), "Ready")
+ self.assertTrue(retry.isHidden())
+ requests = []
+ surface.permission_state.bind_requester(direction, lambda: requests.append(direction))
+ surface.permission_state.report(direction, "refused", "Access was refused.")
+ retry.click()
+ self.assertEqual(requests, [direction])
+ self.assertEqual(status.text(), "Not requested")
+ module.deleteLater()
+
+ def test_overview_omits_permissions_card_on_x11_and_windows(self):
+ for platform_name, wayland in (("linux", False), ("win32", True)):
+ surface = self.permissions_surface(platform_name, wayland)
+ layout = QVBoxLayout()
+ surface._overview_page(layout, None)
+ self.assertIsNone(surface.permissions_module)
+
+ def permissions_surface(self, platform_name, wayland):
+ namespace = {
+ "pages_win": pages_win,
+ "widgets": widgets,
+ "QVBoxLayout": QVBoxLayout,
+ "QHBoxLayout": QHBoxLayout,
+ "QPushButton": widgets.ActionButton,
+ "QWidget": QWidget,
+ "sys": SimpleNamespace(platform=platform_name),
+ "platform_parts": SimpleNamespace(WAYLAND=wayland),
+ "machines_win": SimpleNamespace(MachinesModule=lambda *_args, **_kwargs: QWidget(),
+ PairingSheet=lambda *_args: QWidget()),
+ }
+ methods = ["_overview_page", "_permissions_module", "_on_permission", "_ask_permission_again"]
+ klass = load_methods("win_app/kvm_bridge_win.py", "WindowsApplication", methods, namespace)
+ surface = klass()
+ surface.permission_state = pages_win.LinuxPermissionState() if pages_win.linux_permissions_visible(
+ platform_name, wayland,
+ ) else None
+ if surface.permission_state is not None:
+ surface.permission_state.on_change = surface._on_permission
+ surface._set_peer_send = surface._set_peer_allow = surface._set_peer_in_use = lambda *_args: None
+ surface._set_shortcut_cycle = lambda *_args: None
+ surface._re_pair = lambda *_args: None
+ surface._set_peer_left_out = surface._rename_peer = lambda *_args: None
+ surface._remove_peer = surface._toggle_pairing_sheet = lambda *_args: None
+ surface._show_code = surface._cancel_code = surface._pair_clicked = surface._pick_machine = lambda *_args: None
+ surface._link_module = surface._input_module = surface._same_module = surface._name_module = lambda *_args: QWidget()
+ surface._sign_in_module = surface._updates_module = lambda *_args: QWidget()
+ surface._refresh_peers = lambda: None
+ return surface
+
+ def test_refusal_during_select_devices_is_retryable(self):
+ state = pages_win.LinuxPermissionState()
+ bus = FakeBus(versions={inject_portal.INTERFACE: 2, inject_portal.CLIPBOARD: 1})
+ bus.answers["CreateSession"] = (0, {"session_handle": "/session/1"})
+ bus.answers["SelectDevices"] = (1, {})
+ remote = inject_portal.Remote(connect=lambda: bus, ei=lambda _fd: FakeEi(), tokens=MemoryTokens())
+ inject_portal.on_permission = lambda status, detail, retryable=False: state.report(
+ "remote", status, detail, retryable,
+ )
+ try:
+ remote.start()
+ wait_for(lambda: state.status("remote")[0] != "not_requested", what="the permission refusal")
+ self.assertEqual(state.status("remote")[0], "refused")
+ self.assertTrue(state.can_ask_again("remote"))
+ finally:
+ remote.stop()
+ inject_portal.on_permission = None
+
+ @unittest.skipIf(sys.platform == "win32", "the Wayland back ends select on pipes, which Windows cannot; they run only on Linux")
+ def test_remote_desktop_closed_signal_can_be_asked_again(self):
+ state = pages_win.LinuxPermissionState()
+ bus = FakeBus(versions={inject_portal.INTERFACE: 2, inject_portal.CLIPBOARD: 1})
+ bus.answers["CreateSession"] = (0, {"session_handle": "/session/1"})
+ bus.answers["Start"] = (0, {"devices": inject_portal.DEVICE_KEYBOARD | inject_portal.DEVICE_POINTER})
+ bus.returns["ConnectToEIS"] = (99,)
+ remote = inject_portal.Remote(connect=lambda: bus, ei=lambda _fd: FakeEi(), tokens=MemoryTokens())
+ inject_portal.on_permission = lambda status, detail, retryable=False: state.report(
+ "remote", status, detail, retryable,
+ )
+ try:
+ remote.start()
+ wait_for(remote.ready.is_set, what="RemoteDesktop readiness")
+ bus.emit("/session/1", portal.SESSION, "Closed", ())
+ wait_for(lambda: state.status("remote")[0] == "unavailable", what="the closed session")
+ self.assertTrue(state.can_ask_again("remote"))
+ finally:
+ remote.stop()
+ inject_portal.on_permission = None
+
+ @unittest.skipIf(sys.platform == "win32", "the Wayland back ends select on pipes, which Windows cannot; they run only on Linux")
+ def test_input_capture_closed_signal_can_be_asked_again(self):
+ state = pages_win.LinuxPermissionState()
+ bus = FakeBus(versions={capture_portal.INTERFACE: 2})
+ bus.returns["CreateSession2"] = (vardict({"session_handle": "/session/1"}),)
+ bus.returns["ConnectToEIS"] = (99,)
+ bus.answers["Start"] = (0, {"capabilities": capture_portal.CAP_KEYBOARD | capture_portal.CAP_POINTER})
+ bus.answers["GetZones"] = (0, {"zones": []})
+ hooks = capture_portal.Hooks(lambda *_args: False, lambda *_args: False, lambda *_args: None,
+ connect=lambda: bus, ei=lambda _fd: FakeEi(), tokens=MemoryTokens())
+ hooks.on_permission = lambda status, detail, retryable=False: state.report(
+ "capture", status, detail, retryable,
+ )
+ try:
+ hooks.start()
+ wait_for(lambda: state.status("capture")[0] == "ready", what="InputCapture readiness")
+ bus.emit("/session/1", portal.SESSION, "Closed", ())
+ wait_for(lambda: state.status("capture")[0] == "unavailable", what="the closed session")
+ self.assertTrue(state.can_ask_again("capture"))
+ finally:
+ hooks.stop()
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/win_app/tests/test_linux_start.py b/win_app/tests/test_linux_start.py
index cb1725f..7ddce37 100644
--- a/win_app/tests/test_linux_start.py
+++ b/win_app/tests/test_linux_start.py
@@ -9,6 +9,7 @@ Windows is unchanged."""
import json
import os
+import re
import subprocess
import sys
import tempfile
@@ -99,7 +100,7 @@ def child(mode: str, config: Path) -> None:
assert platform_parts.WAYLAND is True
assert "only brings input back" in window.wayland_shortcut_note.text()
assert not window.wayland_shortcut_note.isHidden()
- assert window.hold_switch.isHidden() and window.crossing_rows["dragging"].isHidden()
+ assert window.hold_switch.isHidden() and window.pointer_module.isHidden()
assert "full-screen" in window.wayland_crossing_note.text() and not window.wayland_crossing_note.isHidden()
window._on_pressure("right", 0.7, False)
window._on_arrival("edge", "left", 10.0, 10.0)
@@ -113,11 +114,19 @@ def child(mode: str, config: Path) -> None:
original = kvm_bridge_win.WindowsApplication.start
def start_then_quit(self):
+ if mode == "main":
+ assert self.isVisible() and self._startup_painted
+ else:
+ # --hidden still shows the window when there is no tray to find it in.
+ assert self.isVisible() == (not self.tray_available) and not self._startup_painted
+ assert not QApplication.startingUp()
original(self)
QTimer.singleShot(200, QApplication.quit)
kvm_bridge_win.WindowsApplication.start = start_then_quit
- sys.argv = ["beamer", "--config", str(config), "--hidden"]
+ sys.argv = ["beamer", "--config", str(config)]
+ if mode == "main-hidden":
+ sys.argv.append("--hidden")
try:
kvm_bridge_win.main()
except SystemExit as exit_:
@@ -190,13 +199,20 @@ class LinuxStartTest(unittest.TestCase):
}))
env = dict(os.environ, QT_QPA_PLATFORM="offscreen", XDG_CONFIG_HOME=directory, XDG_SESSION_TYPE="wayland")
env.pop("LOCALAPPDATA", None)
- for mode in ("window", "main"):
+ for mode in ("window", "main", "main-hidden"):
done = subprocess.run(
[sys.executable, str(Path(__file__).resolve()), mode, str(config)],
env=env, capture_output=True, text=True, timeout=120,
)
self.assertEqual(done.returncode, 0, mode + done.stdout + done.stderr)
self.assertIn("ok", done.stdout)
+ if mode == "main":
+ log = Path(directory) / "Beamer" / "Beamer.log"
+ measurement = re.search(
+ r"Window painted (\d+\.\d{3}) seconds after process start", log.read_text()
+ )
+ self.assertIsNotNone(measurement)
+ print(f"Offscreen source first paint: {measurement.group(1)} seconds")
@unittest.skipIf(sys.platform == "win32", "a faked platform breaks the Windows stdlib")
def test_on_x11_the_x11_parts_start_and_the_receiver_listens(self):
diff --git a/win_app/tests/test_map_ticks.py b/win_app/tests/test_map_ticks.py
new file mode 100644
index 0000000..854ec32
--- /dev/null
+++ b/win_app/tests/test_map_ticks.py
@@ -0,0 +1,358 @@
+"""The Crossing map's thirds breaks, shortcut-cycle badge, status dot, fit and seam on a standalone Qt
+canvas with synthetic tiles (rc14: ticks hung inside the lower tile, the badge sat on the status dot)."""
+
+import os
+import sys
+import unittest
+from pathlib import Path
+
+os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+PARTS = ["start", "middle", "end"]
+OWN, LAPTOP, FEDORA, DESK = "0a" * 16, "1b" * 16, "2c" * 16, "3d" * 16
+LABELS = {OWN: "This PC", LAPTOP: "Loan laptop with a long name", FEDORA: "fedora", DESK: "Desk-PC-Workstation"}
+DISPLAYS = {"0": {"x": 0, "y": 0, "w": 2560, "h": 1440}, "1": {"x": 2560, "y": 0, "w": 1512, "h": 982}}
+# An external display with the shorter built-in to its right, top edges level, and a machine below
+# reaching under both: only the external's bottom edge touches it.
+WITH_DISPLAYS = {OWN: {"x": 0, "y": 0, "w": 226, "h": 80, "displays": DISPLAYS},
+ DESK: {"x": 60, "y": 80, "w": 113, "h": 70}}
+TWO_WIDE = {"a": {"x": 0, "y": 0, "w": 1920, "h": 1080}, "b": {"x": 1920, "y": 0, "w": 1920, "h": 1080}}
+# Two displays meeting at a corner beside a side contact: under this PC and off its bottom-right
+# corner, then this PC's right-hand display off the bottom-right corner of a machine under its left one.
+DISPLAY_CORNERS = ({OWN: {"x": 0, "y": 0, "w": 160, "h": 90}, DESK: {"x": 0, "y": 90, "w": 320, "h": 90, "displays": TWO_WIDE}},
+ {OWN: {"x": 0, "y": 0, "w": 160, "h": 90, "displays": TWO_WIDE}, DESK: {"x": 0, "y": 90, "w": 80, "h": 90}})
+ROW = {OWN: {"x": 0, "y": 0, "w": 160, "h": 100},
+ LAPTOP: {"x": -160, "y": 0, "w": 160, "h": 100},
+ FEDORA: {"x": -320, "y": 0, "w": 160, "h": 100},
+ DESK: {"x": 0, "y": 100, "w": 160, "h": 100}}
+
+
+def peer_state(**changes):
+ return {"state": "edge", "crosses": True, "linked": True, "thirds": PARTS, "lit": PARTS,
+ "detail": "Windows · Linked", **changes}
+
+
+class MapTicks(unittest.TestCase):
+ def setUp(self):
+ from PySide6.QtWidgets import QApplication
+
+ self.app = QApplication.instance() or QApplication([])
+
+ def canvas(self, tiles=ROW, width=850, desk=None, cycle=None):
+ from diagram import AtlasCanvas
+
+ canvas = AtlasCanvas()
+ self.addCleanup(canvas.deleteLater)
+ canvas.resize(width, 268)
+ states = {key: peer_state() for key in tiles if key != OWN}
+ states[OWN] = {"state": "this", "detail": "Desk PC"}
+ states[DESK] = peer_state(**(desk or {}))
+ canvas.set_tiles(tiles, LABELS, states, DESK, cycle_mode="ticked",
+ cycle=cycle or {key: True for key in tiles if key != OWN}, own_id=OWN)
+ self.paint(canvas)
+ return canvas
+
+ def paint(self, canvas, ratio=1):
+ from PySide6.QtCore import Qt
+ from PySide6.QtGui import QImage
+
+ image = QImage(canvas.width() * ratio, canvas.height() * ratio, QImage.Format.Format_ARGB32)
+ image.setDevicePixelRatio(ratio)
+ image.fill(Qt.GlobalColor.transparent)
+ canvas.render(image)
+ return image
+
+ def bottom_pieces(self, canvas):
+ return sorted((path for path in canvas.seam_paths if path[0] == "bottom"), key=lambda path: path[1].x())
+
+ def assert_breaks(self, canvas, wanted):
+ import diagram
+
+ pieces = self.bottom_pieces(canvas)
+ self.assertEqual(len(pieces), len(wanted) + 1)
+ for before, after, point in zip(pieces, pieces[1:], wanted):
+ seen_end = before[2].x() + before[4] / 2
+ seen_start = after[1].x() - after[4] / 2
+ self.assertAlmostEqual((seen_end + seen_start) / 2, point, delta=0.01)
+ self.assertAlmostEqual(seen_start - seen_end, diagram.THIRD_GAP, delta=0.01)
+
+ def test_breaks_are_centred_on_the_thirds_of_the_shared_stretch(self):
+ canvas = self.canvas()
+ own = canvas.tile_rect(OWN)
+ self.assert_breaks(canvas, [own.left() + own.width() / 3, own.left() + 2 * own.width() / 3])
+
+ def test_an_unlit_third_breaks_the_same_way_as_a_lit_one(self):
+ canvas = self.canvas(desk={"thirds": ["start", "end"], "lit": ["start", "end"]})
+ own = canvas.tile_rect(OWN)
+ self.assertEqual([path[4] for path in self.bottom_pieces(canvas)], [4.0, 2.0, 4.0])
+ self.assert_breaks(canvas, [own.left() + own.width() / 3, own.left() + 2 * own.width() / 3])
+
+ def test_partial_contact_breaks_at_this_pcs_own_third_boundaries(self):
+ canvas = self.canvas({OWN: ROW[OWN], DESK: {"x": 40, "y": 100, "w": 80, "h": 100}})
+ own = canvas.tile_rect(OWN)
+ self.assert_breaks(canvas, [own.left() + own.width() / 3, own.left() + 2 * own.width() / 3])
+ pieces = self.bottom_pieces(canvas)
+ self.assertAlmostEqual(pieces[0][1].x(), own.left() + 40 * canvas._scale + 2)
+ self.assertAlmostEqual(pieces[-1][2].x(), own.left() + 120 * canvas._scale - 2)
+
+ def test_nothing_for_the_thirds_is_drawn_outside_the_seam_band(self):
+ from PySide6.QtCore import QPointF
+ from unittest.mock import patch
+ import diagram
+
+ for desk in ({}, {"thirds": ["middle"], "lit": ["middle"]}):
+ with self.subTest(desk=desk):
+ canvas = self.canvas(desk=desk)
+ line = canvas.tile_rect(OWN).bottom()
+ own = canvas.tile_rect(OWN)
+ lines = []
+ original = diagram.QPainter
+
+ class RecordingPainter(original):
+ def drawLine(self, *args):
+ if len(args) == 2:
+ lines.append((QPointF(args[0]), QPointF(args[1]), self.pen().widthF()))
+ return super().drawLine(*args)
+
+ with patch.object(diagram, "QPainter", RecordingPainter):
+ self.paint(canvas)
+ near = [entry for entry in lines if own.left() - 1 <= entry[0].x() <= own.right() + 1
+ and abs(entry[0].y() - line) < 10]
+ self.assertTrue(near)
+ for one, two, width in near:
+ for point in (one, two):
+ self.assertLessEqual(abs(point.y() - line) + width / 2, 2.0)
+
+ def test_unselected_peer_seam_is_one_unbroken_line(self):
+ canvas = self.canvas()
+ left = [path for path in canvas.seam_paths if path[0] == "left"]
+ own = canvas.tile_rect(OWN)
+ self.assertEqual(len(left), 1)
+ self.assertAlmostEqual(left[0][1].y(), own.top() + 2)
+ self.assertAlmostEqual(left[0][2].y(), own.bottom() - 2)
+
+ def test_edge_off_draws_nothing_for_the_thirds(self):
+ canvas = self.canvas(desk={"crosses": False, "edge_off": True, "thirds": [], "lit": []})
+ self.assertEqual(self.bottom_pieces(canvas), [])
+
+ def test_lit_seam_lies_on_the_shared_edge_and_spans_the_shared_stretch(self):
+ canvas = self.canvas()
+ own, desk = canvas.tile_rect(OWN), canvas.tile_rect(DESK)
+ self.assertAlmostEqual(own.bottom(), desk.top(), delta=0.5)
+ pieces = self.bottom_pieces(canvas)
+ for _side, one, two, _alpha, _width in pieces:
+ self.assertAlmostEqual(one.y(), desk.top(), delta=0.5)
+ self.assertAlmostEqual(two.y(), own.bottom(), delta=0.5)
+ self.assertAlmostEqual(pieces[0][1].x(), own.left() + 2)
+ self.assertAlmostEqual(pieces[-1][2].x(), own.right() - 2)
+
+ def test_badge_never_meets_the_name_at_any_tile_height(self):
+ for width, band in ((850, "row"), (260, "small"), (200, "tiny")):
+ canvas = self.canvas(width=width)
+ for key in canvas.tiles:
+ rect = canvas.tile_rect(key)
+ with self.subTest(band=band, peer=LABELS[key]):
+ {"row": lambda: self.assertGreaterEqual(rect.height(), 56),
+ "small": lambda: self.assertTrue(44 <= rect.height() < 56),
+ "tiny": lambda: self.assertLess(rect.height(), 44)}[band]()
+ title = canvas._title_rect(key, rect)
+ if key == OWN:
+ self.assertFalse(canvas._shows_cycle(key))
+ self.assertAlmostEqual(title.left(), rect.left() + 8)
+ continue
+ box = canvas._cycle_box(rect)
+ self.assertEqual((box.width(), box.height()), (16, 16))
+ self.assertAlmostEqual(box.left(), rect.right() - 24)
+ self.assertFalse(box.intersects(title))
+ if band == "small":
+ self.assertGreaterEqual(title.width(), rect.width() - 16 - 1e-9)
+ self.assertAlmostEqual(title.top(), rect.top() + 4)
+ self.assertAlmostEqual(box.top(), rect.bottom() - 20)
+ else:
+ self.assertAlmostEqual(box.center().y(), title.center().y())
+ if band == "tiny":
+ self.assertAlmostEqual(title.right(), box.left() - 6)
+
+ def test_a_name_that_fits_stays_centred_and_a_long_one_takes_the_room_left_of_the_badge(self):
+ canvas = self.canvas()
+ fedora, laptop = canvas.tile_rect(FEDORA), canvas.tile_rect(LAPTOP)
+ short, long = canvas._title_rect(FEDORA, fedora), canvas._title_rect(LAPTOP, laptop)
+ self.assertAlmostEqual(short.left(), fedora.left() + 30)
+ self.assertAlmostEqual(short.left() - fedora.left(), fedora.right() - short.right())
+ self.assertAlmostEqual(long.left(), laptop.left() + 8)
+ self.assertAlmostEqual(long.right(), canvas._cycle_box(laptop).left() - 6)
+
+ def test_cycle_hit_follows_the_badge_under_the_name(self):
+ from PySide6.QtCore import Qt
+ from PySide6.QtTest import QTest
+
+ toggled = []
+ canvas = self.canvas(width=260)
+ canvas.on_cycle = lambda peer, enabled: toggled.append((peer, enabled))
+ rect = canvas.tile_rect(DESK)
+ box = canvas._cycle_box(rect)
+ self.assertAlmostEqual(box.top(), rect.bottom() - 20)
+ QTest.mouseClick(canvas, Qt.MouseButton.LeftButton, pos=box.center().toPoint())
+ self.assertEqual(toggled, [(DESK, False)])
+
+ def test_cycle_hit_area_is_the_box_grown_to_24(self):
+ from PySide6.QtCore import QPointF, Qt
+ from PySide6.QtTest import QTest
+
+ toggled = []
+ canvas = self.canvas()
+ canvas.on_cycle = lambda peer, enabled: toggled.append((peer, enabled))
+ rect = canvas.tile_rect(DESK)
+ box = canvas._cycle_box(rect)
+ hit = canvas._cycle_hit_rect(rect)
+ self.assertEqual((hit.left(), hit.top(), hit.width(), hit.height()),
+ (box.left() - 4, box.top() - 4, 24, 24))
+ QTest.mouseClick(canvas, Qt.MouseButton.LeftButton, pos=box.center().toPoint())
+ self.assertEqual(toggled, [(DESK, False)])
+ QTest.mouseClick(canvas, Qt.MouseButton.LeftButton, pos=QPointF(hit.left() + 1, hit.top() + 1).toPoint())
+ self.assertEqual(toggled, [(DESK, False), (DESK, True)])
+ QTest.mouseClick(canvas, Qt.MouseButton.LeftButton, pos=QPointF(rect.right() - 2, rect.top() + 2).toPoint())
+ self.assertEqual(len(toggled), 2)
+
+ def test_check_glyph_is_a_tick_and_off_is_an_outlined_well(self):
+ from PySide6.QtGui import QColor
+ import theme
+
+ def ink_points(canvas):
+ image = self.paint(canvas, 2)
+ box = canvas._cycle_box(canvas.tile_rect(DESK))
+ ground, fill = QColor(theme.colour("ground")), QColor(theme.colour("ink_2"))
+ found = []
+ for py in range(round((box.top() + 2) * 2), round((box.bottom() - 2) * 2)):
+ for px in range(round((box.left() + 2) * 2), round((box.right() - 2) * 2)):
+ colour = image.pixelColor(px, py)
+ near = lambda other: sum((a - b) ** 2 for a, b in zip(
+ (colour.red(), colour.green(), colour.blue()), (other.red(), other.green(), other.blue())))
+ if near(ground) < near(fill):
+ found.append((px / 2, py / 2))
+ return box, found
+
+ box, ink = ink_points(self.canvas())
+ self.assertGreater(len(ink), 10)
+ lowest = max(point[1] for point in ink)
+ highest = min(point[1] for point in ink)
+ bottom = [point[0] for point in ink if point[1] == lowest]
+ top = [point[0] for point in ink if point[1] == highest]
+ self.assertLess(sum(bottom) / len(bottom), box.center().x())
+ self.assertGreater(sum(top) / len(top), box.center().x())
+ canvas = self.canvas(cycle={DESK: False})
+ image = self.paint(canvas)
+ box = canvas._cycle_box(canvas.tile_rect(DESK))
+ self.assertEqual(image.pixelColor(box.center().toPoint()), QColor(theme.colour("well")))
+
+ def test_status_dot_sits_at_the_left_of_the_detail_line(self):
+ from PySide6.QtCore import QPoint
+ from PySide6.QtGui import QColor
+ import theme
+
+ canvas = self.canvas()
+ image = self.paint(canvas)
+ signal = QColor(theme.colour("signal"))
+ for key in canvas.tiles:
+ rect = canvas.tile_rect(key)
+ with self.subTest(peer=LABELS[key]):
+ self.assertEqual(image.pixelColor(QPoint(round(rect.left() + 15), round(rect.top() + 39))), signal)
+ self.assertNotEqual(image.pixelColor(QPoint(round(rect.right() - 13), round(rect.top() + 13))), signal)
+
+ def test_map_fits_and_centres_the_whole_arrangement(self):
+ for width in (850, 240, 480):
+ with self.subTest(width=width):
+ canvas = self.canvas(width=width)
+ rects = [canvas.tile_rect(key) for key in canvas.tiles]
+ left, right = min(r.left() for r in rects), max(r.right() for r in rects)
+ top, bottom = min(r.top() for r in rects), max(r.bottom() for r in rects)
+ self.assertAlmostEqual((left + right) / 2, canvas.width() / 2, delta=1)
+ self.assertAlmostEqual((top + bottom) / 2, canvas.height() / 2, delta=1)
+ room_w, room_h = canvas.width() - 24, canvas.height() - 24
+ self.assertTrue(abs(canvas._scale - 1.0) < 1e-9 or abs(right - left - room_w) <= 1
+ or abs(bottom - top - room_h) <= 1, (canvas._scale, right - left, bottom - top))
+ self.assertLessEqual(right - left, room_w + 1e-6)
+ self.assertLessEqual(bottom - top, room_h + 1e-6)
+
+ def external(self):
+ from core import ways
+
+ return next(screen for screen in ways._display_frames(WITH_DISPLAYS[OWN]) if screen["display"] == "0")
+
+ def test_with_displays_the_seam_runs_only_where_a_display_edge_touches_the_machine(self):
+ for desk in ({}, {"thirds": ["start", "middle"], "lit": ["start", "middle"]}):
+ with self.subTest(desk=desk):
+ canvas = self.canvas(WITH_DISPLAYS, desk=desk)
+ own, external = canvas.tile_rect(OWN), self.external()
+ bottom = own.top() + (external["y"] + external["h"]) * canvas._scale
+ pieces = self.bottom_pieces(canvas)
+ self.assertTrue(pieces)
+ for _side, one, two, _alpha, width in pieces:
+ self.assertAlmostEqual(one.y(), bottom)
+ self.assertAlmostEqual(two.y(), bottom)
+ self.assertGreaterEqual(one.x() - width / 2, own.left() + 60 * canvas._scale - 1e-9)
+ self.assertLessEqual(two.x() + width / 2,
+ own.left() + (external["x"] + external["w"]) * canvas._scale + 1e-9)
+
+ def test_with_displays_the_breaks_are_at_that_displays_thirds_inside_the_contact(self):
+ from PySide6.QtCore import QPointF
+
+ canvas = self.canvas(WITH_DISPLAYS)
+ own, external = canvas.tile_rect(OWN), self.external()
+ self.assert_breaks(canvas, [own.left() + (external["x"] + 2 * external["w"] / 3) * canvas._scale])
+ y = own.top() + 80 * canvas._scale + 4
+ end = own.left() + (external["x"] + 0.9 * external["w"]) * canvas._scale
+ self.assertEqual(canvas._third_at(QPointF(end, y)), (DESK, "end"))
+ self.assertEqual(canvas._third_at(QPointF(own.left() + 70 * canvas._scale, y)), (DESK, "middle"))
+ self.assertIsNone(canvas._third_at(QPointF(own.left() + 160 * canvas._scale, y)))
+ self.assertEqual(canvas._third_tooltip(*canvas._third_segment_at(QPointF(end, y))),
+ "Right third: click to leave it out")
+
+ def corner_dots(self, canvas):
+ from unittest.mock import patch
+ import diagram
+
+ dots = []
+ original = diagram.QPainter
+
+ class RecordingPainter(original):
+ def drawEllipse(self, *args):
+ if len(args) == 3 and args[1] == 3.5:
+ dots.append(args[0])
+ return super().drawEllipse(*args)
+
+ with patch.object(diagram, "QPainter", RecordingPainter):
+ self.paint(canvas)
+ return dots
+
+ def test_a_corner_where_two_displays_meet_beside_a_side_contact_is_not_drawn(self):
+ for tiles in DISPLAY_CORNERS:
+ for selected in (DESK, OWN):
+ with self.subTest(tiles=sorted(tiles[DESK]), selected=selected == DESK):
+ canvas = self.canvas(tiles)
+ canvas.selected = selected
+ self.assertEqual(self.corner_dots(canvas), [])
+ self.assertEqual({path[0] for path in canvas.seam_paths}, {"bottom"})
+
+ def test_a_machine_reached_at_a_corner_alone_keeps_its_dot(self):
+ canvas = self.canvas({OWN: ROW[OWN], DESK: {"x": 160, "y": 100, "w": 160, "h": 100}})
+ canvas.selected = OWN
+ own = canvas.tile_rect(OWN)
+ dots = self.corner_dots(canvas)
+ self.assertEqual(len(dots), 1)
+ self.assertAlmostEqual(dots[0].x(), own.right())
+ self.assertAlmostEqual(dots[0].y(), own.bottom())
+
+ def test_the_join_between_a_machines_displays_is_not_a_break(self):
+ tiles = {OWN: {"x": 0, "y": 0, "w": 160, "h": 90},
+ DESK: {"x": 0, "y": 90, "w": 160, "h": 90, "displays": TWO_WIDE}}
+ for lit in (["start"], PARTS):
+ with self.subTest(lit=lit):
+ canvas = self.canvas(tiles, desk={"thirds": lit, "lit": lit})
+ own = canvas.tile_rect(OWN)
+ self.assert_breaks(canvas, [own.left() + own.width() / 3, own.left() + 2 * own.width() / 3])
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/win_app/tests/test_pages_win.py b/win_app/tests/test_pages_win.py
index e8525da..fb90c90 100644
--- a/win_app/tests/test_pages_win.py
+++ b/win_app/tests/test_pages_win.py
@@ -1,11 +1,14 @@
import os
import unittest
import sys
+import time
+from unittest import mock
sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
import app_config
from core import effects
+from core import ways
import pages_win
try:
@@ -225,7 +228,7 @@ class SwitchGroupsTest(unittest.TestCase):
def test_simple_and_aperture_come_first_then_the_crossing_directions(self):
groups = pages_win.switch_groups()
- self.assertEqual(groups[0], ("Simple", (("match", "Same as crossing", "Plays the crossing style"),
+ self.assertEqual(groups[0], ("Simple", (("match", "Same as crossing", "Plays Glow"),
("locator", "Ring", "Closes onto the pointer"))))
self.assertEqual(groups[1], ("Light", (("aperture", "Aperture", "Showpiece"),)))
self.assertEqual(groups[2:], pages_win.style_groups()[1:])
@@ -313,6 +316,7 @@ class CrossingPageTest(unittest.TestCase):
import tempfile
from pathlib import Path
+ from PySide6.QtCore import QCoreApplication, QEvent
from PySide6.QtWidgets import QApplication
os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
@@ -333,6 +337,7 @@ class CrossingPageTest(unittest.TestCase):
app_config.write_settings(self.path, settings)
self.page = kvm_bridge_win.WindowsApplication(self.path)
self.page._send_to = lambda peer, message: True
+ self.addCleanup(QCoreApplication.sendPostedEvents, None, QEvent.Type.DeferredDelete)
self.addCleanup(self.page.deleteLater)
self.addCleanup(self.page.server.stop)
@@ -340,14 +345,50 @@ class CrossingPageTest(unittest.TestCase):
app_config.set_ways(self.path, self.peer, side=side, methods=list(methods), parts=list(parts), corner="top_left")
self.page._pull_peer_fields()
- def shown(self):
- import motion
+ def test_fixture_releases_window_before_the_next_case(self):
+ from shiboken6 import isValid
page = self.page
- rows = {key for key, row in page.crossing_rows.items() if motion.target_shown(row)}
- rows |= {"resistance"} if motion.target_shown(page.resistance_module) else set()
- rows |= {"shortcut"} if motion.target_shown(page.shortcut_module) else set()
- return rows
+ self.doCleanups()
+ self.assertFalse(isValid(page))
+
+ def test_incoming_layout_keeps_a_locally_held_paired_tile_when_missing(self):
+ from core import protocol, settings_sync
+ from core.tests import responder_harness as harness
+
+ settings = app_config.load_settings(self.path)
+ paired = protocol.id_text(bytes(range(110, 126)))
+ own = settings["machine_id"]
+ settings["peers"][0]["paired_with"] = [paired]
+ settings["layout"][own] = {"x": 0, "y": 0, "w": 160, "h": 100}
+ settings["layout"][self.peer] = {"x": 172, "y": 0, "w": 160, "h": 100}
+ settings["layout"][paired] = {"x": 500, "y": 100, "w": 160, "h": 100, "name": "Test box"}
+ app_config.write_settings(self.path, settings)
+ self.page._config = app_config.load_config(self.path)
+ source_id = protocol.read_id(self.peer)
+ self.page._peer_caps = lambda: {source_id: {"settings", "layout"}}
+ self.page._design_peer_caps = lambda: {self.peer: {"settings", "layout"}}
+ incoming = {
+ settings["machine_id"]: dict(settings["layout"][settings["machine_id"]]),
+ self.peer: dict(settings["layout"][self.peer]),
+ }
+ data = settings_sync.message_data(False, 0, by=self.peer,
+ layout_state={"set_at": self.page._config.layout_set_at + 1, "by": self.peer, "tiles": incoming})
+
+ self.page._on_settings(self.peer, data)
+
+ self.assertEqual(app_config.load_settings(self.path)["layout"][paired], settings["layout"][paired])
+
+ def test_each_gap_has_its_own_ledger_place_instruction(self):
+ from core import protocol
+ from core.tests import responder_harness as harness
+ settings = app_config.load_settings(self.path)
+ second = protocol.id_text(harness.C)
+ settings["peers"].append(harness.entry(harness.C, "Other", side="right"))
+ settings["layout"][second] = dict(x=500, y=100, w=160, h=100)
+ app_config.write_settings(self.path, settings)
+ self.page._pull_peer_fields()
+ self.assertEqual(self.page.crossing_ledger.rows[second].edge_value.text(), "Off")
def test_the_native_titlebar_can_maximise_and_has_no_width_cap(self):
from PySide6.QtCore import Qt
@@ -365,53 +406,432 @@ class CrossingPageTest(unittest.TestCase):
self.page._select_page("crossing")
QApplication.processEvents()
- self.assertLessEqual(self.page.arrangement_diagram.width(), tokens.PAGE_CONTENT_MAX)
- self.assertLessEqual(max(button.width() for button in self.page.edge_choice._buttons.values()), tokens.PAGE_CONTENT_MAX / 4)
+ self.assertLessEqual(self.page.atlas_canvas.width(), tokens.PAGE_CONTENT_MAX)
+
+ def test_ledger_jump_arms_its_hint_in_place(self):
+ row = self.page.crossing_ledger.rows[self.peer]
+ self.assertEqual(row.jump.key.text(), "Set a key")
+ self.assertTrue(row.jump.hint.isHidden())
+ row.jump._toggle()
+ self.assertFalse(row.jump.hint.isHidden())
- def test_jump_placeholder_uses_body_text_with_the_hint_below(self):
+ def test_ledger_rows_stay_in_place_while_ways_change(self):
+ self.ways()
+ row = self.page.crossing_ledger.rows[self.peer]
+ self.assertEqual(row.edge_glyph.picked, [])
+ self.assertEqual(row.corner_glyph.corner, "")
+ self.ways(["corner"])
+ self.assertEqual(row.corner_glyph.corner, "top_left")
+ self.assertIs(row, self.page.crossing_ledger.rows[self.peer])
+
+ def test_the_canvas_replaces_the_side_and_thirds_choices(self):
+ self.assertTrue(hasattr(self.page, "atlas_canvas"))
+ self.assertFalse(hasattr(self.page, "edge_choice"))
+ self.assertFalse(hasattr(self.page, "parts_choice"))
+
+ def test_display_gesture_hint_is_below_the_canvas(self):
from PySide6.QtWidgets import QApplication
self.page.resize(820, 700)
self.page.show()
self.page._select_page("crossing")
- QApplication.processEvents()
+ for _ in range(8):
+ QApplication.processEvents()
- self.assertEqual(self.page.jump_recorder.key.property("vernier"), "body")
- self.assertLess(self.page.jump_recorder.key.y(), self.page.jump_recorder.hint.y())
+ self.assertEqual(self.page.atlas_canvas_hint.text(), "Alt-click a display to split or group · drag to move · click a third of a lit edge to leave it out")
+ self.assertIs(self.page.atlas_canvas_hint.parentWidget(), self.page.atlas_canvas.parentWidget())
+ self.assertGreaterEqual(self.page.atlas_canvas_hint.y(),
+ self.page.atlas_canvas.y() + self.page.atlas_canvas.height())
- def test_rows_hide_and_come_back_with_the_ways(self):
- self.ways()
- self.assertEqual(self.shown(), {"edge", "shortcut"})
- self.page._ways_changed("shortcut", False)
- self.ways(["part"])
- self.assertEqual(self.shown(), {"edge", "parts", "dragging", "resistance"})
- self.assertTrue(self.page.way_boxes["part"].isChecked())
- self.assertFalse(self.page.way_boxes["shortcut"].isChecked())
-
- def test_the_chips_are_named_for_the_current_edge(self):
- self.ways(["part"], ["start", "end"])
- buttons = self.page.part_buttons
- self.assertEqual([buttons[p].text() for p in ("start", "middle", "end")], ["Top", "Middle", "Bottom"])
- self.assertEqual([buttons[p].isChecked() for p in ("start", "middle", "end")], [True, False, True])
- self.ways(["part"], ["start", "end"], side="top")
- self.assertEqual([buttons[p].text() for p in ("start", "middle", "end")], ["Left", "Middle", "Right"])
-
- def test_an_edge_learned_from_a_peer_renames_the_chips(self):
+ def test_an_edge_learned_from_a_peer_updates_its_canvas_tile(self):
page = self.page
self.ways(["part"])
- page._on_arrangement(self.peer, "bottom", 1790000999, self.peer)
- buttons = page.part_buttons
- self.assertEqual([buttons[p].text() for p in ("start", "middle", "end")], ["Left", "Middle", "Right"])
- self.assertIn("top edge", page.parts_note.text())
+ old_y = page.atlas_canvas.tiles[self.peer]["y"]
+ page._design_peer_caps = lambda: {self.peer: {"settings"}}
+ page._on_arrangement(self.peer, "bottom", int(time.time()), self.peer)
+ self.assertIn(self.peer, page.atlas_canvas.tiles)
+ saved_layout = app_config.load_settings(self.path)["layout"]
+ self.assertNotEqual(page.atlas_canvas.tiles[self.peer]["y"], old_y)
+ self.assertEqual(page.atlas_canvas.tiles[self.peer]["y"], saved_layout[self.peer]["y"])
+
+ def test_older_peer_status_requires_known_capabilities_and_uses_peer_version(self):
+ from PySide6.QtWidgets import QApplication
- def test_unticking_the_last_part_leaves_it_on(self):
+ settings = app_config.load_settings(self.path)
+ settings["peers"][0]["app"] = "Beamer 1.5.2"
+ settings["peers"][0]["platform"] = "windows"
+ app_config.write_settings(self.path, settings)
page = self.page
- self.ways(["part"], ["middle"])
- page.part_buttons["middle"].setChecked(False)
- page._set_part("middle", False)
- parts = [zone for zone in app_config.load_settings(self.path)["zones"] if zone["kind"] == "part"][0]["parts"]
- self.assertEqual(parts, ["middle"])
- self.assertTrue(page.part_buttons["middle"].isChecked())
+ page._live = lambda _peer: False
+ page._pull_peer_fields()
+ page._design_peer_caps = lambda: {}
+ page._reflect_ways()
+ self.assertNotIn("only sees which side", page.crossing_ledger.rows[self.peer].status.text())
+
+ page._design_peer_caps = lambda: {self.peer: frozenset({"settings"})}
+ page._reflect_ways()
+ self.assertEqual(page.crossing_ledger.rows[self.peer].status.text(), "Beamer 1.5.2 · only sees which side")
+ self.assertIn("Windows · Offline", page.atlas_canvas.states[self.peer]["detail"])
+ QApplication.processEvents()
+
+ def test_inactive_peer_keeps_a_ledger_row_without_crossing_zones(self):
+ settings = app_config.load_settings(self.path)
+ settings["peers"][0]["in_use"] = False
+ app_config.write_settings(self.path, settings)
+ self.page._pull_peer_fields()
+ self.assertIn(self.peer, self.page.crossing_ledger.rows)
+ self.assertFalse(ways.has_way(app_config.load_settings(self.path), self.peer))
+ self.assertFalse(hasattr(self.page, "selected_machine_header"))
+
+ def test_left_out_ledger_row_names_the_peer_and_puts_it_back(self):
+ self.page._canvas_left_out(self.peer, True)
+ row = self.page.crossing_ledger.rows[self.peer]
+ self.assertEqual(row.name.full_text, "Mac")
+ self.assertEqual(row.status.text(), "macOS · Left out")
+ self.assertEqual(row.leave.text(), "Put back")
+ row.leave.click()
+ self.assertFalse(app_config.load_settings(self.path)["peers"][0].get("left_out", False))
+
+ def test_tile_selection_and_saved_corner_are_reflected_in_its_ledger_row(self):
+ self.ways(["corner"])
+ self.page._choose_machine(self.peer)
+ row = self.page.crossing_ledger.rows[self.peer]
+ self.assertTrue(row.selected)
+ self.assertEqual(row.corner_glyph.corner, "top_left")
+
+ def test_crossing_refresh_accepts_an_ordinary_edge_without_a_sentence(self):
+ self.ways(["edge"])
+ self.page._reflect_ways()
+ self.assertEqual(self.page.atlas_canvas.states[self.peer]["state"], "edge")
+
+ def test_text_capabilities_allow_the_shared_contact_state(self):
+ from core import protocol
+ from core.tests import responder_harness as harness
+
+ settings = app_config.load_settings(self.path)
+ second = protocol.id_text(harness.C)
+ settings["peers"].append(harness.entry(harness.C, "Linux box", side="right"))
+ settings["layout"] = {
+ self.page._config.machine_id: {"x": 0, "y": 0, "w": 160, "h": 100},
+ self.peer: {"x": 172, "y": 0, "w": 160, "h": 100},
+ second: {"x": 332, "y": 0, "w": 160, "h": 100},
+ }
+ app_config.write_settings(self.path, settings)
+ self.page._pull_peer_fields()
+ self.page._design_peer_caps = lambda: {self.peer: frozenset({"layout"}),
+ second: frozenset({"layout"})}
+ self.page._reflect_ways()
+
+ self.assertEqual(self.page.atlas_canvas.states[self.peer]["state"], "between")
+ self.assertEqual(self.page.atlas_canvas.states[second]["state"], "between")
+
+ def test_corner_can_be_enabled_when_it_is_currently_off(self):
+ self.ways(["edge"])
+ row = self.page.crossing_ledger.rows[self.peer]
+ self.assertEqual(row.corner_glyph.corner, "")
+ row.corner_glyph.buttons["top_left"].click()
+ self.assertEqual(row.corner_glyph.corner, "top_left")
+ self.assertTrue(app_config.load_settings(self.path)["peers"][0]["ways"]["corner"])
+
+ def test_layout_drop_keeps_the_compiled_side_and_its_stamp(self):
+ layout = {self.page._config.machine_id: {"x": 0, "y": 0, "w": 160, "h": 100},
+ self.peer: {"x": 0, "y": -100, "w": 160, "h": 100}}
+ self.page._layout_dropped(layout, self.peer)
+ saved = app_config.load_settings(self.path)
+ entry = next(peer for peer in saved["peers"] if peer["id"] == self.peer)
+ self.assertEqual(entry["side"], "top")
+ self.assertGreater(entry["side_set_at"], 0)
+
+ def test_edge_off_clears_ledger_segments_and_map_crossing_marks(self):
+ self.ways([])
+ self.assertEqual(self.page.atlas_canvas.states[self.peer]["state"], "gap")
+ row = self.page.crossing_ledger.rows[self.peer]
+ self.assertEqual(row.edge_value.text(), "Off")
+ self.assertEqual(row.edge_glyph.picked, [])
+ self.assertFalse(ways.has_way(app_config.load_settings(self.path), self.peer))
+
+ def test_ledger_edge_text_toggles_the_canonical_zone(self):
+ self.ways(["edge"])
+ row = self.page.crossing_ledger.rows[self.peer]
+ self.assertEqual(row.edge_value.text(), "Whole edge")
+ row.edge_text.click()
+ self.assertFalse(ways.has_way(app_config.load_settings(self.path), self.peer))
+ row.edge_text.click()
+ self.assertTrue(ways.has_way(app_config.load_settings(self.path), self.peer))
+
+ def test_ledger_edge_text_turns_parts_off_and_remembers_them(self):
+ self.ways(["part"], parts=["start"])
+ row = self.page.crossing_ledger.rows[self.peer]
+ self.assertEqual(row.edge_glyph.picked, ["start"])
+ row.edge_text.click()
+ self.assertFalse(ways.has_way(app_config.load_settings(self.path), self.peer))
+ self.assertEqual(app_config.load_settings(self.path)["peers"][0]["ways"]["thirds"], ["start"])
+
+ def test_gap_ledger_disables_edge_editing_and_never_moves_the_tile(self):
+ self.ways([])
+ settings = app_config.load_settings(self.path)
+ settings["layout"][self.peer] = dict(x=520, y=240, w=160, h=100)
+ app_config.write_settings(self.path, settings)
+ self.page._pull_peer_fields()
+ row = self.page.crossing_ledger.rows[self.peer]
+ self.assertEqual(row.edge_detail.text(), "place it on the map")
+ self.assertFalse(row.edge_text.isEnabled())
+ row.edge_text.click()
+ current = app_config.load_settings(self.path)
+ self.assertEqual(current["layout"][self.peer], settings["layout"][self.peer])
+ self.assertFalse(ways.has_way(current, self.peer))
+
+ def test_ledger_and_map_light_the_picked_thirds(self):
+ self.ways(["part"], parts=["start"])
+ row = self.page.crossing_ledger.rows[self.peer]
+ self.assertEqual(row.edge_glyph.picked, ["start"])
+ self.assertTrue(row.edge_glyph.buttons["start"].isChecked())
+ self.assertFalse(row.edge_glyph.buttons["end"].isChecked())
+ self.assertEqual(self.page.atlas_canvas.states[self.peer]["thirds"], ["start"])
+
+ def test_overlapping_drop_persists_an_accepted_free_snap(self):
+ from core import protocol
+ from core.tests import responder_harness as harness
+ settings = app_config.load_settings(self.path)
+ second = protocol.id_text(harness.C)
+ settings["peers"].append(harness.entry(harness.C, "Linux box", side="right"))
+ app_config.write_settings(self.path, settings)
+ self.page._pull_peer_fields()
+ layout = {self.page._config.machine_id: dict(x=0, y=0, w=160, h=100),
+ self.peer: dict(x=160, y=0, w=160, h=100), second: dict(x=160, y=0, w=160, h=100)}
+ self.assertTrue(self.page._layout_dropped(layout, second))
+ saved = app_config.load_settings(self.path)["layout"]
+ self.assertFalse(ways._overlaps(saved[self.peer], saved[second]))
+ self.assertEqual(self.page.atlas_canvas.tiles[second], saved[second])
+
+ def test_overlap_without_a_free_snap_restores_the_saved_picture(self):
+ from unittest import mock
+ from core import ways
+
+ own = self.page._config.machine_id
+ saved = app_config.load_settings(self.path)
+ overlap = {"x": 0, "y": 0, "w": 160, "h": 100}
+ layout = {own: dict(overlap), self.peer: dict(overlap)}
+ with mock.patch.object(ways, "snap_position", return_value=dict(overlap)), \
+ mock.patch.object(self.page.atlas_canvas, "animate_tile") as animate:
+ self.assertFalse(self.page._layout_dropped(layout, self.peer))
+ animate.assert_not_called()
+ self.assertEqual(app_config.load_settings(self.path), saved)
+ self.assertIn("cannot connect", self.page.atlas_canvas.accessibleDescription())
+
+ def test_shelved_position_does_not_block_a_drop_and_is_remembered(self):
+ from core import protocol
+ from core.tests import responder_harness as harness
+
+ settings = app_config.load_settings(self.path)
+ shelf = protocol.id_text(harness.C)
+ settings["peers"].append(harness.entry(harness.C, "Shelf", side="right", left_out=True))
+ tile = {"x": 160, "y": 0, "w": 160, "h": 100}
+ settings["layout"] = {self.page._config.machine_id: {"x": 0, "y": 0, "w": 160, "h": 100},
+ self.peer: {"x": -160, "y": 0, "w": 160, "h": 100}, shelf: tile}
+ app_config.write_settings(self.path, settings)
+ self.page._pull_peer_fields()
+ layout = {key: dict(value) for key, value in settings["layout"].items()}
+ layout[self.peer] = tile
+ self.assertTrue(self.page._layout_dropped(layout, self.peer))
+ saved = app_config.load_settings(self.path)
+ self.assertEqual(saved["layout"][shelf], tile)
+ self.assertEqual(saved["layout"][self.peer], tile)
+ self.assertEqual(self.page.atlas_canvas.states[self.peer]["state"], "edge")
+
+ def test_shared_layout_accepts_shelved_overlap_and_named_paired_third_party(self):
+ from core import protocol, settings_sync
+ from core.tests import responder_harness as harness
+
+ settings = app_config.load_settings(self.path)
+ shelf = protocol.id_text(harness.C)
+ foreign = protocol.id_text(bytes(range(110, 126)))
+ next(entry for entry in settings["peers"] if entry["id"] == self.peer)["paired_with"] = [foreign]
+ settings["peers"].append(harness.entry(harness.C, "Shelf", side="right", left_out=True))
+ app_config.write_settings(self.path, settings)
+ self.page._pull_peer_fields()
+ self.page._peer_caps = lambda: {harness.B: {"layout"}}
+ tile = {"x": 160, "y": 0, "w": 160, "h": 100}
+ layout = {self.page._config.machine_id: {"x": 0, "y": 0, "w": 160, "h": 100},
+ self.peer: tile, shelf: tile,
+ foreign: {"x": 320, "y": 0, "w": 160, "h": 100, "name": "Test box"}}
+ layout_stamp = int(time.time()) + 100
+ data = settings_sync.message_data(False, 100, {}, by=self.peer,
+ layout_state={"set_at": layout_stamp, "by": self.peer, "tiles": layout})
+ self.page._on_settings(self.peer, data)
+ saved = app_config.load_settings(self.path)
+ self.assertEqual(set(saved["layout"]), set(layout))
+ for peer, tile in layout.items():
+ expected = {key: tile[key] for key in ("x", "y", "w", "h")}
+ self.assertEqual({key: saved["layout"][peer][key] for key in expected}, expected)
+ self.assertNotIn("vouched_by", saved["layout"][foreign])
+ self.assertGreaterEqual(saved["layout_set_at"], layout_stamp)
+
+ def test_shared_layout_gap_tells_an_older_peer_its_way_back_changed(self):
+ from core import protocol, settings_sync
+ from core.tests import responder_harness as harness
+
+ settings = app_config.load_settings(self.path)
+ source = protocol.id_text(harness.C)
+ settings["peers"][0].update(side_set_at=100, side_by=self.page._config.machine_id)
+ settings["peers"].append(harness.entry(harness.C, "Source", side="left"))
+ app_config.write_settings(self.path, settings)
+ self.ways(["edge"])
+ self.page._peer_caps = lambda: {harness.C: {"layout"}, harness.B: {"settings"}}
+ sent = []
+ self.page._send_to = lambda peer, message: sent.append((peer, message)) or True
+ layout = {self.page._config.machine_id: {"x": 0, "y": 0, "w": 160, "h": 100},
+ self.peer: {"x": 200, "y": 0, "w": 160, "h": 100},
+ source: {"x": -200, "y": 0, "w": 160, "h": 100}}
+ data = settings_sync.message_data(False, 100, {}, by=source,
+ layout_state={"set_at": app_config.load_settings(self.path).get("layout_set_at", 0) + 1,
+ "by": source, "tiles": layout})
+ self.page._on_settings(source, data)
+ arrangements = [message["data"] for peer, message in sent
+ if peer == harness.B and message["type"] == protocol.MSG_ARRANGEMENT]
+ self.assertEqual(len(arrangements), 1)
+ self.assertFalse(arrangements[0]["way_back"])
+
+ def test_shared_picture_keeps_a_named_machine_listed_by_the_source_after_a_drop(self):
+ from core import protocol, settings_sync
+ from core.tests import responder_harness as harness
+
+ foreign = protocol.id_text(harness.C)
+ settings = app_config.load_settings(self.path)
+ next(entry for entry in settings["peers"] if entry["id"] == self.peer)["paired_with"] = [foreign]
+ app_config.write_settings(self.path, settings)
+ self.page._peer_caps = lambda: {harness.B: {"layout"}}
+ layout = {self.page._config.machine_id: {"x": 0, "y": 0, "w": 160, "h": 100},
+ self.peer: {"x": 160, "y": 0, "w": 160, "h": 100},
+ foreign: {"x": 320, "y": 0, "w": 160, "h": 100, "name": "Test box"}}
+ data = settings_sync.message_data(False, 100, {}, by=self.peer,
+ layout_state={"set_at": settings.get("layout_set_at", 0) + 1,
+ "by": self.peer, "tiles": layout})
+ self.page._on_settings(self.peer, data)
+ named_foreign = layout[foreign]
+ self.assertEqual(self.page.atlas_canvas.tiles[foreign], named_foreign)
+ self.assertEqual(self.page.atlas_canvas.labels[foreign], "Test box")
+ dropped = {key: dict(tile) for key, tile in self.page.atlas_canvas.tiles.items()}
+ dropped[self.peer]["x"] = 160
+ self.assertTrue(self.page._layout_dropped(dropped, self.peer))
+ self.assertEqual(app_config.load_settings(self.path)["layout"][foreign], named_foreign)
+
+ def test_crossing_map_drops_the_rc7_ghost_tile_reproduction(self):
+ from core import protocol, settings_sync
+ from core.tests import responder_harness as harness
+
+ settings = app_config.load_settings(self.path)
+ own = settings["machine_id"]
+ pc = self.peer
+ laptop = protocol.id_text(harness.C)
+ phone, box, old_pc = (protocol.id_text(bytes([value]) * 16) for value in (11, 12, 13))
+ next(entry for entry in settings["peers"] if entry["id"] == pc).update(
+ left_out=True, paired_with=[phone, box])
+ settings["peers"].append(harness.entry(harness.C, "Laptop", paired_with=[old_pc]))
+ settings["peers"].append(harness.entry(phone, "Phone", platform="ios", port=0, token="t" * 43))
+ settings["layout"].update({
+ laptop: {"x": 172, "y": 0, "w": 160, "h": 100},
+ phone: {"x": 344, "y": 0, "w": 160, "h": 100, "vouched_by": pc},
+ box: {"x": 516, "y": 0, "w": 160, "h": 100, "vouched_by": pc},
+ old_pc: {"x": 688, "y": 0, "w": 160, "h": 100, "vouched_by": laptop},
+ })
+ app_config.write_settings(self.path, settings)
+ self.page._pull_peer_fields()
+ source_id = protocol.read_id(laptop)
+ self.page._peer_caps = lambda: {source_id: {"settings", "layout"}}
+ self.page._design_peer_caps = lambda: {laptop: {"settings", "layout"}}
+ incoming = dict(settings["layout"])
+ data = settings_sync.message_data(False, 100, {}, by=laptop,
+ layout_state={"set_at": settings.get("layout_set_at", 0) + 1,
+ "by": laptop, "tiles": incoming})
+
+ self.page._on_settings(laptop, data)
+ self.page._reflect_ways()
+
+ self.assertTrue({phone, box, old_pc}.isdisjoint(self.page.atlas_canvas.tiles))
+
+ def test_drop_to_a_gap_tells_the_peer_its_way_back_changed(self):
+ from core import protocol
+
+ settings = app_config.load_settings(self.path)
+ settings["peers"][0].update(side_set_at=100, side_by=self.page._config.machine_id)
+ app_config.write_settings(self.path, settings)
+ self.ways(["edge"])
+ sent = []
+ self.page._send_to = lambda peer, message: sent.append(message) or True
+ layout = {self.page._config.machine_id: {"x": 0, "y": 0, "w": 160, "h": 100},
+ self.peer: {"x": 200, "y": 0, "w": 160, "h": 100}}
+ self.page._layout_dropped(layout, self.peer)
+ arrangements = [message["data"] for message in sent if message["type"] == protocol.MSG_ARRANGEMENT]
+ self.assertEqual(len(arrangements), 1)
+ self.assertFalse(arrangements[0]["way_back"])
+
+ def test_snap_radius_is_twelve_display_pixels(self):
+ self.page.atlas_canvas._scale = 0.5
+ layout = {self.page._config.machine_id: {"x": 0, "y": 0, "w": 160, "h": 100},
+ self.peer: {"x": 180, "y": 17, "w": 160, "h": 100}}
+ self.page._layout_dropped(layout, self.peer)
+ self.assertEqual(app_config.load_settings(self.path)["layout"][self.peer]["x"], 160)
+
+ def test_own_tile_rename_hint_is_visible(self):
+ from PySide6.QtCore import Qt
+ from PySide6.QtTest import QTest
+
+ canvas = self.page.atlas_canvas
+ canvas.resize(720, 260)
+ own = canvas.tile_rect(self.page._config.machine_id).center().toPoint()
+ QTest.mouseDClick(canvas, Qt.MouseButton.LeftButton, pos=own)
+ self.assertIn("Overview", canvas.accessibleDescription())
+
+ def test_rename_does_not_save_a_duplicate_names_display_suffix(self):
+ from core.tests import responder_harness as harness
+
+ settings = app_config.load_settings(self.path)
+ settings["peers"][0]["label"] = "Studio"
+ settings["peers"].append(harness.entry(harness.C, "Other", label="Studio", side="left"))
+ app_config.write_settings(self.path, settings)
+ self.page._pull_peer_fields()
+ self.page.atlas_canvas.begin_rename(self.peer)
+ self.assertEqual(self.page.atlas_canvas.rename_edit.text(), "Studio")
+
+ def test_left_out_ledger_keys_tick_can_leave_the_shortcut_cycle(self):
+ self.page._canvas_left_out(self.peer, True)
+ self.page._set_shortcut_goes_to("ticked")
+ row = self.page.crossing_ledger.rows[self.peer]
+ row.cycle.setChecked(False)
+ self.assertFalse(app_config.load_settings(self.path)["peers"][0]["shortcut_cycle"])
+
+ def test_machine_row_cycle_tick_saves_and_updates_the_tile(self):
+ self.page._set_shortcut_goes_to("ticked")
+ row = next(iter(self.page.machines.rows.values()))
+ self.assertFalse(row.shortcut_cycle.isHidden())
+ row.shortcut_cycle.setChecked(False)
+ self.assertFalse(app_config.load_settings(self.path)["peers"][0]["shortcut_cycle"])
+ self.assertFalse(self.page.atlas_canvas.cycle[self.peer])
+
+ def test_dormant_map_tile_keeps_its_offline_ledger_row(self):
+ self.page._gone = lambda peer: peer == self.peer
+ self.page._reflect_ways()
+ self.assertIn(self.peer, self.page.atlas_canvas.shelf_ids)
+ row = self.page.crossing_ledger.rows[self.peer]
+ self.assertIn("Offline, ways kept", row.status.text())
+ self.assertFalse(hasattr(self.page, "left_out_shelf"))
+
+ def test_layout_drop_refusal_persists_the_animated_free_position(self):
+ from core import protocol, ways
+ from core.tests import responder_harness as harness
+
+ settings = app_config.load_settings(self.path)
+ second = protocol.id_text(harness.C)
+ settings["peers"].append(harness.entry(harness.C, "Linux box", side="right"))
+ app_config.write_settings(self.path, settings)
+ self.page._pull_peer_fields()
+ layout = {self.page._config.machine_id: {"x": 0, "y": 0, "w": 160, "h": 100},
+ self.peer: {"x": 172, "y": 0, "w": 160, "h": 100},
+ second: {"x": 172, "y": 0, "w": 160, "h": 100}}
+ self.page._layout_dropped(layout, second)
+ saved = app_config.load_settings(self.path)["layout"]
+ self.assertFalse(ways._overlaps(saved[self.peer], saved[second]))
def test_the_crossing_line_gives_the_first_reason_nothing_can_cross(self):
line = pages_win.crossing_state_sentence
diff --git a/win_app/tests/test_pair_code_caret.py b/win_app/tests/test_pair_code_caret.py
new file mode 100644
index 0000000..22c2a65
--- /dev/null
+++ b/win_app/tests/test_pair_code_caret.py
@@ -0,0 +1,198 @@
+import math
+import os
+import subprocess
+import sys
+import unittest
+from pathlib import Path
+
+os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+sys.path.insert(0, str(Path(__file__).resolve().parents[2]))
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from PySide6.QtCore import Qt
+from PySide6.QtGui import QColor, QFontMetricsF, QImage
+from PySide6.QtWidgets import QApplication
+
+import machines_win
+import theme
+
+
+class PairCodeCaretTests(unittest.TestCase):
+ @classmethod
+ def setUpClass(cls):
+ cls.app = QApplication.instance() or QApplication([])
+ previous_font = cls.app.font()
+ previous_stylesheet = cls.app.styleSheet()
+ previous_dark = theme.is_dark()
+ cls.addClassCleanup(theme.set_dark, previous_dark)
+ cls.addClassCleanup(cls.app.setStyleSheet, previous_stylesheet)
+ cls.addClassCleanup(cls.app.setFont, previous_font)
+ theme.set_dark(True)
+ theme.init_fonts()
+ cls.app.setFont(theme.font(theme.TYPE["body"]))
+ cls.app.setStyleSheet(theme.stylesheet())
+
+ def setUp(self):
+ self.sheet = machines_win.PairingSheet(lambda: None, lambda: None, lambda *_: None, lambda *_: None)
+ self.sheet.resize(432, 900)
+ self.sheet.show()
+ self.app.processEvents()
+ self.sheet.code.setFocus()
+ self.app.processEvents()
+ self.addCleanup(self.sheet.deleteLater)
+
+ def _signal_columns(self, image, rect):
+ signal = QColor(theme.colour("signal"))
+ scale = image.devicePixelRatio()
+ top = math.ceil((rect.top() + 1) * scale)
+ bottom = math.floor((rect.bottom() - 1) * scale)
+ columns = []
+ for x in range(image.width()):
+ run = 0
+ longest = 0
+ for y in range(top, min(bottom + 1, image.height())):
+ colour = image.pixelColor(x, y)
+ if colour == signal:
+ run += 1
+ longest = max(longest, run)
+ else:
+ run = 0
+ if longest >= max(3, math.floor((bottom - top + 1) * 0.6)):
+ columns.append(x)
+ return columns
+
+ def _digit_ink_columns(self, image, rect):
+ scale = image.devicePixelRatio()
+ columns = []
+ for x in range(max(0, math.ceil(rect.left() * scale)),
+ min(image.width(), math.ceil(rect.right() * scale))):
+ for y in range(max(0, math.ceil(rect.top() * scale)),
+ min(image.height(), math.ceil(rect.bottom() * scale))):
+ colour = image.pixelColor(x, y)
+ if colour.red() > 175 and colour.green() > 175 and colour.blue() > 165:
+ columns.append(x)
+ return columns
+
+ def test_qt_caret_rectangle_and_painted_caret_share_the_visible_cell(self):
+ code = self.sheet.code
+ original_font = code.font()
+ try:
+ child_scale = os.environ.get("PAIR_CODE_CARET_SCALE_CHILD") == "1"
+ scale = 1.5 if child_scale else 1.0
+ self.assertAlmostEqual(code.grab().devicePixelRatio(), scale)
+ for scale in (scale,):
+ code.setFont(theme.mono_font(20))
+ self.app.processEvents()
+ for length in range(7):
+ text = "123456"[:length]
+ for position in range(length + 1):
+ with self.subTest(scale=scale, text=text, position=position):
+ code.setText(text)
+ code.setCursorPosition(position)
+ self.app.processEvents()
+
+ actual = code.inputMethodQuery(Qt.InputMethodQuery.ImCursorRectangle)
+ self.assertTrue(hasattr(actual, "x"), actual)
+ cells = code._cell_rectangles()
+ metrics = QFontMetricsF(code.font())
+ if position < 6:
+ caret_cell = cells[position]
+ glyph = text[position] if position < length else "0"
+ expected_x = caret_cell.center().x() - metrics.horizontalAdvance(glyph) / 2
+ else:
+ caret_cell = cells[5]
+ expected_x = caret_cell.center().x() + metrics.horizontalAdvance(text[-1]) / 2
+ expected_y = caret_cell.top() + 8
+ expected_height = max(0, caret_cell.height() - 16)
+ self.assertLessEqual(abs(actual.x() - expected_x), 1, (actual, expected_x))
+ self.assertLessEqual(abs(actual.y() - expected_y), 1, (actual, expected_y))
+
+ painted = code.caret_rect(position)
+ self.assertLessEqual(abs(actual.x() - painted.x()), 1, (actual, painted))
+ self.assertLessEqual(abs(actual.y() - painted.y()), 1, (actual, painted))
+ self.assertGreaterEqual(actual.height(), painted.height() - 1)
+
+ self.assertLessEqual(abs(painted.x() - expected_x), 1, (painted, expected_x))
+ self.assertAlmostEqual(painted.height(), expected_height, delta=1)
+ self.assertGreaterEqual(actual.x(), caret_cell.left(), (actual, caret_cell))
+ self.assertLessEqual(actual.x(), caret_cell.right(), (actual, caret_cell))
+ # The caret is in the cell with the signal border, where the next digit goes.
+ self.assertIs(caret_cell, cells[min(5, position)])
+
+ if length == 6:
+ self.assertTrue(0 <= actual.x() <= cells[5].right() + machines_win.CODE_CELL_GAP,
+ (actual, cells[5]))
+ if position == 6:
+ sixth = cells[5]
+ self.assertGreaterEqual(actual.x(), sixth.left() - machines_win.CODE_CELL_GAP)
+ self.assertLessEqual(actual.x(), sixth.right() + machines_win.CODE_CELL_GAP)
+ self.assertGreater(actual.x(), code.width() / 2)
+
+ image = code.grab().toImage().convertToFormat(QImage.Format.Format_ARGB32)
+ dpr = image.devicePixelRatio()
+ if position == length == 6:
+ last_ink_cell = code.digit_cells()[length - 1]
+ ink_x = self._digit_ink_columns(image, last_ink_cell)
+ self.assertTrue(ink_x, (text, last_ink_cell))
+ trailing_distance = actual.x() - max(ink_x) / dpr
+ self.assertGreaterEqual(trailing_distance, -1, (actual, max(ink_x) / dpr))
+ self.assertLessEqual(trailing_distance,
+ cells[length - 1].width() / 2 + machines_win.CODE_CELL_GAP,
+ (actual, max(ink_x) / dpr))
+ expected_x = round(painted.x() * dpr)
+ signal_columns = self._signal_columns(image, painted)
+ focus_cell = cells[min(5, position)]
+ border_columns = (focus_cell.left() * dpr, focus_cell.right() * dpr)
+ border_tolerance = max(1.0, dpr)
+ signal_columns = [x for x in signal_columns
+ if all(abs(x - border) > border_tolerance for border in border_columns)]
+ matching = [x for x in signal_columns if abs(x / dpr - painted.x()) <= 1]
+ self.assertGreaterEqual(len(matching), 1, (painted, signal_columns, border_columns))
+ self.assertEqual(signal_columns, matching,
+ f"stray signal-coloured caret ink at {signal_columns}, expected {painted}")
+
+ native_cursor = code.cursorRect()
+ native_x = min(image.width() - 1, max(0, round(native_cursor.x() * dpr)))
+ code.clearFocus()
+ self.app.processEvents()
+ unfocused = code.grab().toImage().convertToFormat(QImage.Format.Format_ARGB32)
+ native_changes = [
+ (native_x, y) for y in range(max(0, round(painted.top() * dpr)),
+ min(image.height(), round(painted.bottom() * dpr) + 1))
+ if image.pixelColor(native_x, y) != unfocused.pixelColor(native_x, y)
+ ]
+ self.assertEqual(native_changes, [],
+ f"focus paints ink at Qt's native caret x {native_cursor.x()}")
+ code.setFocus()
+ self.app.processEvents()
+
+ anchor_position = position
+ if code.hasSelectedText():
+ start = code.selectionStart()
+ end = start + len(code.selectedText())
+ anchor_position = end if position == start else start
+ anchor = code.inputMethodQuery(Qt.InputMethodQuery.ImAnchorRectangle)
+ self.assertLessEqual(abs(anchor.x() - code.caret_rect(anchor_position).x()), 1,
+ (anchor, anchor_position))
+
+ code.setText("123456")
+ code.setSelection(1, 3)
+ anchor = code.inputMethodQuery(Qt.InputMethodQuery.ImAnchorRectangle)
+ self.assertLessEqual(abs(anchor.x() - code.caret_rect(1).x()), 1, anchor)
+
+ if not child_scale:
+ environment = os.environ.copy()
+ environment["QT_SCALE_FACTOR"] = "1.5"
+ environment["PAIR_CODE_CARET_SCALE_CHILD"] = "1"
+ result = subprocess.run(
+ [sys.executable, "-m", "unittest", "win_app.tests.test_pair_code_caret"],
+ cwd=Path(__file__).resolve().parents[2], env=environment,
+ text=True, capture_output=True, check=False,
+ )
+ self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
+ finally:
+ code.setFont(original_font)
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/win_app/tests/test_pair_code_rendering.py b/win_app/tests/test_pair_code_rendering.py
index b7649b2..6d961ee 100644
--- a/win_app/tests/test_pair_code_rendering.py
+++ b/win_app/tests/test_pair_code_rendering.py
@@ -22,8 +22,12 @@ class PairCodeRenderingTests(unittest.TestCase):
cls.app = QApplication.instance() or QApplication([])
previous_font = cls.app.font()
previous_stylesheet = cls.app.styleSheet()
+ previous_dark = theme.is_dark()
+ cls.addClassCleanup(theme.set_dark, previous_dark)
cls.addClassCleanup(cls.app.setStyleSheet, previous_stylesheet)
cls.addClassCleanup(cls.app.setFont, previous_font)
+ # The pixel threshold measures pale digit ink, so a prior window's light palette cannot leak in.
+ theme.set_dark(True)
theme.init_fonts()
cls.app.setFont(theme.font(theme.TYPE["body"]))
cls.app.setStyleSheet(theme.stylesheet())
@@ -165,7 +169,7 @@ class PairCodeRenderingTests(unittest.TestCase):
measurements)
def test_pair_action_precedes_the_machines_list(self):
- module = machines_win.MachinesModule(*([lambda *_: None] * 5))
+ module = machines_win.MachinesModule(*([lambda *_: None] * 6))
module.resize(560, 300)
module.show()
self.app.processEvents()
@@ -176,7 +180,7 @@ class PairCodeRenderingTests(unittest.TestCase):
entry = {"token": "test-machine", "name": "Studio", "platform": "macos", "port": 24820,
"host": "192.0.2.10", "send": True, "allow_drive": False, "in_use": True}
state = machines_win.peers_view.PeerState("amber", "Waiting", "Looking for Studio.")
- module.set_peers([(entry, "Studio", state, "Mac · 192.0.2.10 · port 24820")])
+ module.set_peers([(entry, "Studio", state, "Mac · 192.0.2.10 · port 24820")], cycle_mode="last")
self.app.processEvents()
row = module.rows["test-machine"]
button_y = module.pair_button.mapTo(module, module.pair_button.rect().topLeft()).y()
diff --git a/win_app/tests/test_pairing_window.py b/win_app/tests/test_pairing_window.py
index 9108c29..30a315b 100644
--- a/win_app/tests/test_pairing_window.py
+++ b/win_app/tests/test_pairing_window.py
@@ -12,11 +12,12 @@ from types import SimpleNamespace
sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
-from core import pairing, peerlist, protocol
+from core import pairing, peerlist, protocol, ways
from core.tests import responder_harness as harness
try:
from PySide6.QtCore import Qt
+ from PySide6.QtTest import QTest
from PySide6.QtWidgets import QApplication
import app_config
@@ -87,6 +88,39 @@ class MachinesWindowTest(unittest.TestCase):
self.assertEqual(row.word.text(), "Waiting")
self.assertIn("Studio Mac", row.detail.text())
+ def test_renaming_a_machine_saves_on_return_and_escape_cancels(self):
+ window = self.open(peer(ID_A, "Studio Mac", TOKEN_A, "192.0.2.10"))
+ row = next(iter(window.machines.rows.values()))
+ row.rename_button.click()
+ self.assertFalse(row.rename_edit.isHidden())
+ self.assertEqual(row.rename_note.text(), "Only on this computer" if sys.platform.startswith("linux") else "Only on this PC")
+ row.rename_edit.setText(" Work Mac ")
+ QTest.keyClick(row.rename_edit, Qt.Key.Key_Return)
+ self.assertEqual(window.machines.rows[TOKEN_A].name.text(), "Work Mac")
+ self.assertEqual(self.settings()["peers"][0]["label"], "Work Mac")
+
+ row = window.machines.rows[TOKEN_A]
+ row.rename_button.click()
+ row.rename_edit.setText("Discard this")
+ QTest.keyClick(row.rename_edit, Qt.Key.Key_Escape)
+ self.assertEqual(self.settings()["peers"][0]["label"], "Work Mac")
+ self.assertTrue(row.rename_edit.isHidden())
+ self.assertFalse(row.name.isHidden())
+
+ def test_a_left_out_row_can_be_put_back_and_names_the_shortcut(self):
+ entry = peer(ID_A, "Studio Mac", TOKEN_A, "192.0.2.10")
+ entry.update(left_out=True, left_out_ways=["edge"])
+ window = self.open(entry)
+ row = next(iter(window.machines.rows.values()))
+
+ self.assertEqual(row.left_out.text(), "Put back")
+ self.assertEqual(row.left_out_note.text(), "Left out of the layout. The shortcut and the menu still reach it.")
+ row.left_out.click()
+
+ self.assertNotIn("left_out", self.settings()["peers"][0])
+ self.assertNotIn("left_out_ways", self.settings()["peers"][0])
+ self.assertEqual(row.left_out.text(), "Leave out")
+
def test_the_direction_switches_start_under_a_closed_disclosure(self):
window = self.open(peer(ID_A, "Studio Mac", TOKEN_A, "192.0.2.10"))
row = next(iter(window.machines.rows.values()))
@@ -132,7 +166,7 @@ class MachinesWindowTest(unittest.TestCase):
self.assertFalse(self.window.machines.empty.isHidden())
self.assertEqual(self.window.machines.empty.text(), "No machines paired yet.")
self.assertFalse(self.window._paired)
- self.assertFalse(self.window.same_switch.isEnabled())
+ self.assertFalse(self.window.same_checks["everything"].isEnabled())
def test_with_nothing_paired_appearance_and_speed_still_save(self):
self.window = kvm_bridge_win.WindowsApplication(self.path)
@@ -183,12 +217,13 @@ class MachinesWindowTest(unittest.TestCase):
def test_removing_a_machine_takes_its_entry_and_zones_and_keeps_the_rest(self):
window = self.open(peer(ID_A, "Studio", TOKEN_A, "192.0.2.10"), peer(ID_B, "Laptop", TOKEN_B, "192.0.2.11"))
settings = self.settings()
- settings["zones"] = [{"peer": protocol.id_text(ID_A), "kind": "edge"}, {"peer": protocol.id_text(ID_B), "kind": "edge", "off": True}]
+ settings["peers"][1]["ways"]["edge"] = False
app_config.write_settings(self.path, settings)
window._remove_peer(TOKEN_A)
after = self.settings()
self.assertEqual([entry["name"] for entry in after["peers"]], ["Laptop"])
- self.assertEqual([zone["peer"] for zone in after["zones"]], [protocol.id_text(ID_B)])
+ self.assertFalse(after["peers"][0]["ways"]["edge"])
+ self.assertEqual(after["zones"], [])
self.assertEqual(list(window.machines.rows), [TOKEN_B])
self.assertEqual(window._config.auth_token, TOKEN_B)
@@ -197,7 +232,7 @@ class MachinesWindowTest(unittest.TestCase):
window._remove_peer(TOKEN_A)
self.assertEqual(self.settings()["peers"], [])
self.assertFalse(window._paired)
- self.assertFalse(window.same_switch.isEnabled())
+ self.assertFalse(window.same_checks["everything"].isEnabled())
self.assertFalse(window.machines.empty.isHidden())
window._refresh_window()
@@ -234,7 +269,8 @@ class MachinesWindowTest(unittest.TestCase):
def input_on(self, window, peer):
homes = []
- window.sender._owner = SimpleNamespace(on=peer, away=peer is not None)
+ window.sender._owner = SimpleNamespace(on=peer, away=peer is not None,
+ reach_for=lambda target: [])
window.sender.set_redirecting = lambda value, came_home=True: homes.append(value)
return homes
@@ -334,6 +370,24 @@ class MachinesWindowTest(unittest.TestCase):
self.assertEqual([entry["token"] for entry in self.settings()["peers"]], [TOKEN_A, TOKEN_B])
self.assertTrue(self.settings()["peers"][0]["linked"])
+ def test_re_pairing_same_identity_keeps_intent_cycle_and_jump(self):
+ window = self.open(peer(ID_A, "Studio", TOKEN_A, "192.0.2.10"))
+ settings = self.settings()
+ intent = {"edge": False, "thirds": ["start", "end"], "corner": True,
+ "corner_at": "top_right", "notch": False}
+ settings["peers"][0].update(ways=intent, shortcut_cycle=False, jump_key="ctrl+shift+2")
+ app_config.write_settings(self.path, settings)
+ replaced = window.book.peers()[0]
+ fresh = peer(ID_A, "Studio", TOKEN_B, "192.0.2.12")
+
+ window._store_peer(fresh, replaced)
+
+ saved = self.settings()["peers"][0]
+ self.assertEqual(saved["token"], TOKEN_B)
+ self.assertEqual(saved["ways"], intent)
+ self.assertFalse(saved["shortcut_cycle"])
+ self.assertEqual(saved["jump_key"], "ctrl+shift+2")
+
def test_a_pairing_does_not_replace_a_machine_that_was_removed_since_it_was_read(self):
window = self.open(peer(ID_A, "Studio", TOKEN_A, "192.0.2.10"), peer(ID_B, "Laptop", TOKEN_B, "192.0.2.11"))
replaced = window.book.peers()[0]
@@ -343,30 +397,47 @@ class MachinesWindowTest(unittest.TestCase):
window._store_peer(fresh, replaced)
self.assertEqual([entry["token"] for entry in self.settings()["peers"]], [TOKEN_B])
- def test_pairing_the_mac_at_the_1_4_entrys_address_again_keeps_its_side_and_zones(self):
+ def test_pairing_the_mac_at_the_1_4_entrys_address_again_keeps_its_side_and_intent(self):
# Every 1.4.x upgrader pairs again (no token migrates since 1.5.0), on purpose and at the
# screen: where that Mac sits is not theirs to set a second time.
migrated = {**peer(ID_A, "Studio Mac", TOKEN_A, "192.0.2.10"), "id": "", "from_1_4": True, "linked": False,
- "paired_at": 0, "side": "top", "side_set_at": 1_790_000_000}
+ "paired_at": 0, "side": "top", "side_set_at": 1_790_000_000,
+ "shortcut_cycle": False, "jump_key": "ctrl+shift+2"}
window = self.open(migrated, zones=[{"peer": "", "kind": "edge"}, {"peer": "", "kind": "corner",
"corner": "top_left", "edge": "top", "off": True}])
fresh = peer(b"\x0c" * 16, "Studio Mac", protocol.id_text(bytes(range(2, 34))), "192.0.2.10")
window._store_peer(fresh, window.book.peers()[0])
after = self.settings()
new_id = protocol.id_text(b"\x0c" * 16)
- self.assertEqual([zone["peer"] for zone in after["zones"]], [new_id, new_id])
+ from display_map_fixture import display_fields
+ self.assertEqual(after["zones"], [{"peer": new_id, "kind": "edge", "side": "top",
+ **display_fields(window)}])
+ self.assertEqual(after["peers"][0]["ways"],
+ {"edge": True, "thirds": list(ways.PARTS), "corner": False,
+ "corner_at": "top_left", "notch": False})
self.assertEqual((after["peers"][0]["side"], after["peers"][0]["side_set_at"]), ("top", 1_790_000_000))
+ self.assertFalse(after["peers"][0]["shortcut_cycle"])
+ self.assertEqual(after["peers"][0]["jump_key"], "ctrl+shift+2")
def test_pairing_another_platform_at_that_address_keeps_nothing_of_it(self):
migrated = {**peer(ID_A, "Studio Mac", TOKEN_A, "192.0.2.10"), "id": "", "from_1_4": True, "linked": False,
- "paired_at": 0, "side": "top", "side_set_at": 1_790_000_000}
+ "paired_at": 0, "side": "top", "side_set_at": 1_790_000_000,
+ "shortcut_cycle": False, "jump_key": "ctrl+shift+2"}
window = self.open(migrated, zones=[{"peer": "", "kind": "edge"}])
fresh = peer(b"\x0c" * 16, "Studio PC", protocol.id_text(bytes(range(2, 34))), "192.0.2.10", platform="windows")
window._store_peer(fresh, window.book.peers()[0])
after = self.settings()
- # Only its own whole edge, which every machine paired starts with.
- self.assertEqual(after["zones"], [{"peer": protocol.id_text(b"\x0c" * 16), "kind": "edge"}])
- self.assertEqual(after["peers"][0]["side"], "")
+ new_id = protocol.id_text(b"\x0c" * 16)
+ side = ways._rect_contact(after["layout"][after["machine_id"]], after["layout"][new_id])[0]
+ from display_map_fixture import display_fields
+ self.assertEqual(after["zones"], [{"peer": new_id, "kind": "edge", "side": side,
+ **display_fields(window)}])
+ self.assertEqual(after["peers"][0]["side"], side)
+ self.assertNotEqual(side, "top")
+ self.assertTrue(after["peers"][0]["ways"]["edge"])
+ self.assertFalse(after["peers"][0]["ways"]["corner"])
+ self.assertTrue(after["peers"][0].get("shortcut_cycle", True))
+ self.assertFalse(after["peers"][0].get("jump_key"))
@unittest.skipIf(kvm_bridge_win is None, "needs PySide6")
diff --git a/win_app/tests/test_parity.py b/win_app/tests/test_parity.py
index a956fbf..e9c4bf1 100644
--- a/win_app/tests/test_parity.py
+++ b/win_app/tests/test_parity.py
@@ -57,6 +57,7 @@ class TriggerKeyTests(unittest.TestCase):
self.assertEqual(capture_win.VK_TO_NAME[vk], name)
trigger = capture_win.Trigger("f13", "double_tap", 300)
self.assertIsNone(trigger.feed("f13", True, 0.0))
+ self.assertIsNone(trigger.feed("f13", False, 0.05))
self.assertEqual(trigger.feed("f13", True, 0.1), capture_win.TOGGLE)
@@ -167,6 +168,8 @@ class HeldEdgeTests(unittest.TestCase):
link.handshake()
route = link.take()
self.assertEqual(link.answer(route)[0], protocol.MSG_ACCEPT)
+ inward = link.move(201, 0)
+ self.assertIsNotNone(link.acked(inward))
seq = link.move(-200, 0)
self.assertIsNotNone(link.acked(seq))
crossed = link.expect(protocol.MSG_SWITCH, timeout=0.2)
diff --git a/win_app/tests/test_part_edge_corners_qt.py b/win_app/tests/test_part_edge_corners_qt.py
new file mode 100644
index 0000000..0322879
--- /dev/null
+++ b/win_app/tests/test_part_edge_corners_qt.py
@@ -0,0 +1,192 @@
+"""Map thirds, scoped contact geometry and ledger parity with synthetic settings."""
+
+import copy
+import unittest
+from unittest.mock import patch
+
+from PySide6.QtCore import QPointF, Qt
+from PySide6.QtGui import QColor
+from PySide6.QtTest import QTest
+
+import app_config
+import diagram
+import theme
+from core import ways
+import test_crossing_page_parity as parity
+from test_crossing_ledger import band_point, paint, picked
+
+
+def picked_row(window):
+ return picked(window, window._chosen_machine())
+
+
+class PartEdgeCornersTests(unittest.TestCase):
+ setUp = parity.CrossingPageParityTests.setUp
+ tearDown = parity.CrossingPageParityTests.tearDown
+ _open_window = parity.CrossingPageParityTests._open_window
+ _close_window = parity.CrossingPageParityTests._close_window
+ _stop_patches = parity.CrossingPageParityTests._stop_patches
+
+ def test_map_click_toggles_the_row_without_a_drag(self):
+ window, peer = self.window, self.peers[0]["id"]
+ window._ledger_edge(peer)
+ for third in ways.PARTS:
+ canvas = window.atlas_canvas
+ before = copy.deepcopy(canvas.tiles)
+ saved_layout = app_config.load_settings(self.path)["layout"]
+ point = band_point(canvas, third)
+ QTest.mousePress(canvas, Qt.MouseButton.LeftButton, pos=point)
+ QTest.mouseMove(canvas, point + type(point)(30, 20))
+ self.assertEqual(canvas.tiles, before)
+ QTest.mouseRelease(canvas, Qt.MouseButton.LeftButton, pos=point)
+ self.assertEqual(picked_row(window), [part for part in ways.PARTS if part != third])
+ self.assertEqual(app_config.load_settings(self.path)["layout"], saved_layout)
+ QTest.mouseClick(canvas, Qt.MouseButton.LeftButton, pos=band_point(canvas, third))
+ self.assertEqual(picked_row(window), list(ways.PARTS))
+
+ def test_a_picked_third_with_only_a_sliver_of_contact_is_not_lit(self):
+ window, peer = self.window, self.peers[0]["id"]
+ window._ledger_edge(peer)
+ window._ledger_third(peer, "start")
+ layout = copy.deepcopy(window.atlas_canvas.tiles)
+ own = window._config.machine_id
+ layout[own].update(x=0, y=0, w=300, h=300)
+ layout[peer].update(x=300, y=100, w=300, h=110)
+ layout[self.peers[1]["id"]].update(x=-300, y=0)
+ window._layout_dropped(layout, peer)
+ state = window.atlas_canvas.states[peer]
+ self.assertEqual(state["thirds"], ["middle", "end"])
+ self.assertEqual(state["lit"], ["middle"])
+ canvas = window.atlas_canvas
+ image = paint(canvas)
+ rect, scale = canvas.tile_rect(own), canvas._scale
+ from PySide6.QtCore import QPoint
+ sliver = QPoint(round(rect.right()), round(rect.top() + 205 * scale))
+ self.assertNotEqual(image.pixel(sliver), diagram._colour("signal").rgb())
+
+ def test_unpicked_keeps_the_pick_without_an_inspector_note(self):
+ window, peer = self.window, self.peers[0]["id"]
+ window._ledger_edge(peer)
+ window._ledger_third(peer, "middle")
+ window._ledger_third(peer, "end")
+ layout = copy.deepcopy(window.atlas_canvas.tiles)
+ own = window._config.machine_id
+ layout[own].update(x=0, y=0, w=160, h=120)
+ layout[peer].update(x=160, y=80, w=160, h=40)
+ window._layout_dropped(layout, peer)
+ self.assertEqual(window.atlas_canvas.states[peer]["thirds"], ["start"])
+ self.assertEqual(picked_row(window), ["start"])
+ self.assertFalse(hasattr(window, "atlas_note"))
+ QTest.mouseClick(window.atlas_canvas, Qt.MouseButton.LeftButton, pos=band_point(window.atlas_canvas, "end"))
+ self.assertEqual(picked_row(window), ["start", "end"])
+ self.assertTrue(window.atlas_canvas.states[peer]["crosses"])
+
+ def test_a_corner_only_machine_has_its_pad_and_no_seam(self):
+ window, peer = self.window, self.peers[0]["id"]
+ window._ledger_corner(peer, "top_right")
+ canvas = window.atlas_canvas
+ image = paint(canvas)
+ self.assertTrue(canvas.states[peer]["crosses"])
+ self.assertEqual(canvas.corner_marks, [(peer, "top_right", 1.0)])
+ own = canvas.tile_rect(canvas._own_id())
+ self.assertFalse(any(side == "right" for side, *_ in canvas.seam_paths))
+ self.assertNotEqual(image.pixel(band_point(canvas, "middle")), diagram._colour("signal").rgb())
+ self.assertEqual(image.pixel(round(own.right() + 5), round(own.top())), diagram._colour("signal").rgb())
+
+ def test_edge_off_survives_drop_and_text_restores_whole_edge(self):
+ window, peer = self.window, self.peers[0]["id"]
+ window._ledger_edge(peer)
+ window._ledger_third(peer, "middle")
+ window._ledger_edge(peer)
+ window._layout_dropped(copy.deepcopy(window.atlas_canvas.tiles), peer)
+ self.assertFalse(ways.has_way(app_config.load_settings(self.path), peer))
+ self.assertEqual(picked_row(window), [])
+ self.assertTrue(window.atlas_canvas.states[peer]["edge_off"])
+ window.crossing_ledger.rows[peer].edge_text.click()
+ self.assertEqual(picked_row(window), list(ways.PARTS))
+ self.assertTrue(window.atlas_canvas.states[peer]["crosses"])
+
+ def test_each_side_orients_and_toggles_its_three_bands(self):
+ window, peer = self.window, self.peers[0]["id"]
+ window._ledger_edge(peer)
+ for side in ways.EDGES:
+ layout = copy.deepcopy(window.atlas_canvas.tiles)
+ own = window._config.machine_id
+ layout[own].update(x=0, y=0, w=160, h=120)
+ x, y = {"left": (-160, 0), "right": (160, 0), "top": (0, -120), "bottom": (0, 120)}[side]
+ layout[peer].update(x=x, y=y, w=160, h=120)
+ layout[self.peers[1]["id"]].update(x=500, y=300)
+ window._layout_dropped(layout, peer)
+ parity.settle(window)
+ row = window.crossing_ledger.rows[peer]
+ self.assertEqual(row.edge_glyph.side, side)
+ for third in ways.PARTS:
+ QTest.mouseClick(window.atlas_canvas, Qt.MouseButton.LeftButton, pos=band_point(window.atlas_canvas, third, side))
+ self.assertNotIn(third, picked_row(window))
+ QTest.mouseClick(window.atlas_canvas, Qt.MouseButton.LeftButton, pos=band_point(window.atlas_canvas, third, side))
+ self.assertEqual(picked_row(window), list(ways.PARTS))
+
+ def test_band_is_five_pixels_wide_and_available_when_edge_is_off(self):
+ window, peer = self.window, self.peers[0]["id"]
+ canvas = window.atlas_canvas
+ rect = canvas.tile_rect(window._config.machine_id)
+ self.assertEqual(canvas._third_at(QPointF(rect.right() - 5, rect.center().y())), (peer, "middle"))
+ self.assertEqual(canvas._third_at(QPointF(rect.right() + 5, rect.center().y())), (peer, "middle"))
+ self.assertIsNone(canvas._third_at(QPointF(rect.right() + 5.01, rect.center().y())))
+ self.assertEqual(canvas._third_at(band_point(canvas, "middle")), (peer, "middle"))
+ window._choose_machine(self.peers[1]["id"])
+ self.assertIsNone(canvas._third_at(band_point(canvas, "middle")))
+
+ def test_selected_seam_and_tracks_break_at_the_thirds(self):
+ window, peer = self.window, self.peers[0]["id"]
+ window._ledger_edge(peer)
+ window._ledger_third(peer, "middle")
+ canvas, lines = window.atlas_canvas, []
+ original = diagram.QPainter
+ class RecordingPainter(original):
+ def drawLine(self, *args):
+ if len(args) == 2:
+ lines.append((QPointF(args[0]), QPointF(args[1]), self.pen().widthF(), self.pen().color()))
+ return super().drawLine(*args)
+ with patch.object(diagram, "QPainter", RecordingPainter):
+ paint(canvas)
+ rect = canvas.tile_rect(window._config.machine_id)
+ x, third_height = rect.right(), rect.height() / 3
+ seams = [(a, b, width, colour) for a, b, width, colour in lines
+ if abs(a.x() - x) < .01 and abs(b.x() - x) < .01]
+ signal = QColor(theme.colour("signal"))
+ lit = [(a.y(), b.y()) for a, b, width, colour in seams if width == 4 and colour == signal]
+ # At a third boundary the 4pt seam stops half the break gap plus its round cap short.
+ inner = diagram.THIRD_GAP / 2 + 2
+ expected = [(rect.top() + 2, rect.top() + third_height - inner),
+ (rect.top() + 2 * third_height + inner, rect.bottom() - 2)]
+ self.assertEqual(len(lit), len(expected))
+ for actual, wanted in zip(lit, expected):
+ self.assertAlmostEqual(actual[0], wanted[0])
+ self.assertAlmostEqual(actual[1], wanted[1])
+ tracks = [(a.y(), b.y()) for a, b, width, colour in seams if width == 2]
+ self.assertEqual(len(tracks), 1)
+ self.assertAlmostEqual(tracks[0][0], rect.top() + third_height + 2)
+ self.assertAlmostEqual(tracks[0][1], rect.top() + 2 * third_height - 2)
+
+ def test_inactive_peers_have_no_corner_mark(self):
+ peer = self.peers[0]["id"]
+ self.window._ledger_corner(peer, "top_right")
+ self.window._canvas_left_out(peer, True)
+ paint(self.window.atlas_canvas)
+ self.assertFalse(self.window.atlas_canvas.corner_marks)
+ self.assertEqual(self.window.crossing_ledger.rows[peer].corner_value.text(), "Top right")
+
+ def test_edge_detail_waits_for_contact_but_corner_stays_live(self):
+ window, peer = self.window, self.peers[0]["id"]
+ layout = copy.deepcopy(window.atlas_canvas.tiles)
+ layout[peer].update(x=600, y=300)
+ window._layout_dropped(layout, peer)
+ row = window.crossing_ledger.rows[peer]
+ self.assertEqual(row.edge_detail.text(), "place it on the map")
+ self.assertFalse(row.edge_text.isEnabled())
+ self.assertTrue(row.corner_glyph.buttons["top_right"].isEnabled())
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/win_app/tests/test_pc_three_machines.py b/win_app/tests/test_pc_three_machines.py
index a6d1d55..2613dce 100644
--- a/win_app/tests/test_pc_three_machines.py
+++ b/win_app/tests/test_pc_three_machines.py
@@ -1,6 +1,5 @@
-"""Three machines on the Windows app (1.5.0 milestone 5): the shortcut's machine, a tray item per
-machine, each machine's ways written on its own, the Crossing page's choice of machine, the diagram
-of this PC and its neighbours, and Pause counting every machine's zones (WIRE.md sections 5 and 8)."""
+"""Three machines on the Qt app: shortcut targets, tray items, Atlas tile selection and drops,
+local ways, and Pause counting every machine's zones (WIRE.md sections 5 and 8)."""
import json
import os
@@ -9,10 +8,11 @@ import tempfile
import unittest
from unittest import mock
from pathlib import Path
+from types import SimpleNamespace
sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
-from links_rig import B, C, Rig, edge_zone
+from tests.links_rig import B, C, HERE, Rig, edge_zone
import app_config
import pages_win
@@ -22,7 +22,7 @@ from core import ways
from core.tests import responder_harness as harness
try:
- from PySide6.QtWidgets import QApplication
+ from PySide6.QtWidgets import QApplication, QLabel
import diagram
import kvm_bridge_win
@@ -44,9 +44,11 @@ class ShortcutMachineTests(unittest.TestCase):
"""The shortcut, the Send button and the tray send input where core.ways.shortcut_peer says."""
def rig(self, up, **entries):
+ shortcut_goes_to = entries.pop("shortcut_goes_to", "last")
peers = [harness.entry(B, "Bee", side="left", **entries.get("b", {})),
harness.entry(C, "Sea", side="right", **entries.get("c", {}))]
- return Rig(entries=peers, zones=[edge_zone(B), edge_zone(C)], up=up)
+ return Rig(entries=peers, zones=[edge_zone(B), edge_zone(C)], up=up,
+ shortcut_goes_to=shortcut_goes_to)
def test_with_the_first_machine_down_the_shortcut_takes_one_that_is_up(self):
rig = self.rig(up=(C,))
@@ -54,6 +56,13 @@ class ShortcutMachineTests(unittest.TestCase):
self.assertEqual(rig.sender.owner, C)
self.assertEqual(target_of(rig.sent(C, "focus")[0]), C)
+ def test_hold_shortcut_announces_an_unready_last_machine(self):
+ rig = self.rig(up=(C,))
+ rig.sender._last_on = BT
+ rig.sender.hold_shortcut(True)
+ self.assertEqual(rig.sender.owner, C)
+ self.assertEqual(rig.alerts, ["Skipped Bee: not connected."])
+
def test_the_shortcut_goes_back_to_the_machine_input_was_last_on(self):
rig = self.rig(up=(B, C))
rig.sender.go(C)
@@ -63,6 +72,15 @@ class ShortcutMachineTests(unittest.TestCase):
self.assertTrue(rig.sender.set_redirecting(True))
self.assertEqual(rig.sender.owner, C)
+ def test_next_shortcut_cycles_through_drawing_order_and_home(self):
+ rig = self.rig(up=(B, C), shortcut_goes_to="next")
+ rig.sender.toggle_shortcut()
+ self.assertEqual(rig.sender.owner, C)
+ rig.sender.toggle_shortcut()
+ self.assertEqual(rig.sender.owner, B)
+ rig.sender.toggle_shortcut()
+ self.assertIsNone(rig.sender.owner)
+
def test_a_machine_that_does_not_accept_input_is_passed_over(self):
rig = self.rig(up=(C,))
rig.bring_up(B, accepts=False)
@@ -113,6 +131,8 @@ class SetWaysTests(unittest.TestCase):
harness.entry(B, "Bee", side="left", side_set_at=100, side_by=HIGH),
harness.entry(C, "Sea", platform="windows"),
]
+ for entry in settings["peers"]:
+ entry["caps"] = []
settings["zones"] = [{"peer": BT, "kind": "edge"}]
app_config.write_settings(self.path, settings)
@@ -134,26 +154,24 @@ class SetWaysTests(unittest.TestCase):
self.assertIn({"peer": CT, "kind": "edge"}, loaded["zones"])
self.assertIn({"peer": CT, "kind": "edge"}, self.saved()["zones"])
- def test_one_whose_side_is_taken_gets_its_edge_off_and_the_file_still_reads(self):
+ def test_old_peer_on_a_taken_side_keeps_intent_without_an_overlapping_zone(self):
settings = self.saved()
settings["peers"][1]["side"] = "left"
app_config.write_settings(self.path, settings)
loaded = app_config.load_settings(self.path)
- self.assertIn({"peer": CT, "kind": "edge", "off": True}, loaded["zones"])
+ self.assertFalse(any(z["peer"] == CT for z in loaded["zones"]))
+ self.assertTrue(loaded["peers"][1]["ways"]["edge"])
self.assertIn("Sea has no way in", ways.blocked_sentence(loaded, CT, "this PC"))
- def test_one_machines_side_and_zones_are_written_and_the_others_left_alone(self):
- moved = app_config.set_ways(self.path, CT, side="right", methods=["part", "corner"], parts=["end"], corner="bottom_right")
- self.assertTrue(moved)
- entry = self.peer(CT)
- self.assertEqual((entry["side"], entry["side_by"]), ("right", self.saved()["machine_id"]))
- self.assertGreater(entry["side_set_at"], 0)
- zones = self.zones(CT)
- self.assertEqual(zones["part"]["parts"], ["end"])
- self.assertNotIn("off", zones["part"])
- self.assertTrue(zones["edge"]["off"])
- self.assertEqual((zones["corner"]["corner"], zones["corner"]["edge"]), ("bottom_right", "right"))
- self.assertEqual(self.peer(BT)["side"], "left")
+ def test_way_edit_writes_one_peers_intent_and_keeps_both_sides(self):
+ settings = self.saved()
+ settings["peers"][1]["side"] = "right"
+ app_config.write_settings(self.path, settings)
+ self.assertFalse(app_config.set_ways(self.path, CT, side="top", methods=["part", "corner"], parts=["end"], corner="bottom_right"))
+ self.assertEqual(self.peer(CT)["side"], "right")
+ self.assertEqual(self.zones(CT)["part"]["parts"], ["end"])
+ self.assertNotIn("edge", self.zones(CT))
+ self.assertEqual(self.zones(CT)["corner"]["edge"], "right")
self.assertEqual(self.zones(BT), {"edge": {"peer": BT, "kind": "edge"}})
def test_an_unchanged_side_is_not_a_move(self):
@@ -168,16 +186,14 @@ class SetWaysTests(unittest.TestCase):
self.assertEqual(self.peer(BT)["side"], "top")
self.assertEqual(self.zones(BT)["corner"]["edge"], "top")
- def test_a_clash_is_refused_with_a_sentence_naming_both_and_nothing_is_written(self):
- # On Bee's side with no way in yet: turning Sea's edge on would cover Bee's.
- app_config.set_ways(self.path, CT, side="left", methods=[], parts=["middle"], corner="top_left")
- before = self.path.read_bytes()
- with self.assertRaises(app_config.ConfigError) as raised:
- app_config.set_ways(self.path, CT, side="left", methods=["edge"], parts=["middle"], corner="top_left")
- self.assertIn("Bee", str(raised.exception))
- self.assertIn("Sea", str(raised.exception))
- self.assertIn("this PC", str(raised.exception))
- self.assertEqual(self.path.read_bytes(), before)
+ def test_shared_side_way_edit_saves_intent_without_a_clash_refusal(self):
+ settings = self.saved()
+ settings["peers"][1]["side"] = "left"
+ app_config.write_settings(self.path, settings)
+ app_config.set_ways(self.path, CT, methods=["edge"], parts=["middle"], corner="top_left")
+ self.assertTrue(self.peer(CT)["ways"]["edge"])
+ self.assertFalse(any(z["peer"] == CT for z in self.saved()["zones"]))
+ self.assertEqual(self.zones(BT), {"edge": {"peer": BT, "kind": "edge"}})
def test_a_machine_that_is_not_paired_is_an_error(self):
with self.assertRaises(app_config.ConfigError):
@@ -194,8 +210,7 @@ class SetWaysTests(unittest.TestCase):
saved = self.saved()
self.assertEqual((saved["peers"][0]["side"], saved["peers"][0]["side_set_at"], saved["peers"][0]["side_by"]),
("top", 300, HIGH))
- # Sea's edge is the repair every read makes for a machine paired with no zone, not the save's.
- self.assertEqual(saved["zones"], [{"peer": BT, "kind": "edge"}, {"peer": CT, "kind": "edge"}])
+ self.assertEqual(saved["zones"], [{"peer": BT, "kind": "edge"}])
self.assertFalse(saved["shortcut"])
self.assertEqual(saved["pointer_speed"], 2.0)
@@ -217,16 +232,13 @@ class SetWaysTests(unittest.TestCase):
self.assertEqual(app_config.apply_arrangement(self.path, BT, "left", 500, HIGH), (True, []))
self.assertEqual((self.peer(BT)["side"], self.zones(BT)["corner"]["edge"]), ("right", "right"))
- def test_an_arrangement_is_core_ways_and_names_both_machines(self):
- settings = self.saved()
- settings["peers"][1]["side"] = "right"
- settings["zones"].append({"peer": CT, "kind": "edge"})
- app_config.write_settings(self.path, settings)
+ def test_old_peer_arrangement_compiles_without_historical_off_zones(self):
changed, notices = app_config.apply_arrangement(self.path, CT, "right", 500, HIGH)
self.assertTrue(changed)
self.assertEqual(self.peer(CT)["side"], "left")
- self.assertEqual(notices, ["Bee and Sea now lead from the same part of this PC's screen, so Sea's edge is off."])
- self.assertTrue(self.zones(CT)["edge"]["off"])
+ self.assertEqual(notices, [])
+ self.assertEqual(self.zones(CT), {})
+ self.assertTrue(self.peer(CT)["ways"]["edge"])
class DiagramGeometryTests(unittest.TestCase):
@@ -355,7 +367,6 @@ class WindowTests(unittest.TestCase):
settings["port"] = harness.free_port()
app_config.write_settings(self.path, settings)
self.window = kvm_bridge_win.WindowsApplication(self.path)
- # Both linked: a machine with no link gives way instead of being offered thirds (core/ways.py give_way).
self.linked = {BT, CT}
self.window._live = lambda peer: peer in self.linked
self.sent = []
@@ -373,7 +384,49 @@ class WindowTests(unittest.TestCase):
return next(item for item in self.saved()["peers"] if item["id"] == ident)
+class ShortcutCycleRefreshTests(WindowTests):
+ def test_ticked_cycle_remains_visible_after_peer_state_refresh(self):
+ self.window._config.shortcut_goes_to = "ticked"
+
+ self.window._refresh_peers()
+ rows = [row for row in self.window.machines.rows.values() if not row._phone]
+ self.assertEqual(len(rows), 2)
+ self.assertTrue(all(row.shortcut_cycle.isVisibleTo(self.window.machines) for row in rows))
+
+ self.window._refresh_peer_states()
+
+ self.assertTrue(all(row.shortcut_cycle.isVisibleTo(self.window.machines) for row in rows))
+
+
+class HeaderResponseTests(WindowTests):
+ def test_active_sender_peer_uses_outgoing_measurement_before_other_driver(self):
+ outgoing, incoming = B, C
+ link = SimpleNamespace(live=lambda: True, response_time_ms=23)
+ links = SimpleNamespace(_by_peer={outgoing: link}, up=lambda peer: peer == outgoing,
+ _link=lambda peer: link if peer == outgoing else None)
+ with mock.patch.object(self.window, "sender", SimpleNamespace(owner=outgoing, links=links)), \
+ mock.patch.object(self.window, "server", SimpleNamespace(owner=incoming, links=lambda: {incoming},
+ response_time_ms=lambda _peer: 91)):
+ self.assertEqual(self.window._header_response_time(), ("Bee", 23, True))
+
+ def test_receive_only_driver_uses_incoming_measurement(self):
+ sender = SimpleNamespace(owner=None, links=SimpleNamespace(up=lambda _peer: False, _link=lambda _peer: None))
+ server = SimpleNamespace(owner=C, links=lambda: {C}, response_time_ms=lambda peer: 42 if peer == C else None)
+ with mock.patch.object(self.window, "sender", sender), mock.patch.object(self.window, "server", server):
+ self.assertEqual(self.window._header_response_time(), ("Sea", 42, True))
+
+ def test_windows_identity_advertises_ping_response_measurements(self):
+ self.assertIn("ping_rtt", self.window._identity()["caps"])
+
+
class CrossingPageTests(WindowTests):
+ def drop(self, peer, x, y, w=160, h=100, positions=None):
+ layout = {key: dict(tile) for key, tile in self.window.atlas_canvas.tiles.items()}
+ layout.update(positions or {})
+ layout[peer] = {"x": x, "y": y, "w": w, "h": h}
+ self.window._choose_machine(peer)
+ return self.window._layout_dropped(layout, peer)
+
def sharing_side(self):
settings = app_config.load_settings(self.path)
for peer in settings["peers"]:
@@ -384,25 +437,22 @@ class CrossingPageTests(WindowTests):
self.window._choose_machine(CT)
return self.window
- def test_edge_turns_on_over_a_machine_with_no_link_and_that_machines_edge_goes_off(self):
- # 06-10-2026: a machine gone for good held the side, and Edge would not turn on until it was moved.
+ def test_offline_picture_peer_keeps_its_zone_when_another_edge_is_edited(self):
window = self.sharing_side()
self.linked = {CT}
- window._choose_machine(CT)
- self.assertTrue(window.share_module.isHidden())
- window.way_boxes["edge"].setChecked(True)
- self.assertTrue(window.way_boxes["edge"].isChecked())
- zones = {(zone["peer"], zone["kind"]): zone for zone in app_config.load_settings(self.path)["zones"]}
- self.assertTrue(zones[(BT, "edge")].get("off"))
- self.assertTrue(zones[(BT, "edge")].get("aside"))
- self.assertIsNone(zones[(CT, "edge")].get("off"))
+ before = dict(self.bee_zone())
+ window._ledger_edge(CT)
+ window._ledger_edge(CT)
+ self.assertEqual(self.bee_zone(), before)
+ self.assertTrue(self.peer(CT)["ways"]["edge"])
+ self.assertFalse(any("aside" in zone for zone in self.saved()["zones"]))
def lid_shut(self):
- """Sea given Bee's side while Bee, with its lid shut, has no link to this PC."""
+ """Keep Bee offline while Sea edits its ways."""
window = self.sharing_side()
self.linked = {CT}
window._choose_machine(CT)
- window.way_boxes["edge"].setChecked(True)
+ self.assertTrue(window._write_ways(methods=["edge"]))
self.alerts = []
window._on_alert = lambda title, message: self.alerts.append(message)
return window
@@ -411,102 +461,92 @@ class CrossingPageTests(WindowTests):
return next(zone for zone in app_config.load_settings(self.path)["zones"]
if zone["peer"] == BT and zone["kind"] == "edge")
- def test_a_machine_with_its_lid_shut_has_its_edge_set_aside_and_gets_it_back_when_it_connects(self):
+ def test_offline_picture_peer_keeps_its_zone_and_reconnection_adds_no_glue(self):
window = self.lid_shut()
- self.assertEqual(self.bee_zone(), {"peer": BT, "kind": "edge", "off": True, "aside": True})
- window.way_boxes["edge"].setChecked(False)
- window._settle_presence()
- self.assertTrue(self.bee_zone().get("aside"))
+ before = self.saved()
+ self.assertNotIn("aside", self.bee_zone())
self.linked = {BT, CT}
window._settle_presence()
- self.assertEqual(self.bee_zone(), {"peer": BT, "kind": "edge"})
- self.assertIn(protocol.read_id(BT), {peer for peer, _message in self.sent})
+ self.assertEqual(self.saved(), before)
self.assertEqual(self.alerts, [])
- def test_a_machine_back_over_a_side_another_holds_stays_off_and_the_page_offers_thirds(self):
+ def test_reconnecting_picture_peer_keeps_allocations_and_ledger_status_updates(self):
window = self.lid_shut()
+ before = self.saved()["zones"]
self.linked = {BT, CT}
window._settle_presence()
- self.assertEqual(self.bee_zone(), {"peer": BT, "kind": "edge", "off": True})
- self.assertEqual(len(self.alerts), 1)
- window._choose_machine(BT)
- self.assertFalse(window.share_module.isHidden())
+ window._reflect_ways()
+ self.assertEqual(self.saved()["zones"], before)
+ self.assertEqual(self.alerts, [])
+ self.assertIn("Linked", window.crossing_ledger.rows[BT].status.text())
- def test_a_machine_that_removed_this_pairing_stays_off_for_good_and_the_page_says_so(self):
+ def test_forgotten_peer_has_no_zones_but_keeps_intent_and_a_ledger_row(self):
window = self.lid_shut()
- window._gone = lambda peer: peer == BT
- window._settle_presence()
- self.assertEqual(self.bee_zone(), {"peer": BT, "kind": "edge", "off": True})
- self.assertEqual(self.alerts, ["Bee no longer has this pairing, so its edge stays off. Remove Bee here and "
- "pair the two again."])
- window._choose_machine(BT)
- self.assertFalse(window.blocked_note.isHidden())
- self.assertIn("Bee no longer has this pairing", window.blocked_note.text())
-
- def test_the_share_panel_offers_thirds_below_the_side_and_hides_the_blocked_sentence(self):
+ settings = self.saved()
+ settings["peers"][0].update(dormant=True, dormant_reason="forgotten")
+ app_config.write_settings(self.path, settings)
+ window._pull_peer_fields()
+ window._write_ways(peer=CT, edge=True)
+ self.assertFalse(any(z["peer"] == BT for z in self.saved()["zones"]))
+ self.assertTrue(self.peer(BT)["ways"]["edge"])
+ self.assertIn(BT, window.atlas_canvas.shelf_ids)
+ self.assertIn(BT, window.crossing_ledger.rows)
+ self.assertFalse(hasattr(window, "left_out_shelf"))
+
+ def test_selected_machine_is_named_in_its_ledger_row(self):
window = self.sharing_side()
- self.assertFalse(window.share_module.isHidden())
- self.assertEqual([window.share_tiles[p].text() for p in ("start", "middle", "end")],
- ["Top\nBee", "Middle\nBee", "Bottom\nSea"])
- self.assertTrue(window.blocked_note.isHidden())
+ self.assertEqual(window.crossing_ledger.rows[CT].name.full_text, "Sea")
+ self.assertTrue(window.crossing_ledger.rows[CT].selected)
+ self.assertFalse(hasattr(window, "blocked_note"))
- def test_a_tile_cycles_its_machine_and_share_saves_and_tells_each_one(self):
+ def test_dropping_tiles_on_separate_thirds_saves_and_tells_the_new_way_back(self):
window = self.sharing_side()
- window.share_tiles["start"].click()
- self.assertEqual(window.share_tiles["start"].text(), "Top\nSea")
- window.share_button.click()
- zones = {(zone["peer"], zone["kind"]): zone for zone in self.saved()["zones"]}
- self.assertEqual(zones[(BT, "part")]["parts"], ["middle"])
- self.assertEqual(zones[(CT, "part")]["parts"], ["start", "end"])
- self.assertTrue(zones[(BT, "edge")].get("off"))
- self.assertTrue(zones[(CT, "edge")].get("off"))
+ self.assertTrue(self.drop(CT, 160, 67, 160, 33, {BT: dict(x=160, y=0, w=160, h=33)}))
+ zones = {(z["peer"], z["kind"]): z for z in self.saved()["zones"]}
+ self.assertEqual(zones[(BT, "part")]["parts"], ["start"])
+ self.assertEqual(zones[(CT, "part")]["parts"], ["end"])
+ self.assertNotIn((BT, "edge"), zones)
+ self.assertNotIn((CT, "edge"), zones)
+ self.assertEqual(self.peer(BT)["side"], "right")
+ self.assertEqual(self.peer(CT)["side"], "right")
self.assertEqual({peer for peer, _data in self.arrangements()}, {B, C})
+ self.assertTrue(all(data["way_back"] for _, data in self.arrangements()))
- def test_turning_on_edge_keeps_it_off_and_focuses_the_share_button(self):
+ def test_overlapping_drop_lands_only_at_an_accepted_free_position(self):
window = self.sharing_side()
- # An offscreen window is never active, so the focus asked for is what can be checked.
- with mock.patch.object(window.share_button, "setFocus") as focus:
- window.way_boxes["edge"].setChecked(True)
- self.assertFalse(window.way_boxes["edge"].isChecked())
- self.assertFalse(window.share_module.isHidden())
- self.assertTrue(window.blocked_note.isHidden())
- focus.assert_called()
-
- def test_turning_on_an_overlapping_part_keeps_it_off_and_focuses_the_share_button(self):
+ self.assertTrue(self.drop(CT, 160, -50))
+ layout = self.saved()["layout"]
+ self.assertFalse(ways._overlaps(layout[BT], layout[CT]))
+ self.assertEqual(window.atlas_canvas.tiles[CT], layout[CT])
+
+ def test_an_overlapping_partial_tile_is_sent_to_a_free_snap(self):
window = self.sharing_side()
- # An offscreen window is never active, so the focus asked for is what can be checked.
- with mock.patch.object(window.share_button, "setFocus") as focus:
- window.way_boxes["part"].setChecked(True)
- self.assertFalse(window.way_boxes["part"].isChecked())
- self.assertFalse(window.share_module.isHidden())
- self.assertTrue(window.blocked_note.isHidden())
- focus.assert_called()
+ self.assertTrue(self.drop(CT, 160, -50, 160, 33))
+ layout = self.saved()["layout"]
+ self.assertFalse(ways._overlaps(layout[BT], layout[CT]))
+ self.assertFalse(ways._overlaps(layout[window._config.machine_id], layout[CT]))
def test_with_two_machines_paired_the_page_offers_a_choice_of_machine(self):
window = self.window
- self.assertFalse(window.machine_row.isHidden())
- self.assertEqual(set(window.machine_choice._buttons), {BT, CT})
- self.assertEqual([button.text() for button in window.machine_choice._buttons.values()], ["Bee", "Sea"])
- self.assertEqual(window.machine_choice.value, BT)
- self.assertEqual(window.edge_choice.value, "left")
- self.assertTrue(window.way_boxes["edge"].isChecked())
- self.assertEqual(window.edge_heading.text(), "Where Bee is")
+ self.assertEqual(set(window.atlas_canvas.tiles), {window._config.machine_id, BT, CT})
+ self.assertEqual((window.atlas_canvas.labels[BT], window.atlas_canvas.labels[CT]), ("Bee", "Sea"))
+ self.assertEqual(window.atlas_canvas.selected, BT)
+ self.assertEqual(ways.ways(window._crossing_settings(), BT)["side"], "left")
+ self.assertEqual(window.crossing_ledger.rows[BT].name.full_text, "Bee")
def test_choosing_a_machine_shows_its_ways(self):
window = self.window
window._choose_machine(CT)
- self.assertEqual(window.edge_choice.value, None)
- # Every machine paired starts with its whole edge, which waits for a side.
- self.assertTrue(window.way_boxes["edge"].isChecked())
- self.assertTrue(window.way_boxes["shortcut"].isChecked())
- self.assertEqual(window.edge_heading.text(), "Where Sea is")
- self.assertEqual(window.edge_unlearned.text(), pages_win.not_learned_edge("Sea"))
- self.assertIn("Sea", window.ways_summary.text())
+ self.assertEqual(ways.ways(window._crossing_settings(), CT)["methods"], ["edge"])
+ self.assertEqual(window.crossing_ledger.rows[CT].name.full_text, "Sea")
+ self.assertTrue(window.crossing_ledger.rows[CT].selected)
+ self.assertFalse(window.crossing_ledger.rows[BT].selected)
+ self.assertEqual(window.atlas_canvas.selected, CT)
def test_a_side_set_here_is_that_machines_alone_and_is_sent_to_it(self):
window = self.window
window._choose_machine(CT)
- window._set_arrangement("right")
+ self.assertTrue(self.drop(CT, 160, 0))
self.assertEqual(self.peer(CT)["side"], "right")
self.assertEqual(self.peer(BT)["side"], "left")
(peer, message), = self.sent
@@ -517,57 +557,45 @@ class CrossingPageTests(WindowTests):
def arrangements(self):
return [(peer, message["data"]) for peer, message in self.sent if message["type"] == protocol.MSG_ARRANGEMENT]
- def test_turning_off_every_way_to_a_machine_tells_it_so_with_its_side_as_it_was(self):
- self.window.way_boxes["edge"].setChecked(False)
- (peer, data), = self.arrangements()
- self.assertEqual((peer, data["edge"], data["set_at"], data["by"], data["way_back"]), (B, "left", 100, HIGH, False))
- self.window.way_boxes["corner"].setChecked(True)
- self.assertIs(self.arrangements()[-1][1]["way_back"], True)
+ def test_ledger_way_changes_tell_the_peer_its_current_return_way(self):
+ self.window.crossing_ledger.rows[BT].edge_text.click()
+ peer, data = self.arrangements()[-1]
+ self.assertEqual(peer, B)
+ self.assertFalse(data["way_back"])
+ self.assertEqual(data["edge"], self.peer(BT)["side"])
+ self.window.crossing_ledger.rows[BT].corner_glyph.buttons["top_left"].click()
+ self.assertTrue(self.arrangements()[-1][1]["way_back"])
def test_moving_one_machine_tells_every_machine_whose_way_back_it_changed(self):
- settings = self.saved()
- settings["peers"][0].update(side="left", side_set_at=100, side_by=HIGH)
- settings["peers"][1].update(side="left", side_set_at=200, side_by=HIGH)
- settings["zones"] = [{"peer": BT, "kind": "edge"}, {"peer": CT, "kind": "edge", "off": True}]
- app_config.write_settings(self.path, settings)
- self.window._pull_peer_fields()
- self.assertEqual(ways.way_back_by(self.window._crossing_settings(), CT), BT)
- self.window._choose_machine(BT)
- self.window._set_arrangement("right")
- self.assertCountEqual([peer for peer, _data in self.arrangements()], [B, C])
-
- def test_removing_the_machine_in_the_way_tells_the_one_it_blocked(self):
- settings = self.saved()
- settings["peers"][0].update(side="left", side_set_at=100, side_by=HIGH)
- settings["peers"][1].update(side="left", side_set_at=200, side_by=HIGH)
- settings["zones"] = [{"peer": BT, "kind": "edge", "off": True}, {"peer": CT, "kind": "edge"}]
- app_config.write_settings(self.path, settings)
- self.window._pull_peer_fields()
- self.assertEqual(ways.way_back_by(self.window._crossing_settings(), BT), CT)
-
+ self.assertTrue(self.drop(BT, -400, 0, positions={CT: dict(x=400, y=200, w=160, h=100)}))
+ told = {peer: data for peer, data in self.arrangements()}
+ self.assertEqual(set(told), {B, C})
+ self.assertTrue(all(data["way_back"] is False for data in told.values()))
+
+ def test_removing_a_left_out_machine_keeps_the_remaining_crossing(self):
+ self.window._canvas_left_out(CT, True)
+ self.sent.clear()
self.window._remove_peer(harness.TOKENS[C])
+ saved = self.saved()
+ self.assertEqual([p["id"] for p in saved["peers"]], [BT])
+ self.assertTrue(ways.has_way(saved, BT))
+ self.assertFalse(any(peer == C for peer, _data in self.arrangements()))
- told = [(peer, data) for peer, data in self.arrangements() if peer == B]
- self.assertEqual(len(told), 1)
- self.assertFalse(told[0][1]["way_back"])
- self.assertNotIn("way_back_by", told[0][1])
-
- def test_an_arrangement_that_changed_something_is_answered_with_this_pcs_own(self):
+ def test_picture_peer_return_way_changes_are_saved_without_an_answer(self):
window = self.window
+ before = self.saved()["layout"]
window.bridge.arrangement.emit(CT, "left", 500, HIGH, True, None)
- (peer, data), = self.arrangements()
- self.assertEqual((peer, data["edge"], data["set_at"], data["by"], data["way_back"]), (C, "right", 500, HIGH, True))
- self.assertIs(self.peer(CT)["way_back"], True)
- window.bridge.arrangement.emit(CT, "left", 500, HIGH, True, None)
- self.assertEqual(len(self.arrangements()), 1)
+ self.assertTrue(self.peer(CT)["way_back"])
+ self.assertEqual(self.saved()["layout"], before)
+ self.assertEqual(self.arrangements(), [])
window.bridge.arrangement.emit(CT, "left", 500, HIGH, False, None)
- self.assertEqual(len(self.arrangements()), 2)
- self.assertIs(self.peer(CT)["way_back"], False)
+ self.assertFalse(self.peer(CT)["way_back"])
+ self.assertEqual(self.arrangements(), [])
def test_every_link_up_says_whether_a_way_leads_to_that_machine(self):
told = lambda: next(m["data"] for m in self.window._announce(B) if m["type"] == protocol.MSG_ARRANGEMENT)
self.assertIs(told()["way_back"], True)
- self.window.way_boxes["edge"].setChecked(False)
+ self.assertTrue(self.drop(BT, -400, 0))
self.assertIs(told()["way_back"], False)
def test_either_link_hands_on_way_back(self):
@@ -578,114 +606,107 @@ class CrossingPageTests(WindowTests):
self.window.sender.arrangement_callback(C, {**read, "set_at": 501, "way_back": True})
self.assertEqual([args[4] for args in heard], [False, True])
- def test_a_way_with_a_share_offer_keeps_its_box_off_and_shows_the_panel(self):
+ def test_drop_over_another_machine_saves_a_nonoverlapping_snap(self):
window = self.window
- window._choose_machine(CT)
- window._set_arrangement("left")
- before = self.path.read_bytes()
- window.way_boxes["edge"].setChecked(True)
- self.assertFalse(window.way_boxes["edge"].isChecked())
- self.assertEqual(self.path.read_bytes(), before)
- self.assertFalse(window.share_module.isHidden())
- self.assertIn("Bee already crosses from the left edge", window.share_sentence.text())
- self.assertTrue(window.blocked_note.isHidden())
- window._choose_machine(BT)
- self.assertTrue(window.share_module.isHidden())
+ self.assertTrue(self.drop(CT, -160, 0))
+ saved = self.saved()["layout"]
+ self.assertFalse(ways._overlaps(saved[BT], saved[CT]))
+ self.assertEqual(window.atlas_canvas.selected, CT)
def test_ways_written_here_reach_that_machines_zones_only(self):
window = self.window
- window._choose_machine(CT)
- window._set_arrangement("right")
- window.way_boxes["corner"].setChecked(True)
- window._set_corner("bottom_right")
- zones = {zone["kind"]: zone for zone in self.saved()["zones"] if zone["peer"] == CT}
- self.assertNotIn("off", zones["corner"])
- self.assertEqual(zones["corner"]["corner"], "bottom_right")
- self.assertEqual([zone for zone in self.saved()["zones"] if zone["peer"] == BT], [{"peer": BT, "kind": "edge"}])
+ self.assertTrue(self.drop(CT, 160, 0))
+ before = dict(self.peer(BT)["ways"])
+ window.crossing_ledger.rows[CT].corner_glyph.buttons["bottom_right"].click()
+ corners = [z for z in self.saved()["zones"] if z["peer"] == CT and z["kind"] == "corner"]
+ self.assertEqual(corners[0]["corner"], "bottom_right")
+ self.assertEqual(self.peer(BT)["ways"], before)
def test_the_shortcut_stays_this_pcs_own(self):
window = self.window
- window._choose_machine(CT)
- window.way_boxes["shortcut"].setChecked(False)
+ window._ways_changed("shortcut", False)
self.assertFalse(self.saved()["shortcut"])
window._choose_machine(BT)
- self.assertFalse(window.way_boxes["shortcut"].isChecked())
+ self.assertFalse(self.saved()["shortcut"])
+ self.assertTrue(self.peer(BT).get("shortcut_cycle", True))
- def test_a_machine_that_may_drive_this_pc_and_cannot_follow_the_way_is_named(self):
+ def test_selected_machine_stays_named_without_a_missing_way_inspector(self):
window = self.window
window._choose_machine(CT)
- self.assertFalse(window.missing_note.isHidden())
- self.assertIn("While Bee drives this PC, this way to Sea does nothing", window.missing_note.text())
- window._choose_machine(BT)
- self.assertTrue(window.missing_note.isHidden())
+ self.assertEqual(window.crossing_ledger.rows[CT].name.full_text, "Sea")
+ self.assertTrue(window.crossing_ledger.rows[CT].selected)
+ self.assertFalse(hasattr(window, "missing_note"))
- def test_a_machine_whose_side_another_holds_is_named_in_the_share_panel(self):
+ def test_picture_arrangement_keeps_layout_and_selects_its_ledger_row(self):
window = self.window
+ before = self.saved()["layout"]
window._on_arrangement(CT, "right", 500, HIGH)
window._choose_machine(CT)
- self.assertFalse(window.share_module.isHidden())
- self.assertIn("Bee already crosses from the left edge", window.share_sentence.text())
- self.assertTrue(window.blocked_note.isHidden())
- window._choose_machine(BT)
- self.assertTrue(window.share_module.isHidden())
+ self.assertEqual(self.saved()["layout"], before)
+ self.assertTrue(window.crossing_ledger.rows[CT].selected)
+ self.assertFalse(hasattr(window, "blocked_note"))
- def test_a_machine_that_said_no_way_leads_back_is_named_until_it_says_one_does(self):
+ def test_picture_peer_return_way_flag_updates_without_a_notice_block(self):
window = self.window
- self.assertTrue(window.no_way_back_note.isHidden())
window._on_arrangement(BT, "right", 50, HIGH, False)
- self.assertFalse(window.no_way_back_note.isHidden())
- self.assertIn("Bee has no way back to this machine", window.no_way_back_note.text())
+ self.assertFalse(self.peer(BT)["way_back"])
window._on_arrangement(BT, "right", 50, HIGH, True)
- self.assertTrue(window.no_way_back_note.isHidden())
+ self.assertTrue(self.peer(BT)["way_back"])
+ self.assertFalse(hasattr(window, "no_way_back_note"))
- def test_an_arrangement_names_the_machine_holding_the_way_back_side(self):
+ def test_arrangement_keeps_the_return_way_holder_without_a_notice_block(self):
window = self.window
- window._choose_machine(CT)
window._on_arrangement(CT, "right", 500, HIGH, False, BT)
- sea = next(item for item in app_config.load_settings(self.path)["peers"] if item["id"] == CT)
- self.assertEqual(sea["way_back_by"], BT)
- self.assertIn("Bee on its right too", window.no_way_back_note.text())
+ self.assertEqual(self.peer(CT)["way_back_by"], BT)
+ self.assertFalse(hasattr(window, "no_way_back_note"))
- def test_an_arrangement_from_the_machine_not_shown_moves_only_its_side(self):
+ def test_nonselected_picture_arrangement_keeps_its_side_and_layout(self):
window = self.window
- window._on_arrangement(CT, "left", 500, HIGH)
- self.assertEqual(window.edge_choice.value, "left")
- window._choose_machine(CT)
- self.assertEqual(window.edge_choice.value, "right")
+ before = self.saved()["layout"]
+ side = self.peer(CT)["side"]
+ window._on_arrangement(CT, "left", 500, HIGH, True)
+ self.assertEqual(window.atlas_canvas.selected, BT)
+ self.assertEqual(self.peer(CT)["side"], side)
+ self.assertEqual(self.saved()["layout"], before)
+ self.assertTrue(self.peer(CT)["way_back"])
def test_the_diagram_draws_every_machine(self):
window = self.window
window._choose_machine(CT)
- window._set_arrangement("right")
- drawn = {machine["label"]: machine for machine in window.arrangement_diagram._machines}
- self.assertEqual((drawn["Bee"]["side"], drawn["Sea"]["side"]), ("left", "right"))
- self.assertTrue(drawn["Sea"]["chosen"])
- self.assertFalse(drawn["Bee"]["chosen"])
- self.assertIn("Bee is to the left of this PC", window.arrangement_diagram.accessibleDescription())
+ self.assertTrue(self.drop(CT, 160, 0))
+ canvas = window.atlas_canvas
+ own = canvas.tiles[window._config.machine_id]
+ self.assertEqual(ways._rect_contact(own, canvas.tiles[BT])[0], "left")
+ self.assertEqual(ways._rect_contact(own, canvas.tiles[CT])[0], "right")
+ self.assertEqual(canvas.selected, CT)
+ self.assertEqual((canvas.labels[BT], canvas.labels[CT]), ("Bee", "Sea"))
def test_pause_counts_every_machines_zones(self):
window = self.window
window._choose_machine(BT)
- window.way_boxes["edge"].setChecked(False)
+ self.assertTrue(self.drop(BT, -400, 0,
+ positions={CT: {"x": 400, "y": 200, "w": 160, "h": 100}}))
self.assertFalse(window._crossing_state_args()[4])
window._choose_machine(CT)
- window._set_arrangement("right")
- window.way_boxes["edge"].setChecked(True)
+ self.assertTrue(self.drop(CT, 160, 0))
self.assertTrue(window._crossing_state_args()[4])
- def test_the_same_switch_reaches_every_machine(self):
- self.assertEqual(self.window.same_switch.text(), "Same on all machines")
+ def test_granular_same_groups_name_each_shared_area(self):
+ self.assertEqual(set(self.window.same_checks), {"crossing", "design", "shortcut", "names", "everything"})
+ self.assertIn("Names shares this machine's name and paired-machine labels",
+ self.window.same_content_note.text())
class OneMachineTests(WindowTests):
PEERS = [harness.entry(B, "Bee", side="left")]
- def test_one_machine_has_no_choice_and_the_page_reads_as_before(self):
+ def test_one_machine_is_selected_on_the_canvas_with_its_existing_way(self):
window = self.window
- self.assertTrue(window.machine_row.isHidden())
- self.assertEqual(window.edge_heading.text(), "Where the other machine is")
- self.assertEqual(window.edge_choice.value, "left")
- self.assertTrue(window.way_boxes["edge"].isChecked())
+ self.assertEqual(set(window.atlas_canvas.tiles), {window._config.machine_id, BT})
+ self.assertEqual(window.atlas_canvas.selected, BT)
+ self.assertEqual(window.crossing_ledger.rows[BT].name.full_text, "Bee")
+ self.assertEqual(ways.ways(window._crossing_settings(), BT)["side"], "left")
+ self.assertEqual(ways.ways(window._crossing_settings(), BT)["methods"], ["edge"])
def test_the_tray_has_no_item_per_machine_and_the_button_names_it(self):
window = self.window
@@ -695,6 +716,20 @@ class OneMachineTests(WindowTests):
class TrayTests(WindowTests):
+ def test_tray_groups_status_version_connection_directions_and_settings(self):
+ window = self.window
+ actions = window.tray_menu.actions()
+ self.assertIs(actions[0], window.status_action)
+ self.assertTrue(actions[1].isSeparator())
+ self.assertIs(actions[2], window.header_action)
+ self.assertTrue(actions[3].isSeparator())
+ labels = [action.text() for action in actions if not action.isSeparator()]
+ self.assertLess(labels.index("Send input to Bee"), labels.index("Pause crossing"))
+ self.assertLess(labels.index("Pause crossing"), labels.index(window.send_action.text()))
+ self.assertLess(labels.index(window.send_action.text()), labels.index(window.drive_action.text()))
+ self.assertLess(labels.index(window.drive_action.text()), labels.index("Settings…"))
+ self.assertEqual(window.open_action.text(), "Settings…")
+
def test_each_machine_this_pc_sends_to_has_its_own_tray_item(self):
window = self.window
self.assertEqual([action.text() for action in window.machine_actions.values()],
@@ -705,6 +740,100 @@ class TrayTests(WindowTests):
self.assertEqual(went, [C])
self.assertFalse(window.redirect_action.isVisible())
+ def test_active_target_row_returns_input_and_owner_changes_update_existing_rows(self):
+ window = self.window
+ returned = []
+ went = []
+ sender = SimpleNamespace(redirecting=True, owner=C,
+ set_redirecting=lambda enabled: returned.append(enabled),
+ go=lambda peer, *args: went.append(peer) or True,
+ shortcut_target=lambda: C)
+ with mock.patch.object(window, "sender", sender):
+ window._refresh_tray_machines()
+ sea = window.machine_actions[CT]
+ bee = window.machine_actions[BT]
+ self.assertEqual(sea.text(), "Bring input back")
+ self.assertTrue(sea.isEnabled())
+ self.assertFalse(window.redirect_action.isVisible())
+ sea.trigger()
+ self.assertEqual(returned, [False])
+
+ sender.owner = B
+ window._refresh_tray_machines()
+ self.assertIs(window.machine_actions[CT], sea)
+ self.assertIs(window.machine_actions[BT], bee)
+ self.assertEqual(sea.text(), "Send input to Sea")
+ self.assertEqual(bee.text(), "Bring input back")
+ sea.trigger()
+ self.assertEqual(went, [C])
+
+ next(entry for entry in window._peer_entries if entry["id"] == CT)["name"] = "Seaside"
+ window._labels_by_id[C] = "Seaside"
+ window._refresh_tray_machines()
+ self.assertIs(window.machine_actions[CT], sea)
+ self.assertEqual(sea.text(), "Send input to Seaside")
+
+ sender.redirecting = False
+ sender.owner = None
+ window._refresh_tray_machines()
+ self.assertEqual(sea.text(), "Send input to Seaside")
+ self.assertEqual(bee.text(), "Send input to Bee")
+
+ window._peer_entries = [entry for entry in window._peer_entries if entry.get("id") == CT]
+ window._refresh_tray_machines()
+ self.assertEqual(window.machine_actions, {})
+ self.assertTrue(window.redirect_action.isVisible())
+ self.assertEqual(window._redirect_text(), "Send input to Seaside")
+
+ window._peer_entries = []
+ window._refresh_tray_machines()
+ self.assertEqual(window.machine_actions, {})
+ self.assertTrue(window.redirect_action.isVisible())
+
+ def test_direction_switches_name_every_machine_and_distinguish_mixed_none_and_all(self):
+ window = self.window
+
+ def set_directions(send, allow_drive):
+ settings = self.saved()
+ for entry, sends, allows in zip(settings["peers"], send, allow_drive):
+ entry["send"] = sends
+ entry["allow_drive"] = allows
+ app_config.write_settings(self.path, settings)
+ window._pull_peer_fields()
+ window._refresh_tray_directions()
+
+ set_directions((True, False), (False, True))
+ self.assertEqual(window.send_action.text(), "This PC drives every machine (some enabled)")
+ self.assertEqual(window.drive_action.text(), "Every machine drives this PC (some enabled)")
+ self.assertFalse(window.send_action.isChecked())
+ self.assertFalse(window.drive_action.isChecked())
+ window._after_peers_edit = lambda: None
+ window.send_action.trigger()
+ self.assertTrue(all(entry["send"] is True for entry in self.saved()["peers"]))
+ self.assertTrue(window.send_action.isChecked())
+
+ set_directions((False, False), (False, False))
+ self.assertEqual(window.send_action.text(), "This PC drives every machine")
+ self.assertEqual(window.drive_action.text(), "Every machine drives this PC")
+ self.assertFalse(window.send_action.isChecked())
+ self.assertFalse(window.drive_action.isChecked())
+
+ set_directions((True, True), (True, True))
+ self.assertTrue(window.send_action.isChecked())
+ self.assertTrue(window.drive_action.isChecked())
+ window.send_action.trigger()
+ self.assertTrue(all(entry["send"] is False for entry in self.saved()["peers"]))
+
+ def test_zero_peers_leave_the_disabled_general_send_action_available(self):
+ window = self.window
+ window._peer_entries = []
+ window._refresh_tray_directions()
+ window._refresh_tray_machines()
+ self.assertFalse(window.send_action.isEnabled())
+ self.assertFalse(window.drive_action.isEnabled())
+ self.assertEqual(window.machine_actions, {})
+ self.assertTrue(window.redirect_action.isVisible())
+
def test_the_send_button_names_the_machine_the_shortcut_would_pick(self):
window = self.window
window.sender.shortcut_target = lambda: C
@@ -747,5 +876,30 @@ class DiagramWidgetTests(unittest.TestCase):
self.assertEqual(picture._marks[("edge", "b", "right")], 1.0)
[email protected](kvm_bridge_win is None, "needs PySide6")
+class TrayRouteTests(unittest.TestCase):
+ def setUp(self):
+ self.app = SimpleNamespace(
+ sender=SimpleNamespace(redirecting=False, owner=None, route_chain=(HERE, B, C)),
+ server=SimpleNamespace(owner=None),
+ _labels_by_id={B: "PC", C: "Linux"},
+ _identity=lambda: {"id": HERE, "name": "Mac"},
+ _label_of=lambda peer: {B: "PC", C: "Linux"}.get(peer, "another machine"),
+ )
+
+ def test_tray_state_names_the_machine_that_drives_this_pc(self):
+ self.assertEqual(kvm_bridge_win.WindowsApplication._drive_status(self.app), "Idle")
+ self.app.sender.redirecting = True
+ self.app.sender.owner = B
+ self.assertEqual(kvm_bridge_win.WindowsApplication._drive_status(self.app), "Driving PC")
+ self.app.sender.redirecting = False
+ self.app.server.owner = C
+ self.assertEqual(kvm_bridge_win.WindowsApplication._drive_status(self.app), "Driven by Linux")
+
+ def test_crossing_route_shows_the_whole_chain_in_order(self):
+ self.assertEqual(kvm_bridge_win.WindowsApplication._current_chain_sentence(self.app),
+ "Current chain: Mac → PC → Linux")
+
+
if __name__ == "__main__":
unittest.main()
diff --git a/win_app/tests/test_phone_settings.py b/win_app/tests/test_phone_settings.py
index a2febb4..9b4e5fd 100644
--- a/win_app/tests/test_phone_settings.py
+++ b/win_app/tests/test_phone_settings.py
@@ -29,7 +29,7 @@ def peer(number, phone=False, **fields):
class PhoneSettingsTests(unittest.TestCase):
def setUp(self):
- directory = tempfile.TemporaryDirectory(dir=ROOT)
+ directory = tempfile.TemporaryDirectory(dir=ROOT / "win_app")
self.addCleanup(directory.cleanup)
self.path = Path(directory.name) / "settings.json"
self.phone = peer(2, phone=True)
@@ -51,6 +51,7 @@ class PhoneSettingsTests(unittest.TestCase):
with self.subTest(order=[p["port"] for p in peers]):
before = self.put(peers)
config = app_config.load_config(self.path)
+ before = app_config.load_settings(self.path)
desktop = next((p for p in peers if p["port"]), None)
self.assertEqual(config.auth_token, desktop["token"] if desktop else "")
self.assertEqual(config.mac_host, desktop["host"] if desktop else "")
diff --git a/win_app/tests/test_phone_ui.py b/win_app/tests/test_phone_ui.py
index 310d00a..87684fc 100644
--- a/win_app/tests/test_phone_ui.py
+++ b/win_app/tests/test_phone_ui.py
@@ -93,7 +93,7 @@ class PhoneUiTests(unittest.TestCase):
app = application("_crossing_machines", "_crossing_settings")
app._peer_entries = entries()
app._zone_entries = [dict(peer=PHONE), dict(peer=DESKTOP)]
- app._config = SimpleNamespace(machine_id="own")
+ app._config = SimpleNamespace(machine_id="own", layout={}, layout_set_at=0, layout_by="")
app._shown = lambda text: text
self.assertEqual(app._crossing_machines(), [(DESKTOP, "Desktop")])
self.assertEqual(app._crossing_settings()["peers"], [entries()[1]])
@@ -132,7 +132,7 @@ class PhoneUiTests(unittest.TestCase):
app = application("_refresh_design_follow", "_lock_followed_design", QStandardItemModel=Model, QStandardItem=Item)
app._peer_entries = entries()
- app._config = SimpleNamespace(design_follow_peer="", same_on_both=False)
+ app._config = SimpleNamespace(design_follow_peer="", same_on_both=False, hide_addresses=False)
app._design_states = {PHONE: {}, DESKTOP: {}}
app._design_peer_caps = lambda: {PHONE: {"design_sync"}, DESKTOP: {"design_sync"}}
app._shown = lambda text: text
@@ -199,13 +199,15 @@ class PhoneUiTests(unittest.TestCase):
def test_phone_row_has_name_platform_remove_and_in_use_without_directions(self):
row = load_methods("win_app/machines_win.py", "PeerRow", ["refresh", "_ask"],
- dict(KEEP_NOTE="kept"))()
+ dict(KEEP_NOTE="kept", peerlist=peerlist))()
for name in ("name", "word", "where", "detail", "confirm_text", "in_use", "send", "allow",
- "remove_button", "directions", "direction_group", "confirm"):
+ "remove_button", "directions", "direction_group", "shortcut_cycle", "repair_button",
+ "confirm", "left_out", "left_out_note"):
setattr(row, name, Control())
row.led = SimpleNamespace(set_tone=lambda tone: None)
row.confirm.visible = False
- row.refresh(entries()[0], "My phone", SimpleNamespace(tone="signal", word="Linked", detail="Connected"), "iPhone")
+ row.refresh(entries()[0], "My phone", SimpleNamespace(tone="signal", word="Linked", detail="Connected"),
+ "iPhone", cycle_mode="last")
self.assertEqual(row.name.text(), "My phone")
self.assertEqual(row.where.text(), "iPhone")
self.assertFalse(row.directions.visible)
diff --git a/win_app/tests/test_qt_polish.py b/win_app/tests/test_qt_polish.py
index 82b6113..d3d2779 100644
--- a/win_app/tests/test_qt_polish.py
+++ b/win_app/tests/test_qt_polish.py
@@ -22,7 +22,7 @@ class QtPolishTests(unittest.TestCase):
set_size = acceptance.SettingsLayoutAcceptance.set_size
page_scroll = acceptance.SettingsLayoutAcceptance.page_scroll
- def test_01_selected_segment_has_dark_text_on_light_with_contrast(self):
+ def test_01_selected_segment_ink_contrasts_in_both_appearances(self):
self.set_size(900)
for dark in (False, True):
theme.set_dark(dark)
@@ -36,18 +36,21 @@ class QtPolishTests(unittest.TestCase):
image = image.copy(round(point.x() * dpr), round(point.y() * dpr),
round(button.width() * dpr), round(button.height() * dpr))
bg = image.pixelColor(image.width() // 2, round(5 * image.devicePixelRatio()))
- self.assertGreater(bg.lightnessF(), .7)
# Measure actual painted glyph ink, rather than merely the stylesheet palette.
centre = image.copy(round(12 * image.devicePixelRatio()), round(10 * image.devicePixelRatio()),
image.width() - round(24 * image.devicePixelRatio()),
image.height() - round(20 * image.devicePixelRatio()))
- ink = min((centre.pixelColor(x, y) for x in range(centre.width())
- for y in range(centre.height())), key=lambda c: c.lightnessF())
def luminance(colour):
values = [v / 12.92 if v <= .04045 else ((v + .055) / 1.055) ** 2.4
for v in colour.getRgbF()[:3]]
return sum(v * w for v, w in zip(values, (.2126, .7152, .0722)))
- self.assertGreaterEqual((luminance(bg) + .05) / (luminance(ink) + .05), 4.5)
+ bg_luminance = luminance(bg)
+ ink = (max if bg_luminance < .5 else min)(
+ (centre.pixelColor(x, y) for x in range(centre.width()) for y in range(centre.height())),
+ key=luminance,
+ )
+ ratio = (max(bg_luminance, luminance(ink)) + .05) / (min(bg_luminance, luminance(ink)) + .05)
+ self.assertGreaterEqual(ratio, 4.5)
def test_02_segments_measure_longest_label_and_never_wrap(self):
for width in (320, 640, 900, 1440, 1920):
@@ -105,32 +108,34 @@ class QtPolishTests(unittest.TestCase):
self.assertLessEqual(row.directions.x() - (row.in_use.x() + row.in_use.width()), 16)
self.assertAlmostEqual(row.remove_button.x() + row.remove_button.width(), row.width(), delta=1)
- def test_07_parts_are_segmented_and_corners_use_two_columns(self):
- self.assertIsInstance(self.window.crossing_rows["parts"].holder.layout().itemAt(0).widget(), widgets._SegmentedView)
+ def test_07_atlas_canvas_and_ledger_replace_the_inspector(self):
+ self.assertIsInstance(self.window.atlas_canvas, diagram.AtlasCanvas)
self.set_size(1440)
self.page_scroll("crossing")
- view = self.window.corner_choice.view
- view.show()
- self.settle()
- self.assertLessEqual(len({button.y() for button in view.buttons}), 2)
+ self.assertFalse(self.window.crossing_ledger.isHidden())
+ for row in self.window.crossing_ledger.rows.values():
+ self.assertEqual(len(row.edge_glyph.buttons), 3)
+ self.assertEqual(len(row.corner_glyph.buttons), 4)
+ self.assertFalse(hasattr(self.window, "way_boxes"))
def test_08_every_legend_way_has_a_description(self):
self.assertTrue(all(description for _, _, description in pages_win.WAY_ROWS))
def test_09_headers_and_diagram_labels_wrap(self):
self.assertTrue(self.window.ways_module.eyebrow.wordWrap())
- self.assertTrue(self.window.jump_heading.wordWrap())
+ self.assertFalse(hasattr(self.window, "selected_machine_header"))
+ for row in self.window.crossing_ledger.rows.values():
+ self.assertTrue(row.status.wordWrap())
+ self.assertTrue(row.edge_detail.wordWrap())
strip = self.window.resistance_strip
- strip.resize(400, 44)
+ strip.resize(400, 72)
strip.set_other_name("Other machine")
- metrics = QFontMetrics(theme.font(theme.TYPE["small"], 600))
- width = strip.target_width() if hasattr(strip, "target_width") else strip.MAC
- self.assertGreaterEqual(width, metrics.horizontalAdvance("Other machine") + 12)
+ metrics = QFontMetrics(theme.font(theme.TYPE["eyebrow"], 600))
+ self.assertEqual(strip.accessibleName(), "Resistance")
+ self.assertEqual(strip.height(), 72)
strip.set_other_name("Synthetic workstation with a long machine name")
- strip.resize(160, 44)
- needed = metrics.boundingRect(QRect(0, 0, round(strip.target_width() - 8), 10000),
- int(Qt.TextFlag.TextWrapAnywhere), strip._other)
- self.assertGreaterEqual(strip.heightForWidth(160), needed.height() + 4)
+ strip.resize(320, 72)
+ self.assertLessEqual(metrics.horizontalAdvance(strip.peer_label_text()), 144)
def test_10_status_uses_hanken_with_normal_tracking(self):
self.page_scroll("overview")
@@ -148,20 +153,28 @@ class QtPolishTests(unittest.TestCase):
self.assertGreaterEqual(button.width(), button.fontMetrics().horizontalAdvance(button.text()) + 16)
self.assertGreaterEqual(button.height(), 30)
self.page_scroll("crossing")
- drawing = self.window.arrangement_diagram
- self.assertFalse(self.window.ways_pair.beside())
- self.assertGreaterEqual(drawing.width(), 120)
- pc, screens, _ = drawing._drawing(drawing.width())
- for rect in [pc, *screens.values()]:
- self.assertGreaterEqual(rect[0], 0)
- self.assertLessEqual(rect[0] + rect[2], drawing.width() + 1)
- metrics = QFontMetrics(theme.font(theme.TYPE["small"], 600))
- for key, rect in screens.items():
- needed = metrics.boundingRect(QRect(0, 0, max(1, round(rect[2] - 8)), 10000),
- int(Qt.TextFlag.TextWrapAnywhere), drawing._labels[key])
- self.assertLessEqual(needed.height(), rect[3] - 4)
- self.assertLessEqual(needed.width(), rect[2] - 8 + 1)
- self.assertGreaterEqual(self.window.jump_recorder.height(), self.window.jump_recorder.heightForWidth(self.window.jump_recorder.width()))
+ canvas = self.window.atlas_canvas
+ self.assertGreaterEqual(canvas.width(), 120)
+ for peer in canvas.tiles:
+ rect = canvas.tile_rect(peer)
+ with self.subTest(peer=peer):
+ self.assertGreaterEqual(rect.left(), 0)
+ self.assertGreaterEqual(rect.top(), 0)
+ self.assertLessEqual(rect.right(), canvas.width())
+ self.assertLessEqual(rect.bottom(), canvas.height())
+ self.set_size(900)
+ self.page_scroll("crossing")
+ canvas = self.window.atlas_canvas
+ from PySide6.QtCore import QEvent
+ from PySide6.QtGui import QMouseEvent
+ for peer in canvas.tiles:
+ point = canvas.tile_rect(peer).center()
+ self.app.sendEvent(canvas, QMouseEvent(QEvent.Type.MouseMove, point, point,
+ Qt.MouseButton.NoButton, Qt.MouseButton.NoButton, Qt.KeyboardModifier.NoModifier))
+ self.assertIn(canvas.labels[peer], canvas.toolTip())
+ self.assertIn(canvas.labels[peer], canvas.accessibleDescription())
+ for row in self.window.crossing_ledger.rows.values():
+ self.assertGreaterEqual(row.jump.height(), row.jump.heightForWidth(row.jump.width()))
def test_12_rail_ends_above_footer_at_minimum_height(self):
self.set_size(320, 300)
diff --git a/win_app/tests/test_real_font.py b/win_app/tests/test_real_font.py
index c45d2dd..be93cb5 100644
--- a/win_app/tests/test_real_font.py
+++ b/win_app/tests/test_real_font.py
@@ -54,7 +54,7 @@ def _run_real_font_window():
theme.init_fonts()
app.setFont(theme.font(theme.TYPE["body"]))
assert theme.sans() == tokens.UI_FAMILY
- work_root = Path(__file__).resolve().parents[2] / "renders" / "test-working"
+ work_root = Path(__file__).resolve().parents[1] / "renders" / "test-working"
work_root.mkdir(parents=True, exist_ok=True)
with tempfile.TemporaryDirectory(dir=work_root) as directory:
config_path = Path(directory) / "settings.json"
diff --git a/win_app/tests/test_return_edge.py b/win_app/tests/test_return_edge.py
index 85ba94b..5e973fb 100644
--- a/win_app/tests/test_return_edge.py
+++ b/win_app/tests/test_return_edge.py
@@ -42,14 +42,21 @@ class GeometryTests(unittest.TestCase):
# that point: the left monitor for most of the left edge, the primary above it, where the
# primary's own left edge is the wall.
self.assertEqual(arrival_position(ARRANGEMENT, "left", 0.5), (-1920, 720))
- self.assertEqual(arrival_position(ARRANGEMENT, "left", 0.0), (0, 0))
+ # The very end of an edge lands LANDING_CLEAR_PX in, clear of the edge and corner beside it.
+ self.assertEqual(arrival_position(ARRANGEMENT, "left", 0.0), (0, 10))
# right: the primary, at its last pixel column.
self.assertEqual(arrival_position(ARRANGEMENT, "right", 0.5), (2559, 720))
# top: 10% of 4480 from x=-1920 is over the left monitor, whose top is exposed at y=200.
self.assertEqual(arrival_position(ARRANGEMENT, "top", 0.1), (-1472, 200))
self.assertEqual(arrival_position(ARRANGEMENT, "top", 0.75), (1440, 0))
# bottom: the primary reaches y=1439; the left monitor stops at 1279.
- self.assertEqual(arrival_position(ARRANGEMENT, "bottom", 1.0), (2559, 1439))
+ self.assertEqual(arrival_position(ARRANGEMENT, "bottom", 1.0), (2549, 1439))
+
+ def test_arrival_can_target_a_named_display_side(self):
+ displays = {"panel-right": Rect(100, 0, 100, 100)}
+ self.assertEqual(arrival_position([Rect(0, 0, 100, 100), displays["panel-right"]],
+ "left", 0.5, display="panel-right", side="right",
+ display_map=displays), (199, 50))
class PressureTests(unittest.TestCase):
@@ -66,6 +73,24 @@ class PressureTests(unittest.TestCase):
self.assertEqual(self.feed((-1920, 500), 5).action, PASS)
self.assertEqual(self.edge.pressure, 0.0)
+ def test_display_zone_holds_and_crosses_at_an_internal_seam(self):
+ clock = FakeClock()
+ left, right = Rect(0, 0, 100, 100), Rect(100, 0, 100, 100)
+ edge = ReturnEdge("right", resistance_px=10, clock=clock, display="left")
+ first = edge.feed([left, right], (100, 50), 6, 0, display_map={"left": left, "right": right})
+ self.assertEqual((first.action, first.position), (HOLD, (99, 50)))
+ second = edge.feed([left, right], (99, 50), 6, 0, display_map={"left": left, "right": right})
+ self.assertEqual((second.action, second.edge, second.offset), (CROSS, "left", 0.5))
+
+ def test_crossing_returns_the_receiving_display_and_side(self):
+ clock = FakeClock()
+ left, right = Rect(0, 0, 100, 100), Rect(100, 0, 100, 100)
+ edge = ReturnEdge("right", resistance_px=10, clock=clock, display="left",
+ target_display="panel-right", target_side="left")
+ edge.feed([left, right], (100, 50), 6, 0, display_map={"left": left, "right": right})
+ result = edge.feed([left, right], (99, 50), 6, 0, display_map={"left": left, "right": right})
+ self.assertEqual((result.display, result.side), ("panel-right", "left"))
+
def test_outward_push_at_the_edge_holds_and_accumulates(self):
outcome = self.feed((-1920, 500), -30, 4)
self.assertEqual(outcome.action, HOLD)
@@ -87,6 +112,25 @@ class PressureTests(unittest.TestCase):
self.feed((-1920, 500), -60)
self.assertAlmostEqual(self.feed((-1920, 500), 0, after=0.1).pressure, 0.25)
+ def test_pressure_at_is_side_effect_free_and_uses_fixed_decay_at_120_and_500(self):
+ for resistance in (120, 500):
+ clock = FakeClock()
+ edge = ReturnEdge("left", resistance_px=resistance, clock=clock)
+ edge.feed(ARRANGEMENT, (-1920, 500), -100, 0)
+ clock.advance(0.2)
+ with self.subTest(resistance=resistance):
+ self.assertAlmostEqual(edge.pressure_at(clock()) * resistance, 40.0)
+ self.assertAlmostEqual(edge._travel, 100.0)
+
+
+ def test_track_endpoints_and_fill_head_share_the_same_coordinate_scale(self):
+ from core.resistance_strip import resistance_x
+
+ self.assertEqual(resistance_x(720, 0), 18.0)
+ self.assertEqual(resistance_x(720, 500), 702.0)
+ self.assertEqual(resistance_x(720, 250), 360.0)
+ self.assertEqual(resistance_x(720, 700), resistance_x(720, 500))
+
def test_breakthrough_sends_the_opposite_edge_and_the_offset(self):
self.feed((-1920, 720), -100)
outcome = self.feed((-1920, 720), -20)
@@ -174,7 +218,7 @@ class LandingMonitorTests(unittest.TestCase):
def test_a_monitor_left_of_and_above_the_primary(self):
monitors = [Rect(0, 0, 1728, 1117), Rect(-2560, -200, 2560, 1440)]
- self.assertEqual(arrival_position(monitors, "left", 0.0), (-2560, -200))
+ self.assertEqual(arrival_position(monitors, "left", 0.0), (-2560, -190))
self.assertEqual(arrival_position(monitors, "right", 0.5)[0], 1727)
diff --git a/win_app/tests/test_rig_map_rc13.py b/win_app/tests/test_rig_map_rc13.py
new file mode 100644
index 0000000..2795e38
--- /dev/null
+++ b/win_app/tests/test_rig_map_rc13.py
@@ -0,0 +1,83 @@
+"""The rig's rc13 map (10-10-2026): the Mac saved to the left of this PC, the loan laptop paired on the
+right with no tile of its own. The owner saw a vertical stack, tiny tiles and a mostly empty map."""
+
+import unittest
+
+import app_config
+import test_crossing_page_parity as parity
+from core import pairing, peerlist
+
+
+class RigMapRc13(unittest.TestCase):
+ setUp = parity.CrossingPageParityTests.setUp
+ tearDown = parity.CrossingPageParityTests.tearDown
+ _open_window = parity.CrossingPageParityTests._open_window
+ _close_window = parity.CrossingPageParityTests._close_window
+ _stop_patches = parity.CrossingPageParityTests._stop_patches
+
+ def _rig(self, stacked=False):
+ self._close_window()
+ settings = app_config.migrate({"appearance": "dark", "name": "Desk PC", "peers": [], "check_updates": False})
+ settings.update(name="Desk PC", check_updates=False)
+ self.peers = []
+ for index, (name, platform) in enumerate((("Studio Mac", "macos"), ("Loan laptop", "windows"))):
+ entry = pairing.peer_entry(bytes([index + 7]) * 16, name, platform, 24820 + index,
+ "A" * 43, f"192.168.1.{20 + index}", 1791321600 + index)
+ entry["linked"] = True
+ peerlist.add_peer(settings, entry)
+ self.peers.append(entry)
+ app_config.write_settings(self.path, settings)
+ mac, acg = (entry["id"] for entry in self.peers)
+ app_config.set_ways(self.path, mac, side="left", methods=["part", "corner"], parts=["start", "end"],
+ corner="bottom_right")
+ app_config.set_ways(self.path, acg, side="" if stacked else "right",
+ methods=["edge"], parts=[], corner="")
+ settings = app_config.load_settings(self.path)
+ own = settings["machine_id"]
+ settings["peers"][0]["side"] = "left"
+ settings["peers"][1]["side"] = "" if stacked else "right"
+ settings["layout"] = {own: {"x": -500, "y": 149, "w": 160, "h": 100, "name": "Desk PC"},
+ mac: {"x": -500 if stacked else -660,
+ "y": 249 if stacked else 149, "w": 160, "h": 100, "name": "Studio Mac"}}
+ settings["layout_by"] = own
+ app_config.write_settings(self.path, settings)
+ self._open_window()
+ self.window.resize(1100, 760)
+ parity.settle(self.window)
+ return own, mac, acg
+
+ def test_the_rig_arrangement_draws_as_saved(self):
+ own, mac, acg = self._rig()
+ canvas = self.window.atlas_canvas
+ rects = {key: canvas.tile_rect(key) for key in (mac, own, acg)}
+ self.assertEqual(set(canvas.tiles), {mac, own, acg})
+ self.assertLess(rects[mac].right(), rects[own].left() + 1)
+ self.assertLess(rects[own].right(), rects[acg].left() + 1,
+ f"tiles={ {key: (rect.x(), rect.y(), rect.width(), rect.height()) for key, rect in rects.items()} }")
+ self.assertEqual(len({round(rect.y()) for rect in rects.values()}), 1)
+ for key, rect in rects.items():
+ for other in rects:
+ if other != key:
+ self.assertFalse(rect.intersects(rects[other]))
+ left = min(rect.left() for rect in rects.values())
+ right = max(rect.right() for rect in rects.values())
+ top = min(rect.top() for rect in rects.values())
+ bottom = max(rect.bottom() for rect in rects.values())
+ self.assertAlmostEqual((left+right)/2, canvas.width()/2, delta=1)
+ self.assertAlmostEqual((top+bottom)/2, canvas.height()/2, delta=1)
+ self.assertGreaterEqual(canvas._scale, 0.75)
+ saved = app_config.load_settings(self.path)
+ self.assertEqual(saved["layout"][acg]["x"], -340)
+ self.assertEqual(next(peer["side"] for peer in saved["peers"] if peer["id"] == acg), "right")
+
+ def test_stacked_rig_arrangement_does_not_overlap(self):
+ own, mac, acg = self._rig(stacked=True)
+ canvas = self.window.atlas_canvas
+ rects = [canvas.tile_rect(peer) for peer in (own, mac, acg)]
+ for index, rect in enumerate(rects):
+ for other in rects[index+1:]:
+ self.assertFalse(rect.intersects(other))
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/win_app/tests/test_same_on_both.py b/win_app/tests/test_same_on_both.py
index 90735ef..ea9f746 100644
--- a/win_app/tests/test_same_on_both.py
+++ b/win_app/tests/test_same_on_both.py
@@ -10,6 +10,8 @@ from pathlib import Path
from unittest import mock
try:
+ from PySide6.QtTest import QTest
+ from PySide6.QtCore import Qt
from PySide6.QtWidgets import QApplication
import kvm_bridge_win
@@ -30,7 +32,8 @@ def mac_message(on, set_at, by=None, **values):
glow_style="beam", glow_colour="ocean", effect_length="long", shortcut_arrival=False,
shortcut_arrival_style="locator")
base.update(values)
- return settings_sync.message_data(on, set_at, base, by=by or protocol.id_text(harness.B))
+ return settings_sync.message_data(on, set_at, base, by=by or protocol.id_text(harness.B),
+ groups=settings_sync.ALL_GROUPS if on else [])
@unittest.skipIf(kvm_bridge_win is None, "needs PySide6")
@@ -63,9 +66,150 @@ class SameOnBothTest(unittest.TestCase):
self.window._refresh_peers()
def test_off_by_default_with_each_page_its_own(self):
- self.assertFalse(self.window.same_switch.isChecked())
+ self.assertFalse(self.window.same_checks["everything"].isChecked())
+ self.assertEqual(set(self.window.same_checks), {"crossing", "design", "shortcut", "names", "everything"})
self.assertEqual(self.window.scope_labels["design"].text(), pages_win.SCOPE["design"])
+ def test_everything_can_be_turned_off(self):
+ self.window._set_same_groups(settings_sync.ALL_GROUPS)
+ self.window.same_checks["everything"].setChecked(False)
+
+ self.assertEqual(self.window._config.same_groups, [])
+
+ def test_an_old_peer_does_not_change_this_pcs_group_selection(self):
+ self.window._config.same_groups = ["design"]
+ message = mac_message(True, 100, resistance_px=60)
+ message.pop("groups")
+ self.window._on_settings(protocol.id_text(harness.B), message)
+
+ self.assertEqual(self.window._config.same_groups, ["design"])
+ self.assertEqual(self.window._config.crossing_resistance_px, 120)
+
+ def test_revert_restores_the_saved_values_and_announces_them(self):
+ peer = protocol.id_text(harness.B)
+ self.pair_peer(peer)
+ data = settings_sync.message_data(True, 100, {"resistance_px": 60}, by=peer,
+ groups=["crossing"])
+ self.window._on_settings(peer, data)
+ self.assertTrue(settings_sync.snapshot_available(
+ app_config.load_settings(self.path).get("same_before_sync")))
+
+ self.window._revert_same()
+
+ self.assertEqual(self.window._config.crossing_resistance_px, 120)
+ self.assertEqual(self.window._config.same_groups, ["crossing"])
+ self.assertEqual(self.sent[-1][1]["crossing"]["resistance_px"], 120)
+
+ def test_revert_clears_a_first_remote_label_with_a_new_stamp(self):
+ peer = protocol.id_text(harness.B)
+ self.pair_peer(peer)
+ data = settings_sync.message_data(True, 100, by=peer, groups=["names"], names={
+ peer: {"label": "Named here", "set_at": 100, "by": peer},
+ })
+ self.window._on_settings(peer, data)
+ self.assertEqual(app_config.load_settings(self.path)["peers"][0]["label"], "Named here")
+
+ self.window._revert_same()
+
+ restored = app_config.load_settings(self.path)["peers"][0]
+ self.assertEqual(restored["label"], "")
+ self.assertGreater(restored["label_set_at"], 100)
+
+ def test_legacy_off_state_stays_off_when_announced_to_a_group_peer(self):
+ self.window._config.same_groups = ["design"]
+ self.window._on_settings(protocol.id_text(harness.B), {"on": False, "set_at": 100,
+ "by": protocol.id_text(harness.B)})
+
+ self.assertFalse(self.window._same_state()["on"])
+ self.assertEqual(self.window._same_state()["groups"], ["design"])
+
+ def test_revert_keeps_the_current_trigger_when_a_jump_chord_now_uses_it(self):
+ peer = protocol.id_text(harness.B)
+ self.pair_peer(peer)
+ original_groups = list(self.window._config.same_groups)
+ self.window._config.trigger_key = "alt_r"
+ self.window._persist()
+ # The key changed here holds its own stamp now: only a newer choice from the peer replaces it.
+ newer = self.window._config.same_stamps["trigger_key"][0] + 1
+ data = settings_sync.message_data(True, newer, {"trigger_key": "f13"}, by=peer,
+ groups=["shortcut"])
+ self.window._on_settings(peer, data)
+ settings = app_config.load_settings(self.path)
+ settings["peers"][0]["jump_key"] = "alt+cmd+3"
+ app_config.write_settings(self.path, settings)
+ self.window._peer_entries = settings["peers"]
+
+ self.window._revert_same()
+
+ self.assertEqual(self.window._config.trigger_key, "f13")
+ self.assertEqual(self.window._config.same_groups, ["shortcut"])
+
+ def test_names_only_keeps_design_following_and_local_scope(self):
+ peer = protocol.id_text(harness.B)
+ self.pair_peer(peer)
+ self.window._config.same_on_both = True
+ self.window._config.same_groups = ["names"]
+ self.window._config.design_follow_peer = peer
+ self.window._design_states[peer] = {"set_at": 100, "by": peer, "values": {"effect_length": "long"}}
+ self.window._apply_followed_design(force=True)
+ self.window._show_same()
+ self.assertEqual(self.window._config.effect_length, "long")
+ self.assertNotIn("crossing", self.window.scope_labels)
+ row = self.window.crossing_ledger.rows[peer]
+ row.begin_rename()
+ self.assertIn("Only on this PC", row.rename_hint.text())
+ self.assertEqual(self.window.scope_labels["design"].text(), pages_win.SCOPE["design"])
+ self.assertIn("Names", self.window.same_note.text())
+
+ def test_stale_names_policy_cannot_rename_after_names_was_deselected(self):
+ peer = protocol.id_text(harness.B)
+ self.pair_peer(peer)
+ self.window._on_settings(peer, settings_sync.message_data(True, 200, by=peer, groups=["crossing"]))
+ self.window._on_settings(peer, settings_sync.message_data(True, 100, by=peer, groups=["names"],
+ names={peer: {"label": "Delayed", "set_at": 300, "by": peer}}))
+ self.assertNotEqual(app_config.load_settings(self.path)["peers"][0].get("label"), "Delayed")
+
+ def test_local_design_change_does_not_stamp_a_names_only_policy(self):
+ self.window._config.same_groups = ["names"]
+ self.window._config.same_on_both = True
+ self.window._config.same_set_at = 100
+ self.window._same_seen = self.window._same_fields()
+ self.window._config.glow_colour = "ocean"
+ self.window._persist()
+ self.assertEqual(self.window._config.same_set_at, 100)
+
+ def test_a_remote_selection_that_drops_design_resumes_the_cached_leader(self):
+ peer = protocol.id_text(harness.B)
+ self.pair_peer(peer)
+ config = self.window._config
+ config.same_on_both, config.same_groups, config.same_set_at = True, ["design"], 10
+ config.design_follow_peer = peer
+ self.window._design_states[peer] = {"set_at": 100, "by": peer, "values": {"effect_length": "long"}}
+ self.window._followed_version = (peer, 100, peer)
+ self.window._on_settings(protocol.id_text(harness.C), settings_sync.message_data(
+ True, 11, by=protocol.id_text(harness.C), groups=["names"]))
+ self.assertEqual(self.window._config.effect_length, "long")
+
+ def test_selection_only_revert_keeps_a_later_local_design_edit(self):
+ peer = protocol.id_text(harness.B)
+ self.pair_peer(peer)
+ config = self.window._config
+ config.same_on_both, config.same_groups, config.same_set_at = True, ["crossing"], 10
+ self.window._on_settings(peer, settings_sync.message_data(True, 11, by=peer, groups=["design"]))
+ self.window._config.glow_colour = "ocean"
+ self.window._revert_same()
+ self.assertEqual(self.window._config.same_groups, ["crossing"])
+ self.assertEqual(self.window._config.glow_colour, "ocean")
+ self.assertEqual(self.window.glow_colour_choice.value, "ocean")
+
+ def test_older_settings_peer_without_layout_capability_shows_group_note(self):
+ self.window._peer_caps = lambda: {harness.B: {"settings"}}
+
+ self.window._show_same()
+
+ self.assertFalse(self.window.same_old_note.isHidden())
+ self.assertTrue(self.window.same_checks["crossing"].isEnabled())
+
def test_full_screen_hold_switch_names_this_pcs_edges(self):
self.assertEqual(self.window.hold_switch.text(), "Hold this PC's edges while an app on it is full screen")
def test_this_pcs_design_state_is_announced_when_same_is_off(self):
@@ -172,6 +316,7 @@ class SameOnBothTest(unittest.TestCase):
self.pair_peer(leader)
config = self.window._config
config.same_on_both = True
+ config.same_groups = list(settings_sync.ALL_GROUPS)
config.same_set_at = 10
config.same_by = other
config.design_follow_peer = leader
@@ -193,7 +338,8 @@ class SameOnBothTest(unittest.TestCase):
def follow(self, **values):
peer = protocol.id_text(harness.B)
self.pair_peer(peer)
- for key, value in values.items():
+ # A preset set alone would lose to the held slider value when the config resolves them.
+ for key, value in settings_sync._with_continuous(values).items():
setattr(self.window._config, key, value)
self.window._config.design_follow_peer = peer
self.window._reflect_config(self.window._config)
@@ -203,7 +349,7 @@ class SameOnBothTest(unittest.TestCase):
def followed_controls(self):
w = self.window
- return [*w.length_choice._buttons.values(), *w.size_choice._buttons.values(), w.landing_toggle,
+ return [w.length_choice.view, w.size_choice.view, w.landing_toggle,
*(w.glow_style_choice.tile(value) for value in self.window.effect_stills),
*(w.switch_style_choice.tile(value) for value in self.window.switch_stills),
*w.glow_colour_choice._swatches.values()]
@@ -226,7 +372,8 @@ class SameOnBothTest(unittest.TestCase):
peer = self.follow(effect_length="long")
self.sent.clear()
- self.window.length_choice._buttons["short"].click()
+ QTest.mouseClick(self.window.length_choice.view, Qt.MouseButton.LeftButton)
+ QTest.keyClick(self.window.length_choice.view, Qt.Key.Key_Left)
self.window.landing_toggle.click()
self.assertEqual(self.window.length_choice.value, "long")
@@ -261,6 +408,7 @@ class SameOnBothTest(unittest.TestCase):
self.window._config.design_follow_peer = peer
self.window._config.same_on_both = True
self.window._config.same_set_at = 100
+ self.window._config.same_groups = list(settings_sync.ALL_GROUPS)
received = settings_sync.message_data(
True, 101, settings_sync.pc_values(self.window._config), by=peer,
design_state={"set_at": 202, "by": peer,
@@ -294,9 +442,9 @@ class SameOnBothTest(unittest.TestCase):
self.assertEqual(self.window.resistance_slider.value(), 60)
self.assertFalse(self.window.landing_toggle.isChecked())
self.window._refresh_window()
- self.assertTrue(self.window.same_switch.isChecked())
- self.assertEqual(self.window.scope_labels["crossing"].text(),
- "Resistance, drag protection and Shortcut stay in step. Ways and jump keys below are local; each side is shared with its paired machine.")
+ self.assertTrue(self.window.same_checks["crossing"].isChecked())
+ self.assertNotIn("crossing", self.window.scope_labels)
+ self.assertFalse(self.window.dragging_switch.isChecked())
# Applying what arrived is not a change made here: it goes on to the other peer and never back.
self.assertEqual([peer for peer, _data in self.sent], [harness.C])
@@ -313,18 +461,18 @@ class SameOnBothTest(unittest.TestCase):
def test_a_peer_without_the_settings_capability_is_sent_none(self):
self.peers[harness.C] = set()
- self.window.same_switch.setChecked(True)
+ self.window.same_checks["everything"].setChecked(True)
self.assertEqual([peer for peer, _data in self.sent], [harness.B])
def test_turning_it_on_here_sends_this_pcs_values_to_every_peer_that_takes_them(self):
- self.window.same_switch.setChecked(True)
+ self.window.same_checks["everything"].setChecked(True)
self.assertEqual([peer for peer, _data in self.sent], [harness.B, harness.C])
data = self.sent[0][1]
self.assertTrue(data["on"])
self.assertIs(data["crossing"]["shortcut"], True)
def test_a_change_here_while_on_is_stamped_and_sent_and_one_to_this_pcs_own_is_not(self):
- self.window.same_switch.setChecked(True)
+ self.window.same_checks["everything"].setChecked(True)
stamp = self.window._config.same_set_at
self.sent.clear()
self.window._config.same_set_at = stamp - 10
@@ -332,12 +480,79 @@ class SameOnBothTest(unittest.TestCase):
self.window._persist()
self.assertEqual(self.sent, [])
self.window._config.effect_length = "short"
+ self.window._config.effect_pace = 0.5
self.window._persist()
self.assertEqual(len(self.sent), 2)
self.assertGreaterEqual(self.window._config.same_set_at, stamp)
self.assertEqual(self.window._config.same_by, self.window._config.machine_id)
self.assertEqual(self.sent[0][1]["design"]["effect_length"], "short")
+ # Per-key stamps (rc14, 10-10-2026): an edit carries only what a person changed.
+ def test_a_change_here_stamps_only_that_value_and_the_state_carries_each_stamp(self):
+ config = self.window._config
+ seed = [config.same_set_at, config.same_by]
+ self.window.same_checks["everything"].setChecked(True)
+ self.sent.clear()
+ self.window._config.crossing_resistance_px = 60
+ self.window._persist()
+ config = self.window._config
+ stamps = config.same_stamps
+ self.assertEqual(stamps["resistance_px"][1], config.machine_id)
+ self.assertEqual({key for key, stamp in stamps.items() if list(stamp) != seed}, {"resistance_px"},
+ "turning it on froze every other value at the stamp it held")
+ self.assertEqual(app_config.load_settings(self.path)["same_stamps"]["resistance_px"],
+ list(stamps["resistance_px"]))
+ sent = self.sent[0][1]
+ self.assertEqual(sent["stamps"]["resistance_px"], list(stamps["resistance_px"]))
+ self.assertEqual(sent["stamps"]["glow_colour"], seed)
+ self.assertGreaterEqual(sent["set_at"], stamps["resistance_px"][0])
+ self.assertEqual(self.window._same_state()["stamps"], sent["stamps"])
+
+ def test_a_newer_value_in_an_older_state_is_taken_alone_and_a_newer_one_here_is_answered(self):
+ self.window.same_checks["everything"].setChecked(True)
+ self.window._config.crossing_resistance_px = 60
+ self.window._persist()
+ config = self.window._config
+ policy = (config.same_set_at, config.same_by)
+ mine = config.same_stamps["resistance_px"][0]
+ self.sent.clear()
+ peer = protocol.id_text(harness.B)
+ stamps = settings_sync.held_stamps({"glow_colour": [5, peer], "resistance_px": [4, peer]}, 0, "")
+ data = settings_sync.message_data(True, policy[0] - 1, dict(
+ resistance_px=30, glow_colour="ocean", trigger_key="alt_r"), by=peer,
+ groups=settings_sync.ALL_GROUPS, stamps=stamps)
+ self.window._on_settings(peer, data)
+ config = self.window._config
+ self.assertEqual((config.glow_colour, config.crossing_resistance_px), ("ocean", 60))
+ self.assertNotEqual(config.trigger_key, "alt_r")
+ self.assertEqual((config.same_set_at, config.same_by), policy)
+ self.assertEqual(config.same_stamps["glow_colour"], [5, peer])
+ forwarded = [sent for to, sent in self.sent if to == harness.C and sent["by"] == peer]
+ self.assertEqual([sent["stamps"] for sent in forwarded], [data["stamps"]], "what it took goes on as it came")
+ answers = [sent for to, sent in self.sent if to == harness.B]
+ self.assertEqual(len(answers), 1)
+ self.assertEqual(answers[0]["stamps"]["resistance_px"], [mine, config.machine_id])
+
+ def test_a_value_changed_here_while_off_outlives_an_older_state_turning_it_on(self):
+ self.window._config.crossing_resistance_px = 60
+ self.window._persist()
+ self.assertEqual(self.sent, [])
+ config = self.window._config
+ mine = config.same_stamps["resistance_px"]
+ self.assertEqual(mine[1], config.machine_id)
+ peer = protocol.id_text(harness.B)
+ self.window._on_settings(peer, mac_message(True, mine[0] - 1, resistance_px=30))
+ config = self.window._config
+ self.assertTrue(config.same_on_both)
+ self.assertEqual((config.crossing_resistance_px, config.glow_colour), (60, "ocean"))
+ answer = [sent for to, sent in self.sent if to == harness.B][-1]
+ # The value travels with its own stamp, newer than the state it comes in.
+ self.assertEqual(answer["stamps"]["resistance_px"], mine)
+ held = settings_sync.held_stamps({}, mine[0] - 1, peer)
+ back = settings_sync.merge(answer, held, mine[0] - 1, kvm_bridge_win.TRIGGER_KEYS, by_here=peer,
+ on_here=True, current_groups=settings_sync.ALL_GROUPS)
+ self.assertEqual(back["values"], {"resistance_px": 60})
+
def test_a_save_after_a_link_replaced_the_first_peer_does_not_bring_the_old_pairing_back(self):
# A fold removed the entry migrated from 1.4.x; the window still holds its token.
settings = app_config.load_settings(self.path)
@@ -345,6 +560,7 @@ class SameOnBothTest(unittest.TestCase):
settings["zones"] = []
app_config.write_settings(self.path, settings)
self.window._config.effect_length = "short"
+ self.window._config.effect_pace = 0.5
self.assertTrue(self.window._persist())
saved = app_config.load_settings(self.path)
self.assertEqual([peer["token"] for peer in saved["peers"]], [harness.TOKENS[harness.B]])
@@ -363,6 +579,7 @@ class SameOnBothTest(unittest.TestCase):
def test_a_design_change_here_while_off_announces_its_local_state(self):
self.window._config.effect_length = "short"
+ self.window._config.effect_pace = 0.5
self.window._persist()
self.assertEqual(len(self.sent), 2)
self.assertTrue(all(message["design_sync"]["values"]["effect_length"] == "short"
@@ -376,8 +593,8 @@ class SameOnBothTest(unittest.TestCase):
app_config.write_settings(self.path, settings)
self.peers = {harness.B: {"settings"}}
messages = self.window._announce(harness.B)
- self.assertEqual([m["type"] for m in messages], ["paired", "settings"])
- self.assertEqual(messages[0]["data"]["ids"], [])
+ self.assertEqual([m["type"] for m in messages], ["arrangement", "paired", "settings"])
+ self.assertEqual(messages[1]["data"]["ids"], [])
settings["peers"][0].update(side="left", side_set_at=500, side_by=self.window._config.machine_id)
app_config.write_settings(self.path, settings)
messages = self.window._announce(harness.B)
@@ -385,6 +602,20 @@ class SameOnBothTest(unittest.TestCase):
self.assertEqual(messages[0]["data"]["edge"], "left")
self.assertEqual(messages[0]["data"]["set_at"], 500)
+ def test_a_followed_design_is_not_stamped_as_this_pcs_choice(self):
+ # The Mac's follow path stamps nothing; stamped here, a copied design beat a real choice.
+ peer = protocol.id_text(harness.B)
+ self.pair_peer(peer)
+ config = self.window._config
+ config.same_on_both, config.same_groups, config.same_set_at = True, ["crossing"], 10
+ self.window._same_seen = self.window._same_fields()
+ config.design_follow_peer = peer
+ self.window._design_states[peer] = {"set_at": 100, "by": peer, "values": {"glow_colour": "ocean"}}
+ self.window._apply_followed_design(force=True)
+ self.assertEqual(self.window._config.glow_colour, "ocean")
+ stamp = settings_sync.held_stamps(config.same_stamps, config.same_set_at, config.same_by)["glow_colour"]
+ self.assertNotEqual(stamp[1], config.machine_id, "the followed colour was stamped as chosen here")
+
if __name__ == "__main__":
unittest.main()
diff --git a/win_app/tests/test_settings_behaviour.py b/win_app/tests/test_settings_behaviour.py
index edb2b0c..381f5da 100644
--- a/win_app/tests/test_settings_behaviour.py
+++ b/win_app/tests/test_settings_behaviour.py
@@ -1,10 +1,7 @@
"""Windows settings decisions with in-memory configuration and no Qt window."""
from core.tests.settings_behaviour import SettingsBehaviourTests as _SettingsBehaviourTests
-from core.tests.app_methods import load_methods
-from core import settings_sync, peerlist
from types import SimpleNamespace
-from unittest import TestCase
class WindowsSettingsBehaviourTests(_SettingsBehaviourTests):
@@ -16,38 +13,3 @@ class WindowsSettingsBehaviourTests(_SettingsBehaviourTests):
del _SettingsBehaviourTests
-
-
-class SameCompatibilityTests(TestCase):
- def test_old_peer_status_disables_same_but_an_unobserved_peer_does_not(self):
- namespace = dict(settings_sync=settings_sync, peerlist=peerlist,
- widgets=SimpleNamespace(set_role=lambda note, role: setattr(note, "role", role)))
- cls = load_methods("win_app/kvm_bridge_win.py", "WindowsApplication", ["_show_same"], namespace)
- for capabilities, enabled, checked, old in (({}, True, True, False),
- ({"new": {"settings"}}, True, True, False),
- ({"old": set()}, False, False, True),
- ({"new": {"settings"}, "old": set()}, False, False, True)):
- with self.subTest(capabilities=capabilities):
- app = cls()
- app._config = SimpleNamespace(same_on_both=True)
- app._paired = True
- app._peer_caps = lambda: capabilities
- switch = SimpleNamespace(checked=True, enabled=True, blockSignals=lambda on: None)
- switch.isChecked = lambda: switch.checked
- switch.setChecked = lambda on: setattr(switch, "checked", on)
- switch.setEnabled = lambda on: setattr(switch, "enabled", on)
- app.same_switch = switch
- app.same_note = SimpleNamespace(
- setText=lambda text: setattr(app.same_note, "text", text),
- setToolTip=lambda text: setattr(app.same_note, "tool_tip", text),
- )
- app._peer_entries = [{"token": "desktop", "name": "Desktop", "port": 24820}]
- app._shown = lambda text: text
- app.scope_labels = {}
- app.own_notes = []
- app._refresh_design_follow = lambda: None
- app._show_same()
- self.assertEqual(switch.enabled, enabled)
- self.assertEqual(switch.checked, checked)
- self.assertEqual("too old" in app.same_note.text, old)
- self.assertEqual(app.same_note.role, "note-amber" if old else "note")
diff --git a/win_app/tests/test_settings_layout_acceptance.py b/win_app/tests/test_settings_layout_acceptance.py
index 28a7c1a..356b66b 100644
--- a/win_app/tests/test_settings_layout_acceptance.py
+++ b/win_app/tests/test_settings_layout_acceptance.py
@@ -9,6 +9,7 @@ import subprocess
import sys
import tempfile
import unittest
+from unittest import mock
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path
@@ -144,7 +145,7 @@ class SettingsLayoutAcceptance(unittest.TestCase):
def setUp(self):
self.assertTrue(self.effective_font.family().lower().startswith("hanken"),
f"tests must use the bundled Hanken Grotesk font, got {self.effective_font.family()!r}")
- scratch = ROOT / "renders" / "test-working"
+ scratch = ROOT / "win_app" / ".test-tmp"
scratch.mkdir(parents=True, exist_ok=True)
self.folder = tempfile.TemporaryDirectory(prefix="beamer-layout-acceptance-", dir=scratch)
folder = Path(self.folder.name)
@@ -180,6 +181,10 @@ class SettingsLayoutAcceptance(unittest.TestCase):
self.settle()
return self.window.stack.currentWidget()
+ def test_trayless_window_exposes_quit_button_and_control_q(self):
+ self.assertEqual(self.window.quit_shortcut.key().toString(), "Ctrl+Q")
+ self.assertTrue(self.window.quit_button.isVisible())
+
def test_window_accepts_320_dip_minimum_at_every_matrix_cell(self):
width = int(os.environ.get("BEAMER_LAYOUT_WIDTH", "320"))
self.set_size(width, 300)
@@ -245,7 +250,22 @@ class SettingsLayoutAcceptance(unittest.TestCase):
continue
with self.subTest(width=width, page=key, button=text):
self.assertTrue(self.paints_on_one_line(button), "the label wraps or clips inside its button")
- self.assertGreaterEqual(button.height(), 30)
+ self.assertGreaterEqual(button.height(), 24 if button.property("ledger_quiet") else 30)
+
+ def test_send_destination_refits_when_the_column_shrinks_and_grows(self):
+ full_text = "Send input to Synthetic workstation with a long machine name"
+ with mock.patch.object(self.window, "_redirect_text", return_value=full_text):
+ self.window._refresh_window()
+ self.page_scroll("overview")
+ labels = []
+ for width in (320, 1100, 320):
+ self.set_size(width)
+ button = self.window.redirect_button
+ self.assertTrue(self.paints_on_one_line(button))
+ self.assertEqual(button.toolTip(), full_text)
+ labels.append(button.text())
+ self.assertGreater(len(labels[1]), len(labels[0]))
+ self.assertEqual(labels[2], labels[0])
def test_no_wrapping_label_is_a_horizontally_aligned_layout_item(self):
# An aligned layout item gets its size hint's width, about 20 average characters for a
@@ -296,8 +316,10 @@ class SettingsLayoutAcceptance(unittest.TestCase):
f"{key} document width {page.width()} exceeds viewport {scroll.viewport().width()}")
def test_form_labels_keep_a_180_dip_track_without_wrapping_in_normal_windows(self):
- self.assertEqual(self.window.edge_heading.text(), "Where the other machine is")
- self.assertIn("Synthetic workstation", self.window.edge_heading.accessibleName())
+ first = self.window._peer_entries[0]["id"]
+ self.assertIn("Synthetic workstation", self.window.crossing_ledger.rows[first].name.full_text)
+ self.assertEqual(self.window.crossing_ledger.accessibleName(), "How each machine is reached")
+ self.assertEqual(self.window.atlas_canvas.accessibleName(), "Crossing layout")
self.set_size(int(os.environ.get("BEAMER_LAYOUT_WIDTH", "900")))
for key in PAGE_KEYS:
scroll = self.page_scroll(key)
@@ -398,8 +420,8 @@ class SettingsLayoutAcceptance(unittest.TestCase):
self.set_size(int(os.environ.get("BEAMER_LAYOUT_WIDTH", "900")))
self.page_scroll("design")
capped = {
- "Length": (self.window.length_choice.view, self.window.length_choice.view.cap),
- "Size": (self.window.size_choice.view, self.window.size_choice.view.cap),
+ "Length": (self.window.length_choice.view, 240),
+ "Size": (self.window.size_choice.view, 240),
"Style for": (self.window.design_mode_choice.view, self.window.design_mode_choice.view.cap),
"Show at": (self.window.effect_method_choice.view, self.window.effect_method_choice.view.cap),
"Match design with": (self.window.design_follow_choice, 320),
@@ -408,12 +430,15 @@ class SettingsLayoutAcceptance(unittest.TestCase):
with self.subTest(control=label):
self.assertLessEqual(control.width(), maximum,
f"{label} is {control.width()} DIP; cap is {maximum}")
- for control_name in ("length_choice", "size_choice", "design_mode_choice", "effect_method_choice"):
+ for control_name in ("design_mode_choice", "effect_method_choice"):
choice = getattr(self.window, control_name)
for value, button in choice._buttons.items():
with self.subTest(choice=control_name, option=value):
self.assertLessEqual(button.width(), choice.view.cell_width(),
f"{control_name}.{value} segment exceeds its measured label width")
+ for control in (self.window.length_choice.view, self.window.size_choice.view):
+ self.assertLessEqual(control.width(), control.parentWidget().width())
+ self.assertGreaterEqual(control.width(), control.minimumSizeHint().width())
self.assertLessEqual(self.window.design_follow_choice.width(), 320)
def test_effect_preview_cache_uses_ceil_logical_size_at_effective_dpr(self):
@@ -505,7 +530,7 @@ class SettingsLayoutAcceptance(unittest.TestCase):
if __name__ == "__main__":
if len(sys.argv) == 2 and sys.argv[1] == "--matrix":
- log_root = ROOT / "renders" / "acceptance-matrix"
+ log_root = ROOT / "win_app" / "renders" / "acceptance-matrix"
log_root.mkdir(parents=True, exist_ok=True)
def run_cell(cell):
diff --git a/win_app/tests/test_settings_migration.py b/win_app/tests/test_settings_migration.py
index 22a3c72..d38be1b 100644
--- a/win_app/tests/test_settings_migration.py
+++ b/win_app/tests/test_settings_migration.py
@@ -19,6 +19,7 @@ sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(
import app_config
from app_config import ConfigError
+from core import ways
FIXTURES = Path(__file__).resolve().parent / "fixtures"
@@ -73,6 +74,12 @@ class Folder(unittest.TestCase):
def put(self, settings):
self.path.write_text(json.dumps(settings, indent=2) + "\n", encoding="utf-8")
+ def learned(self):
+ settings = app_config.load_settings(self.path)
+ app_config.learn_peer_id(settings, 0, PEER_ID)
+ self.put(settings)
+ return app_config.load_settings(self.path)
+
class MigrationTests(Folder):
def test_the_paths_are_settings_json_and_the_old_file_beside_it(self):
@@ -88,7 +95,10 @@ class MigrationTests(Folder):
self.assertIs(settings["shortcut"], True)
self.assertEqual(settings["migrated_token_sha256"], hashlib.sha256(PAIRED.encode()).hexdigest())
self.assertEqual(len(settings["peers"]), 1)
- self.assertEqual(settings["peers"][0], {**MIGRATED_PEER, "token": PAIRED, "side_by": settings["machine_id"]})
+ expected_peer = {**MIGRATED_PEER, "token": PAIRED, "side_by": settings["machine_id"]}
+ self.assertEqual({k: settings["peers"][0][k] for k in expected_peer}, expected_peer)
+ self.assertEqual(settings["peers"][0]["ways"],
+ dict(edge=True, thirds=list(ways.PARTS), corner=True, corner_at="top_right", notch=False))
for key in MOVED_OR_DROPPED:
self.assertNotIn(key, settings)
for key, value in LEGACY.items():
@@ -356,11 +366,11 @@ class ReadingAnOddFileTests(Folder):
settings = app_config.load_settings(self.path)
settings["later"] = {"a": 1}
settings["peers"][0]["later"] = 2
- settings["zones"][0]["later"] = 3
+ settings["peers"][0]["ways"] = {"edge": False, "thirds": ["middle"], "later": 3}
self.put(settings)
app_config.save_config(self.path, replace(app_config.load_config(self.path), pointer_speed=2.0))
again = self.settings()
- self.assertEqual((again["later"], again["peers"][0]["later"], again["zones"][0]["later"]), ({"a": 1}, 2, 3))
+ self.assertEqual((again["later"], again["peers"][0]["later"], again["peers"][0]["ways"]["later"]), ({"a": 1}, 2, 3))
def test_the_machine_name_is_saved(self):
app_config.load_settings(self.path)
@@ -369,98 +379,107 @@ class ReadingAnOddFileTests(Folder):
class OverlapTests(Folder):
- """Two zones in use never cover one stretch (WIRE.md section 8), as on the Mac; a corner inside an edge is fine."""
-
- def refused(self, change):
- settings = app_config.load_settings(self.path)
- change(settings)
+ """Legacy overlaps become intent and one canonical allocation when the file is loaded."""
+
+ def recompile(self, zones, extra=False):
+ settings = self.learned()
+ settings["peers"][0].pop("ways", None)
+ if extra:
+ settings["peers"].append({**settings["peers"][0], "id": OTHER_ID, "token": OTHER,
+ "from_1_4": False})
+ settings["zones"] = [{"peer": PEER_ID, **zone} for zone in zones]
self.put(settings)
- raw = self.path.read_bytes()
- with self.assertRaises(app_config.SettingsFileError):
- app_config.load_config(self.path)
- with self.assertRaises(app_config.SettingsFileError):
- app_config.save_config(self.path, replace(app_config.default_config(), auth_token=PAIRED))
- self.assertEqual(self.path.read_bytes(), raw)
+ return app_config.load_settings(self.path)
- def zone(self, settings, kind):
- return next(zone for zone in settings["zones"] if zone["kind"] == kind)
+ def test_legacy_whole_edge_takes_precedence_over_active_or_off_thirds(self):
+ for off in (False, True):
+ with self.subTest(part_off=off):
+ self.path.unlink(missing_ok=True)
+ saved = self.recompile([{"kind": "edge"}, {"kind": "part", "parts": ["middle"], "off": off}])
+ self.assertEqual(saved["zones"], [{"peer": PEER_ID, "kind": "edge"}])
+ self.assertEqual(saved["peers"][0]["ways"]["thirds"], list(ways.PARTS))
+ self.assertEqual(self.settings()["peers"][0]["ways"]["thirds"], list(ways.PARTS))
+
+ def test_an_off_legacy_edge_does_not_override_active_thirds(self):
+ for mark in ("off", "page_off"):
+ with self.subTest(mark=mark):
+ self.path.unlink(missing_ok=True)
+ saved = self.recompile([{"kind": "edge", mark: True},
+ {"kind": "part", "parts": ["middle"]}])
+ self.assertEqual(saved["peers"][0]["ways"]["thirds"], ["middle"])
- def test_the_edge_and_its_thirds_in_use_together_are_refused(self):
- self.refused(lambda s: self.zone(s, "part").pop("off", None) or self.zone(s, "edge").pop("off", None))
+ def test_incomplete_legacy_zones_still_normalise_without_a_key_error(self):
+ saved = self.recompile([{}, {"kind": "edge"}])
+ self.assertEqual(saved["zones"], [{"peer": PEER_ID, "kind": "edge"}])
- def test_two_part_zones_sharing_a_third_are_refused_and_disjoint_ones_are_not(self):
- def two_parts(s, second):
- self.zone(s, "edge")["off"] = True
- self.zone(s, "part").pop("off", None)
- self.zone(s, "part")["parts"] = ["start"]
- s["zones"].append({"peer": "", "kind": "part", "parts": second})
- self.refused(lambda s: two_parts(s, ["start", "end"]))
- self.path.unlink()
- settings = app_config.load_settings(self.path)
- two_parts(settings, ["end"])
- self.put(settings)
- app_config.load_config(self.path)
+ def test_overlapping_and_disjoint_legacy_parts_compile_to_their_union(self):
+ for second in (["start", "end"], ["end"]):
+ self.path.unlink(missing_ok=True)
+ saved = self.recompile([{"kind": "part", "parts": ["start"]},
+ {"kind": "part", "parts": second}])
+ self.assertEqual(saved["zones"], [{"peer": PEER_ID, "kind": "part", "parts": ["start", "end"]}])
def test_zones_turned_off_cover_nothing(self):
- settings = app_config.load_settings(self.path)
- settings["zones"].append({"peer": "", "kind": "edge", "off": True})
- self.put(settings)
- app_config.load_config(self.path)
+ saved = self.recompile([{"kind": "edge", "off": True}])
+ self.assertEqual(saved["zones"], [])
+ self.assertFalse(saved["peers"][0]["ways"]["edge"])
- def test_two_peers_whose_edges_face_the_same_side_cannot_both_have_the_edge_zone_on(self):
- def second_peer(s):
- s["peers"][0]["id"] = PEER_ID
- s["zones"] = [{**zone, "peer": PEER_ID} for zone in s["zones"]]
- self.zone(s, "edge").pop("off", None)
- self.zone(s, "part")["off"] = True
- s["peers"].append({**s["peers"][0], "id": OTHER_ID, "token": OTHER, "from_1_4": False})
- s["zones"].append({"peer": OTHER_ID, "kind": "edge"})
- self.refused(second_peer)
-
- def test_a_corner_inside_the_edge_is_fine_and_two_of_one_corner_are_not(self):
- settings = app_config.load_settings(self.path)
- self.zone(settings, "edge").pop("off", None)
- self.zone(settings, "corner").pop("off", None)
- self.put(settings)
- app_config.load_config(self.path)
- self.refused(lambda s: s["zones"].append({**self.zone(s, "corner")}))
+ def test_legacy_shared_side_compiles_only_one_allocation_and_keeps_both_intents(self):
+ saved = self.recompile([{"kind": "edge"}, {"peer": OTHER_ID, "kind": "edge"}], extra=True)
+ self.assertEqual(saved["zones"], [{"peer": PEER_ID, "kind": "edge"}])
+ self.assertTrue(saved["peers"][1]["ways"]["edge"])
+
+ def test_legacy_duplicate_corners_compile_once_alongside_the_edge(self):
+ saved = self.recompile([{"kind": "edge"}, {"kind": "corner", "corner": "top_left"},
+ {"kind": "corner", "corner": "top_left"}])
+ self.assertEqual([zone["kind"] for zone in saved["zones"]], ["edge", "corner"])
class ZonesFromMethodsTests(Folder):
def migrated(self, **fields):
self.path.unlink(missing_ok=True)
self.write_legacy({**LEGACY, **fields})
+ settings = app_config.migrate({**LEGACY, **fields})
+ app_config.learn_peer_id(settings, 0, PEER_ID)
+ settings["peers"][0]["caps"] = []
+ app_config.write_settings(self.path, settings)
return app_config.load_settings(self.path)
- def test_every_combination_of_methods_gives_its_zones_and_off_flags(self):
+ def test_legacy_method_combinations_become_intent_and_active_canonical_zones(self):
for count in range(5):
for methods in itertools.combinations(app_config.METHODS, count):
with self.subTest(methods=methods):
settings = self.migrated(crossing_methods=list(methods), crossing_corner="top_left",
crossing_edge_parts=["middle", "end"], mac_return_edge="left")
self.assertIs(settings["shortcut"], "shortcut" in methods)
- self.assertEqual([zone["kind"] for zone in settings["zones"]], ["edge", "part", "corner"])
- # The whole edge covers its thirds, so with both on the thirds stand down (WIRE.md section 8).
- in_use = [m for m in methods if not (m == "part" and "edge" in methods)]
+ expected = (["edge"] if "edge" in methods else ["part"] if "part" in methods else [])
+ expected += ["corner"] if "corner" in methods else []
+ self.assertEqual([zone["kind"] for zone in settings["zones"]], expected)
for zone in settings["zones"]:
- self.assertEqual(zone["peer"], "")
- self.assertEqual(zone.get("off", False), zone["kind"] not in in_use, zone)
- self.assertEqual(settings["zones"][1]["parts"], ["middle", "end"])
- self.assertEqual(settings["zones"][2]["corner"], "top_left")
-
- def test_a_corner_crosses_the_side_as_1_4_x_did_whichever_edges_it_touches(self):
- # 1.4.x built the PC's corner push with the return edge (sender.py: CornerPush(corner, self._edge)).
- for corner, side in (("top_left", "left"), ("top_left", "top"), ("bottom_right", "bottom"),
- ("top_right", "left"), ("bottom_left", "right"), ("top_left", "bottom"),
- ("bottom_right", "top")):
+ self.assertEqual(zone["peer"], PEER_ID)
+ self.assertNotIn("off", zone)
+ intent = settings["peers"][0]["ways"]
+ self.assertEqual(intent["thirds"], list(ways.PARTS) if "edge" in methods else ["middle", "end"])
+ self.assertEqual(intent["corner_at"], "top_left")
+
+ def test_a_corner_crosses_the_side_when_it_touches_it_and_its_own_horizontal_edge_otherwise(self):
+ # 1.4.x built the PC's corner push with the return edge (sender.py: CornerPush(corner, self._edge)),
+ # but a corner push only arms through one of its own two edges (receiver.zone_models): one held
+ # along an edge it does not touch would pin the pointer to that edge. So a corner away from the
+ # side crosses by its own horizontal edge, as the Mac's does (core.ways.corner_edge, 10-10-2026).
+ for corner, side, edge in (("top_left", "left", "left"), ("top_left", "top", "top"),
+ ("bottom_right", "bottom", "bottom"), ("top_right", "left", "right"),
+ ("bottom_left", "right", "left"), ("top_left", "bottom", "left"),
+ ("bottom_right", "top", "right")):
with self.subTest(corner=corner, side=side):
settings = self.migrated(crossing_corner=corner, mac_return_edge=side)
- self.assertEqual(settings["zones"][2]["edge"], side)
+ self.assertEqual(next(z for z in settings["zones"] if z["kind"] == "corner")["edge"], edge)
def test_a_corner_with_no_side_yet_crosses_its_own_left_or_right_edge(self):
for corner, edge in (("top_left", "left"), ("bottom_right", "right")):
with self.subTest(corner=corner):
- self.assertEqual(self.migrated(crossing_corner=corner, mac_return_edge="")["zones"][2]["edge"], edge)
+ saved = self.migrated(crossing_corner=corner, mac_return_edge="")
+ self.assertEqual(next(z for z in saved["zones"] if z["kind"] == "corner")["edge"], edge)
def test_there_is_no_notch_zone_on_windows(self):
self.assertNotIn("notch", [zone["kind"] for zone in self.migrated()["zones"]])
@@ -470,7 +489,8 @@ class ConfigViewTests(Folder):
def test_the_app_sees_the_same_config_as_before_but_for_what_the_spec_drops(self):
config = app_config.load_config(self.path)
expected = app_config.config_from_dict(dict(LEGACY))
- skipped = {"host", "mac_resistance_px", "machine_id", "name"}
+ skipped = {"host", "mac_resistance_px", "machine_id", "name", "crossing_methods",
+ "crossing_edge_parts", "crossing_corner", "layout", "layout_set_at", "layout_by"}
self.assertEqual({k: v for k, v in asdict(config).items() if k not in skipped},
{k: v for k, v in asdict(expected).items() if k not in skipped})
@@ -533,12 +553,15 @@ class SavingTests(Folder):
self.assertIs(settings["shortcut"], False)
self.assertEqual(settings["zones"], before)
- def test_turning_a_way_off_keeps_its_zone_and_its_setting(self):
- app_config.set_ways(self.path, "", methods=["edge"], parts=["start", "end"], corner="top_right")
- app_config.set_ways(self.path, "", methods=["part"], parts=["start", "end"], corner="top_right")
+ def test_turning_ways_off_removes_zones_and_keeps_choices_for_turning_on(self):
+ self.learned()
+ app_config.set_ways(self.path, PEER_ID, methods=["part", "corner"], parts=["start", "end"], corner="top_right")
+ app_config.set_ways(self.path, PEER_ID, methods=[], parts=["start", "end"], corner="top_right")
settings = self.settings()
- self.assertEqual([(zone["kind"], zone.get("off", False)) for zone in settings["zones"]],
- [("edge", True), ("part", False), ("corner", True)])
+ self.assertEqual(settings["zones"], [])
+ self.assertEqual(settings["peers"][0]["ways"]["thirds"], ["start", "end"])
+ self.assertEqual(settings["peers"][0]["ways"]["corner_at"], "top_right")
+ app_config.set_ways(self.path, PEER_ID, methods=["part"], parts=["start", "end"], corner="top_right")
again = app_config.load_config(self.path)
self.assertEqual((again.crossing_methods, again.crossing_edge_parts), (["part", "shortcut"], ["start", "end"]))
@@ -557,16 +580,16 @@ class SavingTests(Folder):
self.assertNotIn("host", settings)
self.assertNotIn("mac_resistance_px", settings)
- def test_a_side_is_stamped_by_this_machine_only_when_set_here_never_by_a_save(self):
- settings = self.settings()
+ def test_way_edits_and_flat_saves_keep_the_held_side_and_author(self):
+ settings = self.learned()
settings["peers"][0]["side_by"] = OTHER_ID
self.put(settings)
app_config.save_config(self.path, replace(self.config, pointer_speed=2.0, mac_return_edge="top",
arrangement_set_at=1790000005))
self.assertEqual((self.settings()["peers"][0]["side"], self.settings()["peers"][0]["side_by"]), ("left", OTHER_ID))
- app_config.set_ways(self.path, "", side="top", methods=["edge"], parts=["middle"], corner="top_left")
+ app_config.set_ways(self.path, PEER_ID, side="top", methods=["edge"], parts=["middle"], corner="top_left")
self.assertEqual((self.settings()["peers"][0]["side"], self.settings()["peers"][0]["side_by"]),
- ("top", settings["machine_id"]))
+ ("left", OTHER_ID))
def test_a_changed_port_moves_this_machines_and_the_one_peers_together(self):
app_config.save_config(self.path, replace(self.config, port=25000))
@@ -580,7 +603,7 @@ class SavingTests(Folder):
app_config.save_config(self.path, replace(app_config.load_config(self.path), pointer_speed=2.0))
self.assertEqual(self.settings()["peers"][0]["port"], 24900)
- def test_a_new_pairing_replaces_the_first_peer_and_points_its_zones_at_the_empty_id(self):
+ def test_a_new_pairing_waits_for_a_learned_id_before_compiling_zones(self):
settings = self.settings()
app_config.learn_peer_id(settings, 0, PEER_ID)
self.put(settings)
@@ -589,7 +612,7 @@ class SavingTests(Folder):
peer = self.settings()["peers"][0]
self.assertEqual((peer["token"], peer["name"], peer["host"], peer["id"]), (OTHER, "Other", "192.0.2.30", ""))
self.assertEqual((peer["linked"], peer["from_1_4"], peer["paired_at"], peer["paired_with"]), (False, True, 0, []))
- self.assertEqual({zone["peer"] for zone in self.settings()["zones"]}, {""})
+ self.assertEqual(self.settings()["zones"], [])
def test_other_peers_and_their_zones_survive_every_save(self):
settings = self.settings()
@@ -602,7 +625,7 @@ class SavingTests(Folder):
app_config.save_config(self.path, replace(config, crossing_methods=[], glow_style="glow"))
app_config.save_config(self.path, replace(config, auth_token=OTHER))
after = self.settings()
- self.assertEqual(after["peers"][1], extra)
+ self.assertEqual({k: after["peers"][1][k] for k in extra}, extra)
self.assertIn({"peer": OTHER_ID, "kind": "edge"}, after["zones"])
self.assertEqual(len(after["peers"]), 2)
@@ -620,8 +643,10 @@ class LearningTheIdTests(Folder):
super().setUp()
self.settings_ = app_config.load_settings(self.path)
- def test_the_first_link_fills_the_id_in_and_rewrites_the_zones(self):
+ def test_the_first_link_learns_the_id_and_next_load_compiles_its_zones(self):
app_config.learn_peer_id(self.settings_, 0, PEER_ID)
+ self.put(self.settings_)
+ self.settings_ = app_config.load_settings(self.path)
self.assertEqual(self.settings_["peers"][0]["id"], PEER_ID)
self.assertEqual({zone["peer"] for zone in self.settings_["zones"]}, {PEER_ID})
@@ -629,7 +654,7 @@ class LearningTheIdTests(Folder):
self.settings_["peers"].append({**MIGRATED_PEER, "id": OTHER_ID, "from_1_4": False, "token": THIRD})
self.settings_["zones"].append({"peer": OTHER_ID, "kind": "edge"})
app_config.learn_peer_id(self.settings_, 0, PEER_ID)
- self.assertEqual([zone["peer"] for zone in self.settings_["zones"]], [PEER_ID] * 3 + [OTHER_ID])
+ self.assertEqual([zone["peer"] for zone in self.settings_["zones"]], [OTHER_ID])
def test_it_refuses_this_machines_own_id_a_duplicate_a_bad_one_and_an_entry_that_has_one(self):
self.settings_["peers"].append({**MIGRATED_PEER, "id": OTHER_ID, "from_1_4": False, "token": THIRD})
@@ -656,7 +681,7 @@ class PairingAgainUnder1_4Tests(Folder):
peer = again["peers"][0]
self.assertEqual((peer["token"], peer["name"], peer["host"]), (OTHER, "Studio", "192.0.2.40"))
self.assertEqual((peer["id"], peer["linked"], peer["paired_with"], peer["from_1_4"]), ("", False, [], True))
- self.assertEqual({zone["peer"] for zone in again["zones"]}, {""})
+ self.assertEqual(again["zones"], [])
self.assertEqual(again["migrated_token_sha256"], hashlib.sha256(OTHER.encode()).hexdigest())
self.assertEqual(again["machine_id"], settings["machine_id"])
self.assertEqual(self.settings(), again)
@@ -677,7 +702,7 @@ class PairingAgainUnder1_4Tests(Folder):
self.write_legacy({**LEGACY, "auth_token": OTHER})
again = self.start()
self.assertEqual([peer["token"] for peer in again["peers"]], [OTHER, THIRD])
- self.assertEqual(again["peers"][1], extra)
+ self.assertEqual({k: again["peers"][1][k] for k in extra}, extra)
self.assertIn({"peer": OTHER_ID, "kind": "edge"}, again["zones"])
def test_a_peer_the_user_removed_stays_removed_while_the_old_file_is_unchanged(self):
@@ -694,8 +719,7 @@ class PairingAgainUnder1_4Tests(Folder):
self.write_legacy({**LEGACY, "auth_token": OTHER})
again = self.start()
self.assertEqual([peer["token"] for peer in again["peers"]], [OTHER])
- self.assertEqual([zone["kind"] for zone in again["zones"]], ["edge", "part", "corner"])
- self.assertEqual({zone["peer"] for zone in again["zones"]}, {""})
+ self.assertEqual(again["zones"], [])
def test_a_token_whose_key_id_is_another_entrys_is_not_migrated_but_the_hash_moves_on(self):
settings = self.start()
diff --git a/win_app/tests/test_sidebar_lifecycle.py b/win_app/tests/test_sidebar_lifecycle.py
new file mode 100644
index 0000000..8862095
--- /dev/null
+++ b/win_app/tests/test_sidebar_lifecycle.py
@@ -0,0 +1,152 @@
+"""Application-wide sidebar hooks stay cheap and end with their owning window."""
+
+import statistics
+import sys
+import time
+import unittest
+from pathlib import Path
+from unittest.mock import patch
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from PySide6.QtCore import QCoreApplication, QEvent, QPointF, QRect, Qt
+from PySide6.QtGui import QMouseEvent, QPaintEvent
+from PySide6.QtWidgets import QApplication, QVBoxLayout, QWidget
+from shiboken6 import getCppPointer, isValid
+
+import theme
+import widgets
+
+
+def window_with_sidebar(sidebar_type=widgets.Sidebar):
+ window = QWidget()
+ layout = QVBoxLayout(window)
+ sidebar = sidebar_type([("overview", "Overview", ""), ("crossing", "Crossing", "")],
+ lambda _key: None, parent=window)
+ layout.addWidget(sidebar)
+ sidebar.select("overview")
+ return window, sidebar
+
+
+class SidebarLifecycleTests(unittest.TestCase):
+ def setUp(self):
+ self.app = QApplication.instance() or QApplication([])
+ theme.init_fonts()
+ widgets.keyboard_navigation()
+ QCoreApplication.sendPostedEvents(None, QEvent.Type.DeferredDelete)
+
+ def tearDown(self):
+ QCoreApplication.sendPostedEvents(None, QEvent.Type.DeferredDelete)
+
+ def test_destroyed_sidebars_leave_no_application_hooks(self):
+ app = self.app
+ removed = []
+ original_remove = app.removeEventFilter
+
+ def remove(filter_object):
+ removed.append(getCppPointer(filter_object)[0])
+ original_remove(filter_object)
+
+ errors = []
+
+ class TrackedSidebar(widgets.Sidebar):
+ def __init__(self, *args, **kwargs):
+ self.presses = 0
+ self.focus_changes = 0
+ super().__init__(*args, **kwargs)
+
+ def eventFilter(self, watched, event):
+ if event.type() == QEvent.Type.MouseButtonPress:
+ self.presses += 1
+ return super().eventFilter(watched, event)
+
+ def _focus_changed(self, old, new):
+ self.focus_changes += 1
+ super()._focus_changed(old, new)
+
+ with patch.object(app, "removeEventFilter", remove), patch.object(sys, "excepthook", lambda *_error: errors.append(_error)):
+ destroyed = []
+ for _ in range(2):
+ window, sidebar = window_with_sidebar(TrackedSidebar)
+ pointer = getCppPointer(sidebar)[0]
+ window.deleteLater()
+ QCoreApplication.sendPostedEvents(None, QEvent.Type.DeferredDelete)
+ self.assertFalse(isValid(window))
+ self.assertFalse(isValid(sidebar))
+ self.assertIn(pointer, removed)
+ destroyed.append((sidebar, sidebar.presses, sidebar.focus_changes))
+
+ window, sidebar = window_with_sidebar(TrackedSidebar)
+ try:
+ mouse = QMouseEvent(QEvent.Type.MouseButtonPress, QPointF(1, 1), QPointF(1, 1),
+ Qt.MouseButton.LeftButton, Qt.MouseButton.LeftButton,
+ Qt.KeyboardModifier.NoModifier)
+ QCoreApplication.postEvent(window, mouse)
+ QCoreApplication.sendPostedEvents(window, QEvent.Type.MouseButtonPress)
+ app.focusChanged.emit(None, sidebar._buttons["overview"])
+ self.assertEqual(sidebar.presses, 1)
+ self.assertGreaterEqual(sidebar.focus_changes, 1)
+ self.assertEqual([(old.presses, old.focus_changes) for old, _, _ in destroyed],
+ [(presses, changes) for _, presses, changes in destroyed])
+ self.assertEqual(errors, [])
+ finally:
+ window.deleteLater()
+ QCoreApplication.sendPostedEvents(None, QEvent.Type.DeferredDelete)
+
+ def test_ring_update_skips_a_deleted_page_button(self):
+ window, sidebar = window_with_sidebar()
+ try:
+ button = sidebar._buttons["crossing"]
+ button.deleteLater()
+ QCoreApplication.sendPostedEvents(None, QEvent.Type.DeferredDelete)
+ self.assertFalse(isValid(button))
+ sidebar._update_rings()
+ finally:
+ window.deleteLater()
+ QCoreApplication.sendPostedEvents(None, QEvent.Type.DeferredDelete)
+
+ def test_irrelevant_events_never_inspect_the_watched_window(self):
+ class Watched:
+ def window(self):
+ raise AssertionError("An irrelevant event must not inspect its widget")
+
+ window, sidebar = window_with_sidebar()
+ recorder = widgets.InputRecorder("Right Ctrl", lambda *_args: None, lambda *_args: 0)
+ jump = widgets.JumpKeyRecorder(lambda *_args: None)
+ recorder.armed = jump.armed = True
+ try:
+ for kind in (QEvent.Type.Paint, QEvent.Type.Polish, QEvent.Type.StyleChange,
+ QEvent.Type.LayoutRequest):
+ for filter_object in (sidebar, widgets.keyboard_navigation(), recorder, jump):
+ self.assertIs(filter_object.eventFilter(Watched(), QEvent(kind)), False)
+ finally:
+ recorder.armed = jump.armed = False
+ recorder.deleteLater()
+ jump.deleteLater()
+ window.deleteLater()
+ QCoreApplication.sendPostedEvents(None, QEvent.Type.DeferredDelete)
+
+ def test_sidebar_paint_filter_cost_stays_within_three_times_baseline(self):
+ plain = QWidget()
+ event = QPaintEvent(QRect(0, 0, 1, 1))
+
+ def duration():
+ start = time.perf_counter()
+ for _ in range(2000):
+ QApplication.sendEvent(plain, event)
+ return time.perf_counter() - start
+
+ try:
+ duration()
+ baseline = statistics.median(duration() for _ in range(5))
+ window, sidebar = window_with_sidebar()
+ try:
+ duration()
+ with_sidebar = statistics.median(duration() for _ in range(5))
+ self.assertLess(with_sidebar, baseline * 3, (baseline, with_sidebar))
+ finally:
+ window.deleteLater()
+ QCoreApplication.sendPostedEvents(None, QEvent.Type.DeferredDelete)
+ finally:
+ plain.deleteLater()
+ QCoreApplication.sendPostedEvents(None, QEvent.Type.DeferredDelete)
diff --git a/win_app/tests/test_single_instance.py b/win_app/tests/test_single_instance.py
new file mode 100644
index 0000000..793330c
--- /dev/null
+++ b/win_app/tests/test_single_instance.py
@@ -0,0 +1,222 @@
+import os
+from pathlib import Path
+import subprocess
+import sys
+import time
+import unittest
+from unittest import mock
+
+from PySide6.QtCore import QEvent, Qt
+from PySide6.QtGui import QKeyEvent
+from PySide6.QtWidgets import QApplication, QSystemTrayIcon, QWidget
+
+import kvm_bridge_win
+
+
+class SingleInstanceTests(unittest.TestCase):
+ @classmethod
+ def setUpClass(cls):
+ cls.app = QApplication.instance() or QApplication([])
+
+ def test_hidden_second_launch_does_not_raise_the_existing_window(self):
+ with mock.patch.object(kvm_bridge_win, "send_instance_activation") as activate:
+ self.assertFalse(kvm_bridge_win.activate_existing_instance(hidden=True))
+ activate.assert_not_called()
+
+ @unittest.skipUnless(sys.platform == 'win32', 'Windows receiver mutex')
+ def test_two_logon_tasks_cannot_claim_two_receivers(self):
+ import ctypes
+ import uuid
+
+ name = 'Local\\Beamer.Autostart.Test.' + uuid.uuid4().hex
+ kernel32 = kvm_bridge_win._windows_kernel32()
+ create_mutex = kernel32.CreateMutexW
+
+ def isolated_mutex(attributes, owner, _name):
+ return create_mutex(attributes, owner, name)
+
+ with mock.patch.object(kernel32, 'CreateMutexW', side_effect=isolated_mutex), \
+ mock.patch.object(kvm_bridge_win, '_windows_kernel32', return_value=kernel32):
+ release = kvm_bridge_win._claim_instance()
+ self.assertIsNotNone(release)
+ self.addCleanup(release)
+ code = (
+ 'import ctypes, sys, kvm_bridge_win\n'
+ 'kernel32 = kvm_bridge_win._windows_kernel32()\n'
+ 'create_mutex = kernel32.CreateMutexW\n'
+ 'kernel32.CreateMutexW = lambda a, o, n: create_mutex(a, o, sys.argv[1])\n'
+ 'kvm_bridge_win._windows_kernel32 = lambda: kernel32\n'
+ 'release = kvm_bridge_win._claim_instance()\n'
+ 'if release is not None: release()\n'
+ 'sys.exit(0 if release is None else 1)\n'
+ )
+ result = subprocess.run([sys.executable, '-c', code, name], timeout=30,
+ capture_output=True, text=True)
+ self.assertEqual(result.returncode, 0, result.stderr)
+
+ def test_visible_second_launch_still_raises_the_existing_window(self):
+ with mock.patch.object(kvm_bridge_win, "send_instance_activation", return_value=True) as activate:
+ self.assertTrue(kvm_bridge_win.activate_existing_instance(hidden=False))
+ activate.assert_called_once()
+
+ def test_startup_migrates_the_legacy_task_before_single_instance_handling(self):
+ order = []
+ with mock.patch.object(kvm_bridge_win, "parse_args", return_value=type("Args", (), {"hidden": True})()), \
+ mock.patch.object(kvm_bridge_win, "prepare_windows_startup", side_effect=lambda: order.append("migrate")), \
+ mock.patch.object(kvm_bridge_win, "_claim_instance", side_effect=lambda: order.append("claim") or None), \
+ mock.patch.object(kvm_bridge_win, "activate_existing_instance") as activate:
+ kvm_bridge_win.main()
+ self.assertEqual(order, ["migrate", "claim"])
+ activate.assert_called_once_with(True, mock.ANY)
+
+ def test_failed_migration_still_reaches_instance_handling(self):
+ with mock.patch.object(kvm_bridge_win, "parse_args", return_value=type("Args", (), {"hidden": True})()), \
+ mock.patch.object(kvm_bridge_win, "prepare_windows_startup", side_effect=OSError("Access is denied")), \
+ mock.patch.object(kvm_bridge_win, "_claim_instance", return_value=None) as claim, \
+ mock.patch.object(kvm_bridge_win, "activate_existing_instance"), \
+ self.assertLogs(kvm_bridge_win.LOGGER, level="ERROR"):
+ kvm_bridge_win.main()
+ claim.assert_called_once()
+
+ def test_second_launch_signals_the_running_instance_with_activation_token(self):
+ name = str(Path(__file__).resolve().parents[1] / f"s{os.getpid()}")
+ received = []
+ server = kvm_bridge_win.InstanceSignal(lambda token: received.append(token), name=name)
+ try:
+ self.assertTrue(server.listening)
+ # A second launch is another process, and a client in this one cannot finish its write
+ # to a Windows named pipe while the server waits on this thread's event loop.
+ code = (
+ "import sys\n"
+ "from PySide6.QtCore import QCoreApplication\n"
+ "app = QCoreApplication([])\n"
+ "import kvm_bridge_win\n"
+ "ok = kvm_bridge_win.send_instance_activation(sys.argv[1], 'gnome-token', timeout_ms=3000)\n"
+ "sys.exit(0 if ok else 1)\n"
+ )
+ client = subprocess.Popen(
+ [sys.executable, "-c", code, name], cwd=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+ )
+ try:
+ deadline = time.monotonic() + 30
+ while client.poll() is None and time.monotonic() < deadline:
+ self.app.processEvents()
+ time.sleep(0.01)
+ self.assertEqual(client.poll(), 0)
+ finally:
+ if client.poll() is None:
+ client.kill()
+ client.wait()
+ deadline = time.monotonic() + 1
+ while not received and time.monotonic() < deadline:
+ self.app.processEvents()
+ time.sleep(0.01)
+ self.assertEqual(received, ["gnome-token"])
+ finally:
+ server.close()
+
+ def test_closing_without_a_tray_quits_instead_of_hiding(self):
+ class Window(QWidget):
+ closeEvent = kvm_bridge_win.WindowsApplication.closeEvent
+
+ def __init__(self):
+ super().__init__()
+ self._closing = False
+ self.tray = mock.Mock()
+ self.tray.isVisible.return_value = False
+ self.quits = 0
+
+ def quit(self):
+ self.quits += 1
+
+ window = Window()
+ with mock.patch.object(QSystemTrayIcon, "isSystemTrayAvailable", return_value=True):
+ window.close()
+ self.assertEqual(window.quits, 1)
+
+ def test_closing_with_a_tray_hides_instead_of_quitting(self):
+ class Window(QWidget):
+ closeEvent = kvm_bridge_win.WindowsApplication.closeEvent
+
+ def __init__(self):
+ super().__init__()
+ self._closing = False
+ self.tray = mock.Mock()
+ self.tray.isVisible.return_value = True
+ self.quits = 0
+
+ def quit(self):
+ self.quits += 1
+
+ window = Window()
+ window.show()
+ with mock.patch.object(QSystemTrayIcon, "isSystemTrayAvailable", return_value=True):
+ window.close()
+ self.assertFalse(window.isVisible())
+ self.assertEqual(window.quits, 0)
+
+ def test_closing_after_the_tray_disappears_quits(self):
+ class Window(QWidget):
+ closeEvent = kvm_bridge_win.WindowsApplication.closeEvent
+
+ def __init__(self):
+ super().__init__()
+ self._closing = False
+ self.tray = mock.Mock()
+ self.tray.isVisible.return_value = True
+ self.quits = 0
+
+ def quit(self):
+ self.quits += 1
+
+ window = Window()
+ with mock.patch.object(QSystemTrayIcon, "isSystemTrayAvailable", return_value=False):
+ window.close()
+ self.assertEqual(window.quits, 1)
+
+ def test_escape_quits_when_no_tray_icon_is_visible(self):
+ class Window(QWidget):
+ keyPressEvent = kvm_bridge_win.WindowsApplication.keyPressEvent
+
+ def __init__(self):
+ super().__init__()
+ self.tray = mock.Mock()
+ self.tray.isVisible.return_value = False
+ self.quits = 0
+
+ def quit(self):
+ self.quits += 1
+
+ window = Window()
+ event = QKeyEvent(QEvent.Type.KeyPress, Qt.Key.Key_Escape, Qt.KeyboardModifier.NoModifier)
+ with mock.patch.object(QSystemTrayIcon, "isSystemTrayAvailable", return_value=True):
+ window.keyPressEvent(event)
+ self.assertEqual(window.quits, 1)
+
+ def test_wayland_activation_token_is_removed_after_the_activation_request(self):
+ class Window:
+ show_window = kvm_bridge_win.WindowsApplication.show_window
+
+ def __init__(self):
+ self.calls = []
+
+ def showNormal(self):
+ self.calls.append("show")
+
+ def raise_(self):
+ self.calls.append("raise")
+
+ def activateWindow(self):
+ self.calls.append(("activate", os.environ.get("XDG_ACTIVATION_TOKEN")))
+
+ with mock.patch.object(sys, "platform", "linux"), \
+ mock.patch.object(kvm_bridge_win.platform_parts, "WAYLAND", True), \
+ mock.patch.dict(os.environ, {}, clear=True):
+ window = Window()
+ window.show_window("one-shot-token")
+ self.assertEqual(window.calls, ["show", "raise", ("activate", "one-shot-token")])
+ self.assertNotIn("XDG_ACTIVATION_TOKEN", os.environ)
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/win_app/tests/test_style_for.py b/win_app/tests/test_style_for.py
index badc93e..85a82f6 100644
--- a/win_app/tests/test_style_for.py
+++ b/win_app/tests/test_style_for.py
@@ -26,7 +26,7 @@ class StyleForTest(unittest.TestCase):
self.app = QApplication.instance() or QApplication([])
theme.init_fonts()
self.app.setFont(theme.font(theme.TYPE["body"]))
- scratch = Path(__file__).resolve().parents[2] / "renders" / "test-working"
+ scratch = Path(__file__).resolve().parents[1] / "renders" / "test-working"
scratch.mkdir(parents=True, exist_ok=True)
self.folder = tempfile.TemporaryDirectory(dir=scratch)
folder = Path(self.folder.name)
diff --git a/win_app/tests/test_style_tiles.py b/win_app/tests/test_style_tiles.py
new file mode 100644
index 0000000..6b1448b
--- /dev/null
+++ b/win_app/tests/test_style_tiles.py
@@ -0,0 +1,188 @@
+import math
+import os
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+from unittest import mock
+
+os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+sys.path.insert(1, str(Path(__file__).resolve().parents[2]))
+
+from PySide6.QtCore import QCoreApplication, QEvent, QPoint
+from PySide6.QtGui import QColor, QImage
+from PySide6.QtWidgets import QApplication
+
+from core import effects
+import theme
+import widgets
+from test_settings_layout_acceptance import SyntheticWindow, responder_harness, write_synthetic_settings
+from tools.render_colour_choices import QtRenderer, relative_luminance, style_cases
+
+
+def card_metrics(renderer, family, style):
+ """(contrast, coverage) of a tile's picture against the card it is drawn on: the contrast the
+ strongest tenth of its effect pixels reach, and the share of the picture changed by effect marks.
+ The baseline uses the same scene, screens, seam and pointer, with only its pens removed."""
+ import effect_previews
+
+ preview_id = style if family == "crossing" else f"switch:{style}"
+ image = renderer.preview(preview_id, "signal")
+ draw_scene = effect_previews.paint_scene
+
+ def without_effects(painter, rect, view, scene, pointer_size, labels):
+ return draw_scene(painter, rect, view, dict(scene, pens=[]), pointer_size, labels)
+
+ with mock.patch.object(effect_previews, "paint_scene", side_effect=without_effects):
+ baseline = renderer.preview(preview_id, "signal")
+ image = image.convertToFormat(QImage.Format.Format_RGBA8888)
+ baseline = baseline.convertToFormat(QImage.Format.Format_RGBA8888)
+ ground = QColor(theme.colour("ground")).getRgb()[:3]
+ ratios = []
+ for y in range(image.height()):
+ for x in range(image.width()):
+ rgb = image.pixelColor(x, y).getRgb()[:3]
+ base = baseline.pixelColor(x, y).getRgb()[:3]
+ if max(abs(a - b) for a, b in zip(rgb, base)) > 3:
+ lum = relative_luminance(rgb)
+ ground_lum = relative_luminance(ground)
+ ratios.append((max(lum, ground_lum) + .05) / (min(lum, ground_lum) + .05))
+ ratios.sort()
+ contrast = ratios[min(len(ratios) - 1, math.ceil(.9 * len(ratios)) - 1)] if ratios else 1.0
+ return contrast, len(ratios) / max(1, image.width() * image.height())
+
+
+class StyleTileTests(unittest.TestCase):
+ @classmethod
+ def setUpClass(cls):
+ cls.app = QApplication.instance() or QApplication([])
+ theme.init_fonts()
+ cls.app.setFont(theme.font(theme.TYPE["body"]))
+ cls.folder = tempfile.TemporaryDirectory()
+ with mock.patch.object(responder_harness, "free_port", return_value=24820):
+ cls.window = SyntheticWindow(write_synthetic_settings(Path(cls.folder.name)))
+ cls.window.full_screen_timer.stop()
+ cls.window.refresh_timer.stop()
+ cls.window._select_page("design")
+ cls.window.show()
+ cls.choice = cls.window.glow_style_choice
+ cls.settle()
+
+ @classmethod
+ def tearDownClass(cls):
+ cls.window.server.stop()
+ cls.window.close()
+ cls.window.deleteLater()
+ cls.app.processEvents()
+ cls.folder.cleanup()
+
+ @classmethod
+ def settle(cls):
+ for _ in range(8):
+ QCoreApplication.sendPostedEvents(None, QEvent.Type.DeferredDelete)
+ QCoreApplication.sendPostedEvents(None, QEvent.Type.LayoutRequest)
+ cls.app.processEvents()
+
+ @classmethod
+ def capture_tile(cls, tile):
+ image = cls.window.grab().toImage()
+ scale = image.devicePixelRatio()
+ point = tile.mapTo(cls.window, QPoint())
+ crop = image.copy(round(point.x() * scale), round(point.y() * scale),
+ round(tile.width() * scale), round(tile.height() * scale))
+ crop.setDevicePixelRatio(scale)
+ return crop
+
+ def test_still_time_is_inside_the_loop_and_deterministic(self):
+ first = effects.still_time("beam", "edge")
+ self.assertGreaterEqual(first, 0)
+ self.assertLess(first, effects.PREVIEW_LOOP_S)
+ self.assertEqual(first, effects.still_time("beam", "edge"))
+ switch = effects.still_time("aperture", "switch")
+ self.assertGreaterEqual(switch, 0)
+ self.assertLess(switch, effects.SWITCH_LOOP_S)
+ self.assertEqual(switch, effects.still_time("aperture", "switch"))
+
+ def test_custom_pace_and_size_keep_the_still_inside_its_view(self):
+ pace, size_fraction = 0.25, 0.08
+ cases = ((effects.preview_effect("skin"), "edge"),
+ (effects.switch_effect("aperture", "beam"), "switch"))
+ for fx, place in cases:
+ with self.subTest(effect=fx.id, place=place):
+ at = effects.still_time(fx, place, "large", pace, size_fraction)
+ view = effects.still_view(fx, place, "large", pace, size_fraction)
+ scene = effects.preview_still_scene(fx, at, place, ("#ffffff",), dark=True, pace=pace,
+ effect_size="large", effect_size_fraction=size_fraction,
+ live=True, view_width=view[2])
+ self.assertTrue(any(
+ min(box[2], view[0] + view[2]) > max(box[0], view[0])
+ and min(box[3], view[1] + view[3]) > max(box[1], view[1])
+ for box, _alpha in effects._op_boxes(scene)))
+
+ def test_real_tile_previews_reach_contrast_and_coverage_in_both_appearances_and_scales(self):
+ previous = theme.is_dark()
+ try:
+ for dark in (True, False):
+ theme.set_dark(dark)
+ for scale in (1, 2):
+ renderer = QtRenderer(scale)
+ renderer.set_dark(dark)
+ for family, style in style_cases():
+ contrast, coverage = card_metrics(renderer, family, style)
+ with self.subTest(family=family, style=style, dark=dark, scale=scale):
+ self.assertGreaterEqual(contrast, 3.0)
+ # The baseline removes screen outlines and the pointer before coverage is measured.
+ self.assertGreaterEqual(coverage, .01)
+ finally:
+ theme.set_dark(previous)
+
+ def test_selected_tile_has_a_badge_before_its_name_without_a_wash_or_picture_overlap(self):
+ previous = theme.is_dark()
+ tile = self.choice.tile("beam")
+ try:
+ for dark in (True, False):
+ theme.set_dark(dark)
+ self.app.setStyleSheet(theme.stylesheet())
+ self.choice.set_value("glow")
+ self.settle()
+ # The tile itself, not the window: at the window's opening size the page scrolls
+ # the caption row out of view.
+ rest = tile.grab().toImage()
+ self.choice.set_value("beam")
+ self.settle()
+ chosen = tile.grab().toImage()
+ scale = chosen.devicePixelRatio()
+ signal = QColor(theme.colour("signal")).getRgb()[:3]
+
+ def distance(image, x, y):
+ return sum(abs(a - b) for a, b in zip(image.pixelColor(x, y).getRgb()[:3], signal))
+
+ card = (chosen.width() // 2, round(5 * scale))
+ name = tile.name_label.geometry()
+ check = [(x, y) for x in range(round(name.x() * scale), round((name.x() + 14) * scale))
+ for y in range(round(name.y() * scale), round(name.bottom() * scale))]
+ inked = [point for point in check if distance(chosen, *point) < 60]
+ preview = tile.layout().itemAt(0).widget().geometry()
+ match = self.window.switch_style_choice.tile("match")
+ match_detail = match.detail_label.text()
+ with self.subTest(dark=dark):
+ self.assertEqual(chosen.pixelColor(*card), rest.pixelColor(*card), "selection washes the card")
+ self.assertGreaterEqual(len(inked), 100 * scale * scale, "no filled badge before the name")
+ self.assertGreater(min(y for _x, y in inked) / scale, preview.bottom(),
+ "the badge reaches into the picture")
+ self.assertEqual(tile.name_label.indent(), widgets._TileOutline.CHECK_ROOM)
+ self.assertTrue(match_detail.startswith("Plays "))
+ self.window.glow_style_choice.set_value("beam")
+ self.window._apply_look()
+ self.settle()
+ self.assertEqual(match.detail_label.text(), "Plays Beam")
+ self.window.glow_style_choice.set_value("glow")
+ self.window._apply_look()
+ self.settle()
+ finally:
+ theme.set_dark(previous)
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/win_app/tests/test_ui_geometry.py b/win_app/tests/test_ui_geometry.py
index ee778eb..5cd9b49 100644
--- a/win_app/tests/test_ui_geometry.py
+++ b/win_app/tests/test_ui_geometry.py
@@ -63,9 +63,10 @@ class AuditGeometryTests(unittest.TestCase):
self.assertFalse(measure(module), measure(module))
def peer(self):
- row = machines_win.PeerRow("synthetic", *([lambda *_: None] * 4))
- row.refresh({"port": 24820}, "Studio MacBook Pro with an exceptionally long mach",
- SimpleNamespace(tone="off", word="Waiting", detail="Waiting for this machine."), "Mac")
+ row = machines_win.PeerRow("synthetic", *([lambda *_: None] * 5))
+ row.refresh({"port": 24820}, "Studio MacBook Pro with an exceptionally long mach",
+ SimpleNamespace(tone="off", word="Waiting", detail="Waiting for this machine."), "Mac",
+ cycle_mode="last")
return row
def test_direction_switches_have_separate_uncropped_tracks(self):
diff --git a/win_app/tests/test_upgrade_autostart.py b/win_app/tests/test_upgrade_autostart.py
new file mode 100644
index 0000000..c1cad8e
--- /dev/null
+++ b/win_app/tests/test_upgrade_autostart.py
@@ -0,0 +1,166 @@
+"""The existing 1.5.1 global task must not silently lose its owner's enabled choice."""
+
+import unittest
+import subprocess
+import xml.etree.ElementTree as ET
+from unittest.mock import patch
+
+import autostart_win
+from test_autostart_win import FakeSchtasks, EXE
+
+USER = r"SYNTHETIC\birch"
+
+
+class UpgradeTasks(FakeSchtasks):
+ def __init__(self, exists=True, enabled=True, owner=USER, fail=None):
+ super().__init__(exists, fail)
+ self.enabled = enabled
+ self.owner = owner
+ self.replacement_xml = None
+ self.arguments = '--hidden'
+ self.fail_delete = False
+
+ def __call__(self, args):
+ if args[1] == '/delete' and self.fail_delete:
+ self.calls.append('/delete')
+ return subprocess.CompletedProcess(args, 1, '', 'Access is denied')
+ if args[1] == '/change' and '/disable' in args:
+ self.enabled = False
+ result = super().__call__(args)
+ if args[1] == "/query" and result.returncode == 0:
+ xml = autostart_win.task_xml(EXE, self.owner)
+ if args[args.index("/tn") + 1] == "Beamer":
+ xml = xml.replace('--hidden', self.arguments)
+ if not self.enabled:
+ xml = xml.replace("<Enabled>true</Enabled>", "<Enabled>false</Enabled>")
+ else:
+ xml = self.xml or self.replacement_xml or xml
+ return subprocess.CompletedProcess(args, 0, xml, "")
+ return result
+
+
+class UpgradeAutostartTests(unittest.TestCase):
+ def setUp(self):
+ for name, value in (("installed_exe", EXE), ("can_run_for_current_user", True)):
+ patcher = patch.object(autostart_win, name, return_value=value)
+ patcher.start()
+ self.addCleanup(patcher.stop)
+
+ def test_enabled_1_5_1_task_stays_enabled_after_first_1_5_2_status_read(self):
+ tasks = UpgradeTasks()
+ self.assertTrue(autostart_win.is_enabled(tasks, USER))
+ self.assertEqual(tasks.tasks, {autostart_win.task_name(USER)})
+ self.assertLess(tasks.calls.index('/create'), tasks.calls.index('/delete'))
+
+ def test_was_off_stays_off(self):
+ for exists in (False, True):
+ tasks = UpgradeTasks(exists=exists, enabled=False)
+ self.assertFalse(autostart_win.is_enabled(tasks, USER))
+ self.assertNotIn('/create', tasks.calls)
+
+ def test_second_run_changes_nothing(self):
+ tasks = UpgradeTasks()
+ autostart_win.is_enabled(tasks, USER)
+ tasks.calls.clear()
+ self.assertTrue(autostart_win.is_enabled(tasks, USER))
+ self.assertEqual(tasks.calls, ['/query', '/query'])
+
+ def test_failed_registration_keeps_old_starter(self):
+ tasks = UpgradeTasks(fail='Access is denied')
+ with self.assertRaises(OSError):
+ autostart_win.is_enabled(tasks, USER)
+ self.assertEqual(tasks.tasks, {'Beamer'})
+ self.assertNotIn('/delete', tasks.calls)
+
+ def test_other_accounts_task_is_not_migrated(self):
+ tasks = UpgradeTasks(owner=r'SYNTHETIC\other')
+ self.assertFalse(autostart_win.is_enabled(tasks, USER))
+ self.assertEqual(tasks.tasks, {'Beamer'})
+
+ def test_unresolvable_account_is_not_migrated(self):
+ tasks = UpgradeTasks(owner='S-1-5-21-unknown')
+ with patch.object(autostart_win, '_user_sid', side_effect=OSError('no mapping')):
+ self.assertFalse(autostart_win.is_enabled(tasks, USER))
+ self.assertEqual(tasks.tasks, {'Beamer'})
+
+ def test_sid_principal_is_migrated_for_its_owner(self):
+ tasks = UpgradeTasks(owner='S-1-5-21-123-456-789-1001')
+ with patch.object(autostart_win, '_user_sid', return_value=tasks.owner):
+ self.assertTrue(autostart_win.is_enabled(tasks, USER))
+ self.assertEqual(tasks.tasks, {autostart_win.task_name(USER)})
+
+ def test_existing_per_user_task_is_not_registered_again(self):
+ tasks = UpgradeTasks()
+ tasks.tasks.add(autostart_win.task_name(USER))
+ self.assertTrue(autostart_win.is_enabled(tasks, USER))
+ self.assertNotIn('/create', tasks.calls)
+ self.assertNotIn('Beamer', tasks.tasks)
+
+ def test_broken_replacement_is_repaired_before_legacy_deletion(self):
+ valid = autostart_win.task_xml(EXE, USER)
+ for broken in (
+ valid.replace(
+ '<ExecutionTimeLimit>PT0S</ExecutionTimeLimit>\n <Enabled>true</Enabled>',
+ '<ExecutionTimeLimit>PT0S</ExecutionTimeLimit>\n <Enabled>false</Enabled>'),
+ valid.replace(EXE, r'C:\Missing\Beamer.exe'),
+ valid.replace('<LogonTrigger>\n <Enabled>true</Enabled>', '<LogonTrigger>\n <Enabled>false</Enabled>'),
+ valid.replace('<LogonTrigger>', '<TimeTrigger>').replace('</LogonTrigger>', '</TimeTrigger>'),
+ ):
+ with self.subTest(xml=broken):
+ tasks = UpgradeTasks()
+ tasks.tasks.add(autostart_win.task_name(USER))
+ tasks.replacement_xml = broken
+ self.assertTrue(autostart_win.is_enabled(tasks, USER))
+ self.assertIn('/create', tasks.calls)
+ self.assertLess(tasks.calls.index('/create'), tasks.calls.index('/delete'))
+ self.assertEqual(tasks.tasks, {autostart_win.task_name(USER)})
+
+ def test_failed_replacement_repair_keeps_legacy_starter(self):
+ tasks = UpgradeTasks(fail='Access is denied')
+ tasks.tasks.add(autostart_win.task_name(USER))
+ tasks.replacement_xml = autostart_win.task_xml(r'C:\Missing\Beamer.exe', USER)
+ with self.assertRaises(OSError):
+ autostart_win.is_enabled(tasks, USER)
+ self.assertIn('Beamer', tasks.tasks)
+ self.assertNotIn('/delete', tasks.calls)
+
+ def test_migration_preserves_legacy_config_arguments(self):
+ tasks = UpgradeTasks()
+ tasks.arguments = '--hidden --config "C:\\User Data\\a &amp; b.json"'
+ self.assertTrue(autostart_win.is_enabled(tasks, USER))
+ root = ET.fromstring(tasks.xml)
+ self.assertEqual(root.findtext('{*}Actions/{*}Exec/{*}Arguments'),
+ '--hidden --config "C:\\User Data\\a & b.json"')
+
+ def test_existing_replacement_keeps_legacy_config_arguments(self):
+ tasks = UpgradeTasks()
+ tasks.tasks.add(autostart_win.task_name(USER))
+ tasks.arguments = '--hidden --config "C:\\User Data\\custom.json"'
+ self.assertTrue(autostart_win.is_enabled(tasks, USER))
+ self.assertIsNotNone(tasks.xml)
+ root = ET.fromstring(tasks.xml)
+ self.assertEqual(root.findtext('{*}Actions/{*}Exec/{*}Arguments'),
+ '--hidden --config "C:\\User Data\\custom.json"')
+
+ def test_failed_legacy_delete_leaves_one_enabled_starter_and_retries(self):
+ tasks = UpgradeTasks()
+ tasks.fail_delete = True
+ with self.assertRaises(OSError):
+ autostart_win.is_enabled(tasks, USER)
+ self.assertEqual(tasks.tasks, {'Beamer', autostart_win.task_name(USER)})
+ self.assertFalse(tasks.enabled)
+ tasks.fail_delete = False
+ tasks.calls.clear()
+ self.assertTrue(autostart_win.is_enabled(tasks, USER))
+ self.assertEqual(tasks.tasks, {autostart_win.task_name(USER)})
+ self.assertNotIn('/create', tasks.calls)
+
+ def test_wrong_executable_leaves_legacy_task_untouched(self):
+ tasks = UpgradeTasks()
+ with patch.object(autostart_win, 'installed_exe', return_value=r'C:\Other\Beamer.exe'):
+ self.assertFalse(autostart_win.is_enabled(tasks, USER))
+ self.assertEqual(tasks.tasks, {'Beamer'})
+
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/win_app/tests/test_wide_layout.py b/win_app/tests/test_wide_layout.py
index b6459c6..3fe3476 100644
--- a/win_app/tests/test_wide_layout.py
+++ b/win_app/tests/test_wide_layout.py
@@ -60,7 +60,7 @@ class WindowsPageWidthTest(unittest.TestCase):
self.app = QApplication.instance() or QApplication([])
theme.init_fonts()
self.app.setFont(theme.font(theme.TYPE["body"]))
- scratch = Path(__file__).resolve().parents[2] / "renders" / "test-working"
+ scratch = Path(__file__).resolve().parents[1] / "renders" / "test-working"
scratch.mkdir(parents=True, exist_ok=True)
directory = tempfile.TemporaryDirectory(dir=scratch)
self.addCleanup(directory.cleanup)
@@ -109,30 +109,24 @@ class WindowsPageWidthTest(unittest.TestCase):
self.assertAlmostEqual(section.width(), column.width(), delta=1)
self.assertLessEqual(page.width(), scroll.viewport().width() + 1)
- def test_the_crossing_diagram_sits_beside_its_ways_once_the_column_holds_both(self):
- # Both blocks at their minimums, with the gap, must fit before they sit beside each other.
+ def test_the_atlas_canvas_fills_the_crossing_column_at_wide_sizes(self):
for (width, height) in ((1366, 900), (1920, 1000), (2560, 1440), (1440, 3440)):
with self.subTest(window=(width, height)):
self.window.resize(width, height)
self.window.show()
self.column_width("crossing")
- pair = self.window.ways_pair
- self.assertGreaterEqual(pair.width(), pair.needed())
- self.assertTrue(pair.beside())
- self.assertEqual(pair.first.y(), pair.second.y())
- self.assertLess(pair.first.x(), pair.second.x())
- self.assertIs(pair.first.parentWidget(), pair)
- self.assertIs(pair.second.parentWidget(), pair)
- self.assertTrue(pair.first.isVisible() and pair.second.isVisible())
-
- def test_the_crossing_pair_stacks_below_the_width_both_need(self):
+ canvas = self.window.atlas_canvas
+ self.assertGreater(canvas.width(), 0)
+ self.assertLessEqual(canvas.width(), self.window.ways_module.width())
+ self.assertGreater(canvas.height(), 0)
+
+ def test_the_atlas_canvas_stays_inside_the_crossing_column_on_a_narrow_window(self):
self.window.resize(320, 900)
self.window.show()
self.column_width("crossing")
- pair = self.window.ways_pair
- self.assertLess(pair.width(), pair.needed())
- self.assertFalse(pair.beside())
- self.assertLess(pair.first.y(), pair.second.y())
+ canvas = self.window.atlas_canvas
+ self.assertGreater(canvas.width(), 0)
+ self.assertLessEqual(canvas.width(), self.window.ways_module.width())
def test_style_families_form_horizontal_equal_tile_rows_at_each_breakpoint(self):
for width in self.WIDTHS:
diff --git a/win_app/tests/test_x11_seams.py b/win_app/tests/test_x11_seams.py
new file mode 100644
index 0000000..6e51f4b
--- /dev/null
+++ b/win_app/tests/test_x11_seams.py
@@ -0,0 +1,100 @@
+"""Internal X11 seam geometry and pressure without requiring an X server."""
+
+import struct
+import sys
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+sys.path.append(str(Path(__file__).resolve().parent.parent.parent))
+
+import x11_seams # noqa: E402
+from core.return_edge import Rect # noqa: E402
+
+
+class FakeBackend:
+ def __init__(self):
+ self.created = []
+ self.destroyed = []
+ self.released = []
+
+ def create_barrier(self, seam):
+ self.created.append(seam)
+ return len(self.created) + 100
+
+ def destroy_barrier(self, barrier):
+ self.destroyed.append(barrier)
+
+ def release_pointer(self, device, barrier, eventid):
+ self.released.append((device, barrier, eventid))
+
+
+class SeamGeometryTest(unittest.TestCase):
+ def test_only_shared_monitor_edge_segments_are_returned(self):
+ found = x11_seams.seams([
+ Rect(-1280, 100, 1280, 1024),
+ Rect(0, 0, 1920, 1080),
+ Rect(1920, 400, 1280, 800),
+ ])
+ self.assertEqual([seam.key for seam in found], [
+ (0, 100, 0, 1079),
+ (1920, 400, 1920, 1079),
+ ])
+
+ def test_diagonal_and_gapped_displays_have_no_seam(self):
+ self.assertEqual(x11_seams.seams([Rect(0, 0, 100, 100), Rect(100, 101, 100, 100)]), [])
+ self.assertEqual(x11_seams.seams([Rect(0, 0, 100, 100), Rect(101, 0, 100, 100)]), [])
+
+
+class SeamControllerTest(unittest.TestCase):
+ def setUp(self):
+ self.backend = FakeBackend()
+ self.controller = x11_seams.Controller(self.backend)
+ self.monitors = [Rect(0, 0, 100, 100), Rect(100, 0, 100, 100)]
+
+ def test_barrier_releases_only_after_configured_outward_pressure(self):
+ self.controller.configure(self.monitors, 30)
+ barrier = 101
+ self.controller.handle(("barrier", x11_seams.XI_BARRIER_HIT, 2, 44, barrier, 12.0, 0.0))
+ self.controller.handle(("barrier", x11_seams.XI_BARRIER_HIT, 2, 44, barrier, 15.0, 0.0))
+ self.assertEqual(self.backend.released, [])
+ self.controller.handle(("barrier", x11_seams.XI_BARRIER_HIT, 2, 44, barrier, 3.0, 0.0))
+ self.assertEqual(self.backend.released, [(2, barrier, 44)])
+ self.controller.handle(("barrier", x11_seams.XI_BARRIER_HIT, 2, 44, barrier, 20.0, 0.0))
+ self.assertEqual(len(self.backend.released), 1)
+
+ def test_reversing_along_or_leaving_does_not_carry_pressure_forward(self):
+ self.controller.configure(self.monitors, 30)
+ barrier = 101
+ key = ("barrier", x11_seams.XI_BARRIER_HIT, 2, 45, barrier)
+ self.controller.handle(key + (18.0, 0.0))
+ self.controller.handle(key + (-12.0, 0.0))
+ self.assertEqual(self.backend.released, [])
+ self.controller.handle(("barrier", x11_seams.XI_BARRIER_LEAVE, 2, 45, barrier, 0.0, 0.0))
+ self.controller.handle(key + (18.0, 0.0))
+ self.assertEqual(self.backend.released, [])
+
+ def test_disabled_state_removes_all_barriers_and_zero_resistance_creates_none(self):
+ self.controller.configure(self.monitors, 30)
+ self.controller.configure(self.monitors, 30, enabled=False)
+ self.assertEqual(self.backend.destroyed, [101])
+ self.controller.configure(self.monitors, 0)
+ self.assertEqual(len(self.backend.created), 1)
+
+ def test_barrier_event_parser_reads_fixed_point_attempted_motion(self):
+ body = struct.pack("=HIIIIIIIIH2xii iI iI", 2, 10, 31, 1, 1, 104, 5, 12, 0,
+ 6, 12 * 65536, 24 * 65536, -4, 0x80000000, 2, 0)
+ event = x11_seams.parse_barrier_event(x11_seams.XI_BARRIER_HIT, body)
+ self.assertEqual(event[:5], ("barrier", x11_seams.XI_BARRIER_HIT, 2, 31, 104))
+ self.assertEqual(event[5:7], (-3.5, 2.0))
+ self.assertEqual(event[7:9], (12.0, 24.0))
+
+ def test_parser_rejects_truncated_or_unrelated_event(self):
+ with self.assertRaises(ValueError):
+ x11_seams.parse_barrier_event(x11_seams.XI_BARRIER_HIT, b"short")
+ with self.assertRaises(ValueError):
+ x11_seams.parse_barrier_event(17, b"" * 62)
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/win_app/theme.py b/win_app/theme.py
index c19848a..45e33d9 100644
--- a/win_app/theme.py
+++ b/win_app/theme.py
@@ -199,8 +199,8 @@ def stylesheet() -> str:
r_field=round(RADIUS["field"]),
r_button=round(RADIUS["button"]),
r_keycap=round(RADIUS["keycap"]),
- selected_bg=tokens.PALETTE["ink"],
- selected_ink=tokens.PALETTE["ground"],
+ selected_bg=P["ink"],
+ selected_ink=P["ground"],
)
return _TEMPLATE.format(**values)
diff --git a/win_app/tokens.py b/win_app/tokens.py
index a1ecd5b..a5aa2a1 100644
--- a/win_app/tokens.py
+++ b/win_app/tokens.py
@@ -27,6 +27,7 @@ PALETTE = {
"signal": "#5fd4f4",
"signal_dim": "#1f4a55",
"amber": "#f2b544",
+ "resistance_flash": "#b77a00",
"fault": "#ff7a66",
"off": "#4a4b44",
}
@@ -53,6 +54,7 @@ PALETTE_LIGHT = {
"signal": "#006a88",
"signal_dim": "#bfe0ea",
"amber": "#8f5c00",
+ "resistance_flash": "#b55f00",
"fault": "#b53522",
"off": "#aeada3",
}
diff --git a/win_app/widgets.py b/win_app/widgets.py
index 99a2f6e..e0e4c46 100644
--- a/win_app/widgets.py
+++ b/win_app/widgets.py
@@ -3,7 +3,11 @@ LED, the 60-segment countdown and the switch."""
from __future__ import annotations
-from PySide6.QtCore import QEvent, QObject, QRect, QRectF, QSignalBlocker, QSize, Qt
+import math
+
+from shiboken6 import isValid
+
+from PySide6.QtCore import QEvent, QObject, QPointF, QRect, QRectF, QSignalBlocker, QSize, Qt
from PySide6.QtGui import QAction, QColor, QFont, QFontMetrics, QLinearGradient, QPainter, QPalette, QPen
from PySide6.QtWidgets import (
QAbstractButton,
@@ -78,6 +82,9 @@ class _KeyboardNavigation(QObject):
def eventFilter(self, watched, event) -> bool:
kind = event.type()
+ if kind not in (QEvent.Type.KeyPress, QEvent.Type.MouseButtonPress,
+ QEvent.Type.MouseButtonDblClick, QEvent.Type.FocusIn):
+ return False
if kind == QEvent.Type.KeyPress and is_navigation_key(event.key(), event.modifiers()):
self.set(True)
elif kind in (QEvent.Type.MouseButtonPress, QEvent.Type.MouseButtonDblClick):
@@ -314,17 +321,99 @@ class Eyebrow(QLabel):
class Module(QFrame):
"""One `panel` cell in the rack, eyebrow first."""
- def __init__(self, title: str, parent: QWidget | None = None) -> None:
+ def __init__(self, title: str, parent: QWidget | None = None, *, heading=False) -> None:
super().__init__(parent)
self.setProperty("vernier", "module")
self.body = QVBoxLayout(self)
self.body.setContentsMargins(16, 16, 16, 16)
self.body.setSpacing(12)
- self.eyebrow = Eyebrow(title)
+ self.eyebrow = label(title, "body", wrap=True) if heading else Eyebrow(title)
+ if heading:
+ self.eyebrow.setFont(theme.font(tokens.TYPE["body"], 600))
self.body.addWidget(self.eyebrow)
self.setSizePolicy(QSizePolicy.Policy.Preferred, QSizePolicy.Policy.Preferred)
+class WayTile(QAbstractButton):
+ """A checkable way with its destination detail inside the same keyboard target."""
+
+ def __init__(self, title: str, detail: str, parent=None) -> None:
+ super().__init__(parent)
+ self.setText(title)
+ self.setAccessibleName(title)
+ self.setCheckable(True)
+ self.setFocusPolicy(Qt.FocusPolicy.StrongFocus)
+ self.setCursor(Qt.CursorShape.PointingHandCursor)
+ self.setProperty("vernier", "plain")
+ self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Preferred)
+ column = QVBoxLayout(self)
+ column.setContentsMargins(34, 8, 12, 8)
+ column.setSpacing(2)
+ self.title = label(title, "body", wrap=True)
+ self.title.setFont(theme.font(tokens.TYPE["body"], 600))
+ self.detail = label(detail, "small", wrap=True)
+ for item in (self.title, self.detail):
+ item.setAttribute(Qt.WidgetAttribute.WA_TransparentForMouseEvents)
+ column.addWidget(item)
+ self.set_detail(detail)
+ self.toggled.connect(self.update)
+
+ def set_detail(self, text: str) -> None:
+ if self.detail.text() != text:
+ self.detail.setText(text)
+ if self.accessibleDescription() != text:
+ self.setAccessibleDescription(text)
+
+ def minimumSizeHint(self) -> QSize:
+ return QSize(100, 52)
+
+ def paintEvent(self, _event) -> None:
+ painter = QPainter(self)
+ painter.setRenderHint(QPainter.RenderHint.Antialiasing)
+ if not self.isEnabled():
+ painter.setOpacity(0.45)
+ painter.fillRect(self.rect(), QColor(theme.colour("ground")))
+ painter.setPen(QColor(theme.colour("signal" if focus_ring_visible(self) else "rule")))
+ painter.drawRect(self.rect().adjusted(0, 0, -1, -1))
+ box = QRectF(12, 11, 14, 14)
+ painter.setPen(QColor(theme.colour("signal" if self.isChecked() else "edge")))
+ painter.setBrush(QColor(theme.colour("signal" if self.isChecked() else "well")))
+ painter.drawRoundedRect(box, 3, 3)
+ if self.isChecked():
+ painter.setPen(QPen(QColor(theme.colour("ground")), 2))
+ painter.drawLine(QPointF(15, 18), QPointF(18, 21))
+ painter.drawLine(QPointF(18, 21), QPointF(24, 14))
+
+
+class Figure(QLabel):
+ """A ruler value with a large numeral and a small unit on the same baseline."""
+
+ def __init__(self, text: str, parent=None) -> None:
+ super().__init__(text, parent)
+ self.setProperty("vernier", "plain")
+ self.setMinimumWidth(0)
+ self.setFixedHeight(64)
+
+ def sizeHint(self) -> QSize:
+ number, _, unit = self.text().partition(" ")
+ width = QFontMetrics(theme.mono_font(tokens.TYPE["numeral"])).horizontalAdvance(number)
+ width += 6 + QFontMetrics(theme.font(tokens.TYPE["small"])).horizontalAdvance(unit)
+ return QSize(width, 64)
+
+ def paintEvent(self, _event) -> None:
+ number, _, unit = self.text().partition(" ")
+ painter = QPainter(self)
+ font = theme.mono_font(tokens.TYPE["numeral"])
+ painter.setFont(font)
+ painter.setPen(QColor(theme.colour("ink")))
+ metrics = QFontMetrics(font)
+ baseline = metrics.ascent()
+ painter.drawText(0, baseline, number)
+ painter.setFont(theme.font(tokens.TYPE["small"]))
+ painter.setPen(QColor(theme.colour("ink_3")))
+ painter.drawText(metrics.horizontalAdvance(number) + 6, baseline, unit)
+
+
class ActionButton(QPushButton):
"""An intrinsic action whose full label remains readable in a narrow column."""
@@ -374,7 +463,7 @@ class ActionButton(QPushButton):
painter.drawControl(QStyle.ControlElement.CE_PushButton, option)
content = self.style().subElementRect(QStyle.SubElement.SE_PushButtonContents, option, self)
if self.property("vernier") == "choice" and self.isChecked() and self.isEnabled():
- painter.setPen(QColor(tokens.PALETTE["ground"]))
+ painter.setPen(QColor(theme.colour("ground")))
elif self.property("vernier") in ("primary", "live") and self.isEnabled():
painter.setPen(QColor(theme.colour("ground")))
else:
@@ -382,6 +471,37 @@ class ActionButton(QPushButton):
painter.drawText(content, Qt.AlignmentFlag.AlignCenter | Qt.TextFlag.TextWordWrap, self.text())
+class ElidingActionButton(ActionButton):
+ """An ActionButton whose label names something of any length (a machine): one line, elided to
+ the width it has, the whole label in its tooltip."""
+
+ def __init__(self, text="", parent=None):
+ super().__init__(text, parent)
+ self.full_text = text
+
+ def set_full_text(self, text):
+ self.full_text = text
+ self._elide()
+
+ def _elide(self):
+ room = max(1, self.width() - self._chrome() - 2)
+ shown = QFontMetrics(self.font()).elidedText(self.full_text, Qt.TextElideMode.ElideRight, room)
+ if shown != self.text():
+ self.setText(shown)
+ self.setToolTip(self.full_text if shown != self.full_text else "")
+
+ def sizeHint(self):
+ width = min(self.maximumWidth(), max(64, self.fontMetrics().horizontalAdvance(self.full_text) + self._chrome() + 2))
+ return QSize(width, max(30, self.fontMetrics().height() + 12))
+
+ def heightForWidth(self, width):
+ return max(30, self.fontMetrics().height() + 12)
+
+ def resizeEvent(self, event):
+ super().resizeEvent(event)
+ self._elide()
+
+
class FormRow(QWidget):
"""The shared label track stacks before it would compress a setting's control."""
@@ -651,6 +771,9 @@ class Choice:
class _TileOutline(QWidget):
+ CHECK_ROOM = 22
+ BADGE_SIZE = 16
+
def __init__(self, tile):
super().__init__(tile)
self.setAttribute(Qt.WidgetAttribute.WA_TransparentForMouseEvents)
@@ -666,12 +789,25 @@ class _TileOutline(QWidget):
painter.setRenderHint(QPainter.RenderHint.Antialiasing)
painter.setBrush(Qt.BrushStyle.NoBrush)
if selected:
- painter.setPen(QPen(QColor(theme.colour("signal")), 2))
+ signal = QColor(theme.colour("signal"))
+ painter.setPen(QPen(signal, 2))
painter.drawRoundedRect(QRectF(self.rect()).adjusted(1, 1, -1, -1),
tokens.RADIUS["button"], tokens.RADIUS["button"])
- x = self.width() - 20
- painter.drawLine(x, 12, x + 3, 15)
- painter.drawLine(x + 3, 15, x + 9, 8)
+ name = getattr(tile, "name_label", None)
+ if name is not None:
+ box = name.geometry()
+ metrics = name.fontMetrics()
+ text_top = box.y() + (box.height() - metrics.height()) / 2.0
+ middle = text_top + metrics.ascent() - metrics.xHeight() / 2.0
+ left = box.x()
+ badge = QRectF(left, middle - self.BADGE_SIZE / 2, self.BADGE_SIZE, self.BADGE_SIZE)
+ painter.setPen(Qt.PenStyle.NoPen)
+ painter.setBrush(signal)
+ painter.drawEllipse(badge)
+ painter.setPen(QPen(QColor(theme.colour("ground")), 2, Qt.PenStyle.SolidLine,
+ Qt.PenCapStyle.RoundCap, Qt.PenJoinStyle.RoundJoin))
+ painter.drawPolyline([QPointF(left + 3.5, middle), QPointF(left + 6.5, middle + 3),
+ QPointF(left + 12.5, middle - 4)])
if focused:
painter.setPen(QPen(QColor(theme.colour("ink")), 2))
painter.drawRoundedRect(QRectF(self.rect()).adjusted(5, 5, -5, -5), 2, 2)
@@ -759,6 +895,7 @@ class ChoiceTiles:
row.setAlignment(Qt.AlignmentFlag.AlignLeft)
self._tiles: dict = {}
self._titles: dict = {}
+ self._details: dict = {}
for value, title, detail, preview in items:
tile = _Tile(lambda v=value: self._chosen(v))
if vertical:
@@ -768,6 +905,7 @@ class ChoiceTiles:
if tile_width is not None:
tile.setFixedWidth(tile_width)
self._titles[value] = title
+ self._details[value] = label(detail, "small", wrap=True)
tile.setAccessibleName(title)
tile.setAccessibleDescription(detail)
column = QVBoxLayout(tile)
@@ -777,8 +915,10 @@ class ChoiceTiles:
column.addWidget(preview)
if not vertical:
column.addSpacing(4)
- column.addWidget(label(title, "tile-name", wrap=tile_width is not None))
- column.addWidget(label(detail, "small", wrap=True))
+ tile.name_label = label(title, "tile-name", wrap=tile_width is not None)
+ column.addWidget(tile.name_label)
+ tile.detail_label = self._details[value]
+ column.addWidget(tile.detail_label)
if vertical:
column.setSpacing(6)
column.insertSpacing(1, 4)
@@ -789,6 +929,7 @@ class ChoiceTiles:
else:
row.addWidget(tile, 0 if vertical or tile_width is not None else 1)
self._tiles[value] = tile
+ tile.outline.raise_()
self.set_value(current)
def set_value(self, value) -> None:
@@ -797,6 +938,7 @@ class ChoiceTiles:
with QSignalBlocker(tile):
tile.setChecked(candidate == value)
set_role(tile, "tile-on" if candidate == value else "tile")
+ tile.name_label.setIndent(_TileOutline.CHECK_ROOM if candidate == value else 0)
tile.outline.update()
title = self._titles[candidate]
tile.setAccessibleName(f"{title}, selected" if candidate == value else title)
@@ -804,10 +946,21 @@ class ChoiceTiles:
def tile(self, value):
return self._tiles.get(value)
+ def set_detail(self, value, detail: str) -> None:
+ if value in self._details and self._details[value].text() != detail:
+ self._details[value].setText(detail)
+ self._tiles[value].setAccessibleDescription(detail)
+
def set_enabled(self, enabled: bool) -> None:
- fade = QGraphicsOpacityEffect(self.view)
- fade.setOpacity(1.0 if enabled else 0.45)
- self.view.setGraphicsEffect(None if enabled else fade)
+ # The effect is built only when it will be installed: one parented to the view and never
+ # installed is never freed, and this runs on every refresh tick.
+ if enabled:
+ self.view.setGraphicsEffect(None)
+ elif not (isinstance(self.view.graphicsEffect(), QGraphicsOpacityEffect)
+ and self.view.graphicsEffect().opacity() == 0.45):
+ fade = QGraphicsOpacityEffect(self.view)
+ fade.setOpacity(0.45)
+ self.view.setGraphicsEffect(fade)
for tile in self._tiles.values():
tile.setEnabled(enabled)
@@ -841,7 +994,9 @@ class _FamilyChoices(QWidget):
else (5 if outer >= 600 else 3 if outer >= 400 else 2))
gap = 12 if self.kind == "style" else 8
cell_width = max(1, (width - gap * (columns - 1) + columns - 1) // columns)
- if len(self.cells) == 1:
+ # A lone style tile keeps the track its family's neighbours have: shrunk to 152 px it was the
+ # one tile on the page drawn at another size (the Aperture switch, alone in Light).
+ if len(self.cells) == 1 and self.kind != "style":
columns, cell_width = 1, min(width, 152)
if self.kind == "style":
height = max(round(cell_width * 116 / 152), round((cell_width - 16) / 2) + 64)
@@ -869,7 +1024,7 @@ class _FamilyChoices(QWidget):
room = self.width() - gap * (columns - 1)
left = round(track * room / columns) + track * gap
right = round((track + 1) * room / columns) + track * gap
- if len(self.cells) == 1:
+ if len(self.cells) == 1 and self.kind != "style":
left, right = 0, width
cell.setGeometry(left, (index // columns) * (height + gap), right - left, height)
if self.kind == "style":
@@ -993,6 +1148,10 @@ class TileGroups:
def tile(self, value):
return next((tile for tiles in self.groups.values() if (tile := tiles.tile(value)) is not None), None)
+ def set_detail(self, value, detail: str) -> None:
+ for tiles in self.groups.values():
+ tiles.set_detail(value, detail)
+
def set_value(self, value) -> None:
self.value = value
for tiles in self.groups.values():
@@ -1169,9 +1328,11 @@ class InputRecorder(ActionButton):
QApplication.instance().installEventFilter(self)
def eventFilter(self, watched, event) -> bool:
+ kind = event.type()
+ if kind not in (QEvent.Type.KeyPress, QEvent.Type.KeyRelease, QEvent.Type.MouseButtonPress):
+ return False
if not self.armed:
return False
- kind = event.type()
if kind == QEvent.Type.KeyPress:
vk = self.hook_vk(event.nativeVirtualKey(), event.nativeScanCode())
if not vk:
@@ -1240,9 +1401,12 @@ class JumpKeyRecorder(ActionButton):
self.value = value or ""
shown = " ".join(self._names.get(part, part.upper() if len(part) == 1 else part.replace("_", " ").title())
for part in self.value.split("+")) if self.value else "Choose a key combination"
- self.setAccessibleName(f"Jump straight here key, {shown}")
+ name = f"Jump straight here key, {shown}"
+ if self.accessibleName() != name:
+ self.setAccessibleName(name)
if not self.armed:
- self.key.setText(shown)
+ if self.key.text() != shown:
+ self.key.setText(shown)
set_role(self.key, "keycap" if self.value else "body")
def cancel(self) -> None:
@@ -1271,9 +1435,12 @@ class JumpKeyRecorder(ActionButton):
self.on_arm(True)
def eventFilter(self, watched, event) -> bool:
+ kind = event.type()
+ if kind not in (QEvent.Type.KeyPress, QEvent.Type.KeyRelease, QEvent.Type.MouseButtonPress):
+ return False
if not self.armed:
return False
- if event.type() == QEvent.Type.KeyPress:
+ if kind == QEvent.Type.KeyPress:
modifiers = event.modifiers()
held = []
for flag, name in ((Qt.KeyboardModifier.ControlModifier, "cmd"),
@@ -1299,9 +1466,9 @@ class JumpKeyRecorder(ActionButton):
self.set_value(chord)
self.on_record(chord)
return True
- if event.type() == QEvent.Type.KeyRelease:
+ if kind == QEvent.Type.KeyRelease:
return True
- if event.type() == QEvent.Type.MouseButtonPress:
+ if kind == QEvent.Type.MouseButtonPress:
inside = isinstance(watched, QWidget) and (watched is self or self.isAncestorOf(watched))
self.cancel()
return inside
@@ -1415,8 +1582,17 @@ class Sidebar(QWidget):
self._on_select = on_select
self._selected = ""
keyboard_navigation()
- QApplication.instance().installEventFilter(self)
- QApplication.instance().focusChanged.connect(self._focus_changed)
+ app = QApplication.instance()
+ app.installEventFilter(self)
+ focus_connection = app.focusChanged.connect(self._focus_changed)
+
+ def detach(destroyed):
+ if isValid(app):
+ # The destroyed signal supplies a valid QObject; the Sidebar wrapper is already invalid.
+ app.removeEventFilter(destroyed)
+ QObject.disconnect(focus_connection)
+
+ self.destroyed.connect(detach)
outer = QVBoxLayout(self)
outer.setContentsMargins(0, 0, 0, 0)
outer.setSpacing(0)
@@ -1429,8 +1605,23 @@ class Sidebar(QWidget):
self.link_led = Led()
self._link_layout.addWidget(self.link_led, 0, Qt.AlignmentFlag.AlignVCenter)
self.link_word = label("", "sidebar-link")
- self._link_layout.addWidget(self.link_word, 1)
+ self.link_peer = label("", "note")
+ self._link_details = QWidget()
+ details_layout = QVBoxLayout(self._link_details)
+ details_layout.setContentsMargins(0, 0, 0, 0)
+ details_layout.setSpacing(1)
+ details_layout.addWidget(self.link_word)
+ details_layout.addWidget(self.link_peer)
+ self._link_layout.addWidget(self._link_details, 1)
+ self.response_time = label("", "note")
+ self.response_time.setAccessibleName("Response time: no fresh measurement")
+ self.response_time.hide()
outer.addWidget(link)
+ response_row = QHBoxLayout()
+ response_row.setContentsMargins(24, 0, 8, 6)
+ response_row.addWidget(self.response_time)
+ self._response_row = response_row
+ outer.addLayout(response_row)
outer.addWidget(rule(vertical=False))
list_layout = QVBoxLayout()
@@ -1483,25 +1674,36 @@ class Sidebar(QWidget):
self._update_rings()
def _update_rings(self):
+ if not isValid(self):
+ return
for key, button in self._buttons.items():
+ if not isValid(button):
+ continue
button._keyboard_ring = self.keyboard_mode and key == self._selected
button.update()
- for tile in self.window().findChildren(_Tile):
- tile.outline.update()
+ focused = QApplication.focusWidget()
+ tiles = (getattr(self, "_ring_focus", None), focused)
+ self._ring_focus = focused
+ for tile in tiles:
+ if tile is not None and isValid(tile) and isinstance(tile, _Tile):
+ tile.outline.update()
def _focus_changed(self, old, new):
+ if not isValid(self):
+ return
if new in self._buttons.values():
selected = self._buttons.get(self._selected)
if not self.keyboard_mode:
new.clearFocus()
- elif selected is not None and new is not selected:
+ elif selected is not None and isValid(selected) and new is not selected:
selected.setFocus(Qt.FocusReason.TabFocusReason)
self._update_rings()
def _pointer_select(self, key):
self.keyboard_mode = False
self._on_select(key)
- self.select(key)
+ if self._selected != key:
+ self.select(key)
def navigate(self, key, direction):
keys = list(self._buttons)
@@ -1509,16 +1711,21 @@ class Sidebar(QWidget):
target = keys[(keys.index(key) + direction) % len(keys)]
self._on_select(target)
self._buttons[target].setFocus(Qt.FocusReason.ShortcutFocusReason)
- self.select(target)
+ if self._selected != target:
+ self.select(target)
def eventFilter(self, watched, event):
- if isinstance(watched, QWidget) and watched.window() is self.window():
- if event.type() == QEvent.Type.MouseButtonPress:
+ kind = event.type()
+ if kind not in (QEvent.Type.MouseButtonPress, QEvent.Type.KeyPress):
+ return False
+ if isValid(self) and isinstance(watched, QWidget) and watched.window() is self.window():
+ if kind == QEvent.Type.MouseButtonPress:
self.keyboard_mode = False
for button in self._buttons.values():
- button.clearFocus()
+ if isValid(button):
+ button.clearFocus()
self._update_rings()
- elif event.type() == QEvent.Type.KeyPress and is_navigation_key(event.key(), event.modifiers()):
+ elif kind == QEvent.Type.KeyPress and is_navigation_key(event.key(), event.modifiers()):
self.keyboard_mode = True
self._update_rings()
return False
@@ -1526,7 +1733,11 @@ class Sidebar(QWidget):
def set_window_width(self, width):
rail = width < 640
self.setFixedWidth(56 if rail else 144 if width < 800 else 176)
- self.link_word.setVisible(not rail)
+ self._link_details.setVisible(not rail)
+ self.link_peer.setVisible(bool(getattr(self, "_response_peer", "")) and not rail)
+ self._rail = rail
+ self._response_row.setContentsMargins(0 if rail else 24, 0, 0 if rail else 8, 3 if rail else 6)
+ self._update_response_time()
self._link_layout.setContentsMargins(24 if rail else 16, 4 if rail else 16,
24 if rail else 16, 4 if rail else 16)
self._list_layout.setContentsMargins(6 if rail else 8, 3 if rail else 8,
@@ -1547,11 +1758,44 @@ class Sidebar(QWidget):
self.foot.setIcon(QIcon())
theme.repolish(self.foot)
- def set_link(self, tone: str, word: str) -> None:
+ def set_link(self, tone: str, word: str, peer: str = "", response_time_ms=None, connected=False) -> None:
+ seen = (tone, word, peer, response_time_ms, connected, getattr(self, "_rail", False))
+ if seen == getattr(self, "_link_seen", None):
+ return
+ self._link_seen = seen
self.link_led.set_tone(tone)
if self.link_word.text() != word:
self.link_word.setText(word)
+ self.link_peer.setText(peer)
+ self.link_peer.setAccessibleName(peer)
+ self.link_peer.setVisible(bool(peer) and not getattr(self, "_rail", False))
self.link_led.setToolTip(word)
+ self._response_peer = peer
+ self._response_time_ms = response_time_ms
+ self._response_connected = connected
+ self._update_response_time()
+
+ def _update_response_time(self) -> None:
+ connected = getattr(self, "_response_connected", False)
+ value = getattr(self, "_response_time_ms", None)
+ self.response_time.setVisible(connected)
+ if not connected:
+ self.response_time.setText("")
+ self.response_time.setAccessibleName("Response time: disconnected")
+ self.response_time.setToolTip("")
+ return
+ target = f" to {self._response_peer}" if getattr(self, "_response_peer", "") else ""
+ detail = f"Response time{target}: {value} ms" if value is not None else f"Response time{target}: no fresh measurement"
+ rail = getattr(self, "_rail", False)
+ if rail:
+ visible = f"{value} ms" if value is not None else "—"
+ elif value is None:
+ visible = "Response: —"
+ else:
+ visible = f"Response: {value} ms"
+ self.response_time.setText(visible)
+ self.response_time.setAccessibleName(detail)
+ self.response_time.setToolTip(detail)
def set_dots(self, marks: dict) -> None:
for key, button in self._buttons.items():
@@ -1564,13 +1808,76 @@ class Ruler(QSlider):
STEP = 10
- def __init__(self, name: str, maximum: int, minimum: int = 0, parent: QWidget | None = None) -> None:
+ def __init__(self, name: str, maximum: int, minimum: int = 0, parent: QWidget | None = None,
+ step: int = STEP, page_step: int | None = None, ticks=(), scale="linear") -> None:
super().__init__(Qt.Orientation.Horizontal, parent)
+ self.ticks = ticks
+ self.scale = scale
self.setRange(minimum, maximum)
- self.setSingleStep(self.STEP)
- self.setPageStep(self.STEP * 5)
+ self.setSingleStep(step)
+ self.setPageStep(page_step if page_step is not None else step * 5)
self.setAccessibleName(name)
self.setCursor(Qt.CursorShape.PointingHandCursor)
+ if ticks:
+ self.setMinimumHeight(54)
+
+ def _fraction(self, value):
+ transform = math.sqrt if self.scale == "sqrt" else float
+ low, high = transform(self.minimum()), transform(self.maximum())
+ return (transform(value) - low) / (high - low)
+
+ def _point_value(self, x):
+ fraction = max(0, min(1, (x - 6) / max(1, self.width() - 12)))
+ if self.scale == "sqrt":
+ value = (math.sqrt(self.minimum()) + fraction * (math.sqrt(self.maximum()) - math.sqrt(self.minimum()))) ** 2
+ else:
+ value = self.minimum() + fraction * (self.maximum() - self.minimum())
+ return round(value / self.singleStep()) * self.singleStep()
+
+ def mousePressEvent(self, event) -> None:
+ if self.ticks and event.button() == Qt.MouseButton.LeftButton:
+ self.setValue(self._point_value(event.position().x()))
+ event.accept()
+ return
+ super().mousePressEvent(event)
+
+ def mouseMoveEvent(self, event) -> None:
+ if self.ticks and event.buttons() & Qt.MouseButton.LeftButton:
+ self.setValue(self._point_value(event.position().x()))
+ event.accept()
+ return
+ super().mouseMoveEvent(event)
+
+ def paintEvent(self, event) -> None:
+ if not self.ticks:
+ super().paintEvent(event)
+ return
+ painter = QPainter(self)
+ painter.setRenderHint(QPainter.RenderHint.Antialiasing)
+ painter.setPen(QColor(theme.colour("edge")))
+ painter.drawLine(6, 30, self.width() - 6, 30)
+ painter.setFont(theme.mono_font(tokens.TYPE["small"]))
+ for division in range(21):
+ x = round(6 + division * (self.width() - 12) / 20)
+ painter.drawLine(x, 24, x, 30)
+ previous_right = -4
+ metrics = painter.fontMetrics()
+ last_width = metrics.horizontalAdvance(str(self.ticks[-1]))
+ for value in self.ticks:
+ x = round(6 + self._fraction(value) * (self.width() - 12))
+ painter.drawLine(x, 22, x, 30)
+ text = str(value)
+ width = metrics.horizontalAdvance(text)
+ left = max(0, min(self.width() - width, x - width // 2))
+ if value != self.ticks[-1] and (left < previous_right + 4 or left + width + 4 > self.width() - last_width):
+ continue
+ painter.drawText(QRect(left, 33, width, 20), Qt.AlignmentFlag.AlignCenter, text)
+ previous_right = left + width
+ x = round(6 + self._fraction(self.value()) * (self.width() - 12))
+ painter.setPen(QColor(theme.colour("ink_2")))
+ painter.drawLine(6, 30, x, 30)
+ painter.setPen(QPen(QColor(theme.colour("signal" if focus_ring_visible(self) else "ink")), 3))
+ painter.drawLine(x, 2, x, 31)
def keyPressEvent(self, event) -> None:
steps = {Qt.Key.Key_Left: -1, Qt.Key.Key_Down: -1, Qt.Key.Key_Right: 1, Qt.Key.Key_Up: 1}
diff --git a/win_app/x11_seams.py b/win_app/x11_seams.py
new file mode 100644
index 0000000..821438c
--- /dev/null
+++ b/win_app/x11_seams.py
@@ -0,0 +1,208 @@
+"""XFixes pointer barriers along the seams between this X11 desktop's monitors.
+
+The small controller is independent of python-xlib so its geometry and resistance behaviour can
+be checked without an X server. XFixes 5 creates the barriers; XI 2.3 reports hits and lets us
+release a pointer after the configured pressure has been reached.
+"""
+
+import struct
+from dataclasses import dataclass
+from typing import Dict, Iterable, List, Tuple
+
+from core.return_edge import Rect
+
+XI_BARRIER_HIT = 25
+XI_BARRIER_LEAVE = 26
+XI_ALL_MASTER_DEVICES = 1
+XI_BARRIER_EVENTS = (1 << XI_BARRIER_HIT) | (1 << XI_BARRIER_LEAVE)
+
+_CREATE_POINTER_BARRIER = 31
+_DESTROY_POINTER_BARRIER = 32
+_XI_BARRIER_RELEASE_POINTER = 61
+
+
+@dataclass(frozen=True)
+class Seam:
+ """A half-open monitor-to-monitor seam, represented as XFixes endpoints."""
+
+ x1: int
+ y1: int
+ x2: int
+ y2: int
+ axis: str
+
+ @property
+ def key(self) -> Tuple[int, int, int, int]:
+ return self.x1, self.y1, self.x2, self.y2
+
+
+def seams(monitors: Iterable[Rect]) -> List[Seam]:
+ """Return each shared edge segment once; external edges are deliberately omitted."""
+ displays = list(monitors)
+ found: Dict[Tuple[int, int, int, int], Seam] = {}
+ for index, first in enumerate(displays):
+ for second in displays[index + 1:]:
+ if first.x + first.width == second.x or second.x + second.width == first.x:
+ start = max(first.y, second.y)
+ end = min(first.y + first.height, second.y + second.height)
+ if end - start > 1:
+ x = (first.x + first.width if first.x + first.width == second.x
+ else second.x + second.width)
+ item = Seam(x, start, x, end - 1, "x")
+ found[item.key] = item
+ if first.y + first.height == second.y or second.y + second.height == first.y:
+ start = max(first.x, second.x)
+ end = min(first.x + first.width, second.x + second.width)
+ if end - start > 1:
+ y = (first.y + first.height if first.y + first.height == second.y
+ else second.y + second.height)
+ item = Seam(start, y, end - 1, y, "y")
+ found[item.key] = item
+ return list(found.values())
+
+
+def parse_barrier_event(kind: int, data: bytes) -> tuple:
+ """Decode the XI 2.3 event body python-xlib leaves opaque on GenericEvent."""
+ if kind not in (XI_BARRIER_HIT, XI_BARRIER_LEAVE):
+ raise ValueError(f"not an XI barrier event: {kind}")
+ # EVENTHEADER: deviceid, time; then eventid, root, event, barrier, full_sequence, dtime,
+ # flags, sourceid, padding, root_x, root_y, dx and dy (FP3232 pairs).
+ if len(data) < 62:
+ raise ValueError("truncated XI barrier event")
+ (deviceid, _time, eventid, _root, _event, barrier, _full_sequence, _dtime, _flags,
+ _sourceid, root_x, root_y, dx_i, dx_f, dy_i, dy_f) = struct.unpack_from("=HIIIIIIIIH2xii iI iI", data)
+ return ("barrier", kind, deviceid, eventid, barrier,
+ dx_i + dx_f / 2 ** 32, dy_i + dy_f / 2 ** 32,
+ root_x / 65536, root_y / 65536)
+
+
+class Controller:
+ """Reconcile active internal seams and release each barrier after configured outward travel."""
+
+ def __init__(self, backend) -> None:
+ self._backend = backend
+ self._barriers: Dict[int, Seam] = {}
+ self._signature = None
+ self._pressure: Dict[Tuple[int, int, int], Tuple[int, float]] = {}
+ self._released = set()
+
+ @property
+ def active(self) -> bool:
+ return bool(self._barriers)
+
+ def configure(self, monitors: Iterable[Rect], resistance_px: int, enabled: bool = True) -> None:
+ resistance = max(0.0, float(resistance_px))
+ wanted = seams(monitors) if enabled and resistance > 0 else []
+ # X protocol coordinates are signed 16-bit screen coordinates. Omit only unrepresentable
+ # seams; a bad display arrangement must not prevent ordinary input capture from starting.
+ wanted = [item for item in wanted if all(-32768 <= point <= 32767 for point in item.key)]
+ signature = (tuple(item.key for item in wanted), resistance, bool(enabled))
+ if signature == self._signature:
+ return
+ self._remove_all()
+ self._signature = signature
+ if not enabled or resistance <= 0:
+ return
+ self._resistance = resistance
+ try:
+ for item in wanted:
+ barrier = self._backend.create_barrier(item)
+ if barrier is not None:
+ self._barriers[int(barrier)] = item
+ except Exception:
+ self._remove_all()
+ self._signature = None
+ raise
+
+ def handle(self, event: tuple) -> None:
+ """Consume (kind, device, event id, barrier, dx, dy, ...) from the capture thread."""
+ _tag, kind, device, eventid, barrier, dx, dy = event[:7]
+ key = (int(device), int(eventid), int(barrier))
+ if kind == XI_BARRIER_LEAVE:
+ self._pressure.pop(key, None)
+ self._released.discard(key)
+ return
+ seam = self._barriers.get(int(barrier))
+ if seam is None or key in self._released:
+ return
+ outward = float(dx if seam.axis == "x" else dy)
+ # A hit event already means the pointer is pushing into the barrier. Direction is kept so
+ # reversing against the same event id restarts, rather than completes, the pressure.
+ if outward == 0:
+ return
+ direction, distance = (1 if outward > 0 else -1), abs(outward)
+ previous_direction, accumulated = self._pressure.get(key, (direction, 0.0))
+ if previous_direction != direction:
+ accumulated = 0.0
+ accumulated += distance
+ self._pressure[key] = (direction, accumulated)
+ if accumulated >= self._resistance:
+ self._backend.release_pointer(device, barrier, eventid)
+ self._released.add(key)
+
+ def close(self) -> None:
+ self._remove_all()
+ self._signature = None
+
+ def _remove_all(self) -> None:
+ for barrier in list(self._barriers):
+ try:
+ self._backend.destroy_barrier(barrier)
+ finally:
+ self._barriers.pop(barrier, None)
+ self._pressure.clear()
+ self._released.clear()
+
+
+def _request_classes():
+ # python-xlib is optional on macOS and Windows; keep its protocol types lazy like capture_x11's
+ # connection itself.
+ from Xlib.protocol import rq
+
+ class CreatePointerBarrier(rq.Request):
+ _request = rq.Struct(rq.Card8("opcode"), rq.Opcode(_CREATE_POINTER_BARRIER), rq.RequestLength(),
+ rq.Card32("barrier"), rq.Card32("window"),
+ rq.Int16("x1"), rq.Int16("y1"), rq.Int16("x2"), rq.Int16("y2"),
+ rq.Card32("directions"), rq.LengthOf("devices", 2),
+ rq.List("devices", rq.Card16))
+
+ class DestroyPointerBarrier(rq.Request):
+ _request = rq.Struct(rq.Card8("opcode"), rq.Opcode(_DESTROY_POINTER_BARRIER), rq.RequestLength(),
+ rq.Card32("barrier"))
+
+ class ReleasePointer(rq.Request):
+ _request = rq.Struct(
+ rq.Card8("opcode"), rq.Opcode(_XI_BARRIER_RELEASE_POINTER), rq.RequestLength(),
+ rq.Card32("num_barriers"),
+ rq.Card16("deviceid"), rq.Pad(2), rq.Card32("barrier"), rq.Card32("eventid"),
+ )
+
+ return CreatePointerBarrier, DestroyPointerBarrier, ReleasePointer
+
+
+class XlibBackend:
+ """The XFixes/XInput protocol requests needed by Controller, on Hooks' X connection."""
+
+ def __init__(self, display, root) -> None:
+ self._create, self._destroy, self._release = _request_classes()
+ self._display = display
+ self._protocol = display.display
+ self._root = root
+ self._xfixes_opcode = self._protocol.get_extension_major("XFIXES")
+ self._xinput_opcode = self._protocol.get_extension_major("XInputExtension")
+
+ def create_barrier(self, seam: Seam) -> int:
+ barrier = self._protocol.allocate_resource_id()
+ self._create(
+ display=self._protocol, opcode=self._xfixes_opcode, barrier=barrier, window=self._root.id,
+ x1=seam.x1, y1=seam.y1, x2=seam.x2, y2=seam.y2,
+ directions=0, devices=[XI_ALL_MASTER_DEVICES],
+ )
+ return barrier
+
+ def destroy_barrier(self, barrier: int) -> None:
+ self._destroy(display=self._protocol, opcode=self._xfixes_opcode, barrier=barrier)
+
+ def release_pointer(self, device: int, barrier: int, eventid: int) -> None:
+ self._release(display=self._protocol, opcode=self._xinput_opcode, num_barriers=1,
+ deviceid=device, barrier=barrier, eventid=eventid)