Skip to content

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

108 KB
Raw Blame
"""The Crossing page's two drawings, in Core Animation layers so every change can move: the
arrangement, which shows where the other machine sits and what crosses, and the push strip, which shows how
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

import motion
import pages
import theme
from core.resistance_strip import MAX_RESISTANCE, resistance_x
from core import ways as core_ways
from core import identify_screens
from core.i18n import N_, tr

POSITION_WORDS = {"right of": N_("right of"), "left of": N_("left of"),
                  "below": N_("below"), "above": N_("above")}
THIRD_WORDS = {"start": N_("start"), "middle": N_("middle"), "end": N_("end")}


def _rect(frame):
    x, y, w, h = frame
    return ((x, y), (w, h))


def _beside_display_numbers(frame, badges):
    x, y, width, height = frame
    spans = [(x, x + width)]
    for badge in badges:
        if badge.isHidden():
            continue
        box = badge.frame()
        if y + height <= box.origin.y or y >= box.origin.y + box.size.height:
            continue
        left, right = box.origin.x - 4, box.origin.x + box.size.width + 4
        spans = [(start, end) for a, b in spans
                 for start, end in ((a, min(b, left)), (max(a, right), b)) if end > start]
    left, right = max(spans, key=lambda span: span[1] - span[0]) if spans else (x, x + 1)
    return left, y, right - left, height


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}
    ).size().width


def _text_layer(size, ink, align=Quartz.kCAAlignmentCenter):
    layer = Quartz.CATextLayer.layer()
    layer.setFont_(theme.font(size, 500))
    layer.setFontSize_(size)
    theme.tint(layer, foreground=ink)
    layer.setAlignmentMode_(align)
    layer.setTruncationMode_(Quartz.kCATruncationEnd)
    layer.setContentsScale_(2.0)
    return layer


def _text_height(text, font, width):
    return AppKit.NSAttributedString.alloc().initWithString_attributes_(
        text, {AppKit.NSFontAttributeName: font}
    ).boundingRectWithSize_options_((max(1, width), 10000), AppKit.NSStringDrawingUsesLineFragmentOrigin).size.height


def _fit_text(layer, text, frame):
    x, y, width, height = frame
    layer.setString_(text)
    layer.setWrapped_(True)
    layer.setTruncationMode_(Quartz.kCATruncationNone)
    text_height = _text_height(text, layer.font(), width)
    layer.setFrame_(((x, y + max(0, (height - text_height) / 2)), (width, text_height)))


def _box(fill=None, stroke=None, radius=0.0):
    layer = Quartz.CALayer.layer()
    theme.tint(layer, background=fill, border=stroke)
    if stroke:
        layer.setBorderWidth_(1)
    layer.setCornerRadius_(radius)
    return layer


def _collapsed(frame, side):
    """`frame` shrunk to its middle along the side it runs down, where a mark grows from."""
    x, y, w, h = frame
    if side in ("left", "right"):
        return (x, y + h / 2, w, 0.0)
    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
RESIZE_GRIP = 12.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'
    quieter, so the picture says which edge leads where."""

    # The screens take the space above the legend row (the key cap and the machines not placed),
    # which they would otherwise run into once neighbours push this Mac off the middle.
    HEIGHT = 210.0
    LEGEND = 36.0
    # A mark's colour by its tone in pages.diagram_marks. A third the chosen machine does not use
    # stays as a dim track while Part of the edge is on, so the gaps read as walls, not as nothing.
    # signal_dim all but vanishes on the dark ground, so the others' marks are signal held back.
    TONES = {"chosen": "signal", "other": ("signal", 0.45), "track": "edge"}

    def isFlipped(self):
        return True

    @objc.python_method
    def setup(self):
        self.setTranslatesAutoresizingMaskIntoConstraints_(False)
        self.heightAnchor().constraintEqualToConstant_(self.HEIGHT).setActive_(True)
        self.setWantsLayer_(True)
        root = self.layer()
        theme.tint(root, background="ground", border="rule")
        root.setBorderWidth_(1)
        root.setCornerRadius_(3)
        self.this = _box("well", "edge", 4)
        self.this_label = _text_layer(theme.TYPE["small"], "ink_2")
        self.notch = _box("ground", None, 2)
        self.key = _box("well", "edge", theme.RADIUS["keycap"])
        # The shortcut as a key cap in the corner, and how it is pressed beside it: a legend, not a
        # sentence, since the note above the drawing already says it in words.
        self.key_label = _text_layer(theme.TYPE["small"], "ink", Quartz.kCAAlignmentCenter)
        self.key_label.setFont_(theme.font(theme.TYPE["small"], 600))
        self.key.addSublayer_(self.key_label)
        self.key_how = _text_layer(theme.TYPE["small"], "ink_3", Quartz.kCAAlignmentLeft)
        self.not_placed = _text_layer(theme.TYPE["small"], "ink_3", Quartz.kCAAlignmentRight)
        for layer in (self.this, self.this_label, self.notch, self.key, self.key_how, self.not_placed):
            root.addSublayer_(layer)
        # Made as machines and their marks first appear, by the machine's key, and dropped with it.
        self.screens = {}
        self.marks = {}
        self.machines = []
        self.state = None
        self.lit = {}
        self.setAccessibilityElement_(True)
        self.setAccessibilityRole_(AppKit.NSAccessibilityImageRole)
        return self

    def layout(self):
        objc.super(ArrangementDiagram, self).layout()
        if self.state is not None:
            self._draw(False)

    @objc.python_method
    def show(self, machines, key_text, has_notch, description, key_how="", shortcut=False):
        """Draws these machines, moving from the last drawing when on screen. Each machine is a dict
        with `key`, `label`, `side` ("" when not placed), its ways (`methods`, `parts`, `corner`) and
        whether it is `chosen`. `key_text` is the shortcut's key as its cap reads, `key_how` how it
        is pressed, `shortcut` whether it is on."""
        state = (tuple((m["key"], m["label"], m["side"], tuple(m["methods"]), tuple(m["parts"]), m["corner"], m["chosen"])
                       for m in machines), key_text, has_notch, key_how, shortcut)
        if state == self.state:
            return
        first = self.state is None
        self.state = state
        self.machines = [dict(machine) for machine in machines]
        self.setAccessibilityLabel_(description)
        self._draw(not first and motion.live(self))

    @objc.python_method
    def _screen(self, key):
        if key not in self.screens:
            screen = _box("panel", "rule", 4)
            label = _text_layer(theme.TYPE["small"], "ink_3")
            # Under this Mac's marks, which may sit at its edge beside a screen.
            for layer in (screen, label):
                self.layer().insertSublayer_below_(layer, self.this)
            self.screens[key] = (screen, label)
        return self.screens[key]

    @objc.python_method
    def _mark_layer(self, key):
        if key not in self.marks:
            layer = _box("signal", None, 2 if key[1] == "corner" else 1.5)
            self.layer().insertSublayer_above_(layer, self.notch)
            self.marks[key] = layer
        return self.marks[key]

    @objc.python_method
    def _draw(self, animate):
        _machines, key_text, has_notch, key_how, shortcut = self.state
        machines = self.machines
        bounds = self.bounds().size
        if bounds.width <= 0:
            return
        font = theme.font(theme.TYPE["small"], 500)
        width = min(bounds.width - 24, 24 + _text_width(key_text, theme.font(theme.TYPE["small"], 600)))
        how = _text_width(key_how, font) + 4
        stacked = bool(shortcut and width + 8 + how > bounds.width - 24)
        legend = self.LEGEND + (20 if stacked else 0)
        this, frames = pages.diagram_layout(bounds.width, bounds.height - legend, [pages.placement(m) for m in machines])
        # With one machine nothing is chosen between, and it looks as the one-machine drawing did.
        several = len(machines) > 1
        motion.transaction(animate)
        self.this.setFrame_(_rect(this))
        line = theme.TYPE["small"] + 4
        x, y, w, h = this
        _fit_text(self.this_label, tr("This Mac"), (x + 6, y + (4 if has_notch else 0), w - 12, h))
        keys = {machine["key"] for machine in machines}
        for key in [key for key in self.screens if key not in keys]:
            for layer in self.screens.pop(key):
                layer.removeFromSuperlayer()
        for machine, frame in zip(machines, frames):
            screen, label = self._screen(machine["key"])
            strong = several and machine["chosen"]
            screen.setHidden_(frame is None)
            label.setHidden_(frame is None)
            if frame is None:
                continue
            theme.tint(screen, border="ink_3" if strong else "rule")
            theme.tint(label, foreground="ink" if strong else "ink_3")
            label.setFont_(theme.font(theme.TYPE["small"], 600 if strong else 500))
            screen.setFrame_(_rect(frame))
            fx, fy, fw, fh = frame
            _fit_text(label, machine["label"], (fx + 4, fy, fw - 8, fh))
        marks, notch = pages.diagram_marks(this, machines)
        for key in [key for key in self.marks if key not in marks]:
            self.marks.pop(key).removeFromSuperlayer()
            self.lit.pop(key, None)
        sides = {machine["key"]: machine["side"] for machine in machines}
        for key, (frame, tone) in marks.items():
            layer = self._mark_layer(key)
            if tone is not None:
                theme.tint(layer, background=self.TONES[tone])
            # The chosen machine's ways on top where two machines' marks meet.
            layer.setZPosition_(1.0 if tone in ("chosen", "track") else 0.0)
            self._mark(key, layer, frame, tone, sides[key[0]] if key[1] != "corner" else None, animate)
        self.notch.setFrame_(_rect(pages.notch_mark(this)))
        self.notch.setHidden_(not has_notch)
        lit_notch = has_notch and notch is not None
        self.notch.setBorderWidth_(1.5 if lit_notch else 0)
        theme.tint(self.notch, border=self.TONES[notch] if lit_notch else "signal",
                   background=("signal", 0.25 if notch == "chosen" else 0.12) if lit_notch else "ground")
        shortcut = shortcut and bool(key_text)
        self.key_label.setString_(key_text)
        self.key_how.setString_(key_how)
        top = bounds.height - legend
        self.key.setFrame_(((12, top), (width, 24)))
        self.key_label.setFrame_(((0, (24 - line) / 2), (width, line)))
        how_left = 12 if stacked else 12 + width + 8
        how_top = top + 26 if stacked else top + (24 - line) / 2
        self.key_how.setFrame_(((how_left, how_top), (min(how, bounds.width - 12 - how_left), line)))
        for layer in (self.key, self.key_how):
            layer.setOpacity_(1.0 if shortcut else 0.0)
        # The machines with no side, on the key cap's line, from wherever the legend ends.
        start = how_left + how + 16 if shortcut else 12
        self.not_placed.setString_(pages.not_placed(machines))
        self.not_placed.setFrame_(((min(start, bounds.width - 12), how_top), (max(0, bounds.width - 12 - start), line)))
        Quartz.CATransaction.commit()

    @objc.python_method
    def _mark(self, key, layer, frame, tone, side, animate):
        """Places a mark; switched on or newly lit while moving, it grows out from its middle as
        it fades in. A mark with no frame (its machine has no side) is not drawn."""
        on = tone is not None and frame is not None
        # The side is part of the state: moved to another side, a mark grows in afresh there, which
        # reads far better than a strip stretching across the screen from one side to the other.
        state = (on, tone, side)
        was = self.lit.get(key)
        self.lit[key] = state
        if frame is None:
            layer.setOpacity_(0.0)
            return
        if not (on and was != state and animate):
            layer.setFrame_(_rect(frame))
            layer.setOpacity_(1.0 if on else 0.0)
            return
        # 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))
        layer.setOpacity_(1.0)
        Quartz.CATransaction.commit()
        x, y, w, h = frame
        sx, sy, sw, sh = start
        for key, old, new in (
            ("bounds", AppKit.NSValue.valueWithRect_(((0, 0), (sw, sh))), AppKit.NSValue.valueWithRect_(((0, 0), (w, h)))),
            ("position", AppKit.NSValue.valueWithPoint_((sx + sw / 2, sy + sh / 2)), AppKit.NSValue.valueWithPoint_((x + w / 2, y + h / 2))),
            ("opacity", 0.0, 1.0),
        ):
            grow = Quartz.CABasicAnimation.animationWithKeyPath_(key)
            grow.setFromValue_(old)
            grow.setToValue_(new)
            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 tr("Overlaps")
    if state in ("gap", "between", "set-elsewhere", "set_elsewhere"):
        return tr("Drag to connect")
    if not crosses:
        return tr("Edge off")
    return tr("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, tr("machine"))
            return tr("Recentre {name}").format(name=name)
        name = self.canvas.labels.get(self.key, tr("Machine · {id}").format(id=self.key[-6:]))
        if self.kind == "cycle":
            return tr("{name}, In the shortcut's cycle").format(name=name)
        word = self.canvas.tile_words.get(self.key)
        return tr("{name}, {status}").format(name=name, status=word) if word else name

    def accessibilityValue(self):
        if self.kind == "cycle":
            return self.canvas.cycle.get(self.key, True) is True
        return tr("Selected") if self.canvas.selected == self.key else ""

    def accessibilityHelp(self):
        if self.kind == "tile" and self.canvas._can_resize(self.key):
            return tr("Drag a corner to resize, or use Option and the arrow keys.")
        return ""

    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().constraintEqualToConstant_(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.tile_words = {}
        self.machine_picker = False
        self.read_only = False
        self.fixed_machine_id = ""
        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.display_number_layers = {}
        self.label_for_tile = {}
        self.state_for_tile = {}
        self.outcome_for_tile = {}
        self.dot_for_tile = {}
        self.cycle_for_tile = {}
        self.resize_layers = {}
        self.accessible_elements = {}
        self.contact_layers = {}
        self.seam_segments = []
        self.mark_layers = {}
        self.corner_halo_layers = {}
        self.wrap_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_(tr("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, tile_words=None, machine_picker=False, read_only=False,
                    fixed_machine_id=None):
        """`own_id` anchors the viewed machine's seams; picker mode includes it in selection."""
        cycle = dict(cycle or {})
        older = set(older)
        tile_words = dict(tile_words or {})
        fixed_machine_id = own_id if fixed_machine_id is None else fixed_machine_id
        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 and tile_words == self.tile_words
                and bool(machine_picker) == self.machine_picker and bool(read_only) == self.read_only
                and fixed_machine_id == self.fixed_machine_id):
            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
        self.tile_words = tile_words
        self.machine_picker = bool(machine_picker)
        self.read_only = bool(read_only)
        self.fixed_machine_id = fixed_machine_id
        if self.read_only:
            self.dragging = self.third_pressed = None
        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.display_number_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),
                              self.resize_layers.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, tr("Machine · {id}").format(id=key[-6:]))
            state = self.states.get(key, {}).get("state")
            sentence = self.states.get(key, {}).get("sentence", "")
            if sentence:
                parts.append(sentence)
            elif self.machine_picker and key == self.own_id:
                parts.append(label)
            elif key == self.own_id:
                name = self.states.get(key, {}).get("machine_name")
                parts.append(tr("{label}, {name}, this Mac.").format(label=label, name=name) if name else
                             tr("{label}, this Mac.").format(label=label))
            else:
                status = self.states.get(key, {})
                outcome = (tr("Offline") if not status.get("linked") else
                           tr("Crosses") if status.get("crosses") else
                           tr("Edge off") if status.get("edge_off") else
                           outcome_for_tile(state, False))
                parts.append(tr("{label}, {outcome}.").format(label=label, outcome=outcome))
            if self.tile_words.get(key):
                parts.append(self.tile_words[key])
            if self._can_resize(key):
                parts.append(tr("{name}: drag a corner to resize, or use Option and the arrow keys.").format(name=label))
            if self.cycle_enabled and key != self.own_id:
                sentence = (tr("{name} is in the shortcut's cycle.") if self.cycle.get(key, True) else
                            tr("{name} is out of the shortcut's cycle."))
                parts.append(sentence.format(name=label))
        return " ".join(parts) or tr("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 and not self.machine_picker):
            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 self.machine_picker or 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", [])
        map_state = state.get("state")
        if not state.get("crosses") and core_ways._rect_contact(own, tile) is None:
            map_state = "gap"
        outcome = outcome_for_tile(map_state, state.get("crosses"))
        if len(thirds) == 1:
            # Translators: {third} is one of the three sections along an edge.
            sentence = tr("{name}, {side} This Mac, {third} third. {outcome}.")
            position = tr(POSITION_WORDS[side])
            third = tr(THIRD_WORDS[thirds[0]])
            self.announce(sentence.format(name=name, side=position, third=third, outcome=outcome))
        else:
            sentence = tr("{name}, {side} This Mac. {outcome}.")
            position = tr(POSITION_WORDS[side])
            self.announce(sentence.format(name=name, side=position, outcome=outcome))

    @objc.python_method
    def announce_resize(self, key):
        name = self.labels.get(key, tr("Machine · {id}").format(id=key[-6:]))
        self.announce(tr("{name} resized.").format(name=name))

    @objc.python_method
    def _commit_resize(self, key):
        if self.on_layout_change:
            self.on_layout_change(self.tiles, key, snap=False)
        else:
            self.announce_resize(key)

    @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.setAnchorPoint_((0, 0))
            check.setPosition_((0, 0))
            check.setHidden_(True)
            cycle.addSublayer_(check)
            grip = Quartz.CAShapeLayer.layer()
            grip.setFillColor_(AppKit.NSColor.clearColor().CGColor())
            grip.setLineWidth_(1.5)
            grip.setLineCap_(Quartz.kCALineCapRound)
            grip.setZPosition_(23)
            grip.setHidden_(True)
            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().addSublayer_(grip)
            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
            self.resize_layers[key] = grip
        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):
        if frame[3] < 32:
            return frame[1] + 11
        if frame[3] < 44:
            return frame[1] + max(12, frame[3] - 21)
        return frame[1] + (4 if frame[3] < 56 else 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):
        return _beside_display_numbers(self._title_without_numbers(key, frame),
                                       self.display_number_layers.get(key, ()))

    @objc.python_method
    def _title_without_numbers(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 height < 32:
            return x + 5, self._title_top(frame), max(1, width - 10), max(1, height - 12)
        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 height < 32:
            return x + width - 15, y + 1, 10, 10
        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 _can_resize(self, key):
        tile = self.tiles.get(key)
        state = self.states.get(key, {})
        return (tile is not None and not self.read_only
                and not any(tile.get(flag) or state.get(flag) for flag in ("left_out", "shelved", "dormant"))
                and tile.get("in_use") is not False and state.get("in_use") is not False
                and (key == self.fixed_machine_id or not tile.get("display_offsets")))

    @staticmethod
    def _resize_rect(frame):
        x, y, width, height = frame
        size = min(RESIZE_GRIP, width, height)
        return x + width - size, y + height - size, size, size

    @objc.python_method
    def _resize_hit(self, point):
        # An edge third's 5 px band wins over a grip it overlaps, as on the PC map.
        if self._third_hit(point):
            return None
        frames, _scale = self._map()
        for key, frame in reversed(list(frames.items())):
            if not self._can_resize(key):
                continue
            x, y, width, height = self._resize_rect(frame)
            # A tile drawn smaller than the grip has its whole grip inside the band of the side it
            # shares; the hit area keeps the full grip size, reaching out past the corner.
            if x <= point.x <= x + max(width, RESIZE_GRIP) and y <= point.y <= y + max(height, RESIZE_GRIP):
                return key
        return None

    @staticmethod
    def _resize_cursor():
        cursor = getattr(AppKit.NSCursor, "resizeNorthWestSouthEastCursor", None)
        return cursor() if cursor is not None else AppKit.NSCursor.crosshairCursor()

    @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
            elsewhere = (self.machine_picker and self.own_id != self.fixed_machine_id
                         and state in ("gap", "between", "set-elsewhere", "set_elsewhere"))
            gap = not elsewhere and state in ("gap", "set-elsewhere", "set_elsewhere", "between", "overlap")
            hover = key == self.hovered and not self.keyboard_focus
            _set_layer_frame_if_changed(tile, _rect(frame))
            tile.setBorderWidth_(2 if selected and self.machine_picker else 1 if is_own else 2 if selected or gap else 1)
            theme.tint(tile, background="well" if is_own else "panel",
                       border="ink_2" if selected and self.machine_picker else "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")
            numbered_frames = core_ways._display_frames(self.tiles[key])
            numbers = identify_screens.display_numbers(self.tiles[key])
            badges = self.display_number_layers.setdefault(key, [])
            while len(badges) < len(numbered_frames):
                badge = _text_layer(theme.TYPE["note"], "ink_2")
                badge.setCornerRadius_(theme.RADIUS["field"])
                theme.tint(badge, background="panel", foreground="ink_2")
                self.layer().insertSublayer_below_(badge, title)
                badges.append(badge)
            for index, badge in enumerate(badges):
                badge.setHidden_(index >= len(numbered_frames))
                if index >= len(numbered_frames):
                    continue
                screen = numbered_frames[index]
                display = screen.get("display") or "0"
                badge.setString_(str(numbers[display]))
                scale_x = frame[2] / self.tiles[key]["w"]
                scale_y = frame[3] / self.tiles[key]["h"]
                left = frame[0] + (screen["x"] - self.tiles[key]["x"]) * scale_x
                top = frame[1] + (screen["y"] - self.tiles[key]["y"]) * scale_y
                bottom = frame[1] + (screen["y"] + screen["h"] - self.tiles[key]["y"]) * scale_y
                if frame[3] < 32:
                    badge.setFontSize_(7)
                    badge_frame = ((left + 5, top + 1), (12, 8))
                elif frame[3] < 44:
                    badge.setFontSize_(8)
                    badge_frame = ((left + 5, top + 1), (14, 10))
                elif frame[3] < 56:
                    badge.setFontSize_(10)
                    badge_frame = ((left + 5, bottom - 15), (16, 14))
                else:
                    badge.setFontSize_(theme.TYPE["note"])
                    badge_frame = ((left + 5, bottom - 23), (20, 18))
                _set_layer_frame_if_changed(badge, badge_frame)
            title.setString_(self.labels.get(key, tr("Machine · {id}").format(id=key[-6:])))
            title_size = 10 if frame[3] < 32 else theme.TYPE["body"]
            if title.fontSize() != title_size:
                title.setFont_(theme.font(title_size, 600))
                title.setFontSize_(title_size)
            title.setWrapped_(False)
            title.setTruncationMode_(Quartz.kCATruncationEnd)
            _set_layer_frame_if_changed(title, _rect(self._title_rect(key, frame)))
            status_info = self.states.get(key, {})
            status = (tr("{name} · macOS").format(name=status_info.get('machine_name') or platform.node().split('.')[0] or tr("This Mac"))
                      if is_own else
                      tr("{platform} · {status}").format(platform=status_info.get('platform', tr("Computer")),
                                                          status=tr("Linked") if status_info.get('linked') else tr("Offline")))
            if key in self.older:
                status = tr("Beamer {version} · only sees which side").format(version=status_info.get('version') or '1.5.2')
            if inactive:
                status = tr("Not in use")
            status = self.tile_words.get(key) or status
            state_layer.setString_(status)
            state_layer.setAlignmentMode_(Quartz.kCAAlignmentLeft)
            _set_layer_frame_if_changed(state_layer, _rect(_beside_display_numbers(
                (frame[0] + 24, frame[1] + 35, max(1, frame[2] - 32), 16), badges)))
            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_kind = ("offline" if not is_own and not status_info.get("linked") else
                            "crosses" if crosses and (status_info.get("corner_ways") or status_info.get("wrap_sides")
                                                       or status_info.get("notch_way")) else
                            "edge_off" if status_info.get("edge_off") or status_info.get("unpicked") else
                            "tile")
            outcome = {"offline": tr("Offline"), "crosses": tr("Crosses"), "edge_off": tr("Edge off")}.get(
                outcome_kind, outcome_for_tile(state, crosses, is_own))
            if is_own:
                outcome = ""
            outcome_layer.setString_(tr("Set elsewhere") if elsewhere and not is_own else outcome)
            _set_layer_frame_if_changed(
                outcome_layer, _rect(_beside_display_numbers(
                    (frame[0] + 8, frame[1] + frame[3] - 22, max(1, frame[2] - 16), 14), badges)))
            outcome_layer.setHidden_(frame[3] < 56)
            theme.tint(outcome_layer, foreground="ink_3" if elsewhere else "signal" if outcome_kind == "crosses" else
                       "amber" if state in ("gap", "between", "set-elsewhere", "set_elsewhere", "overlap") 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 or any(
                AppKit.NSIntersectsRect(dot.frame(), badge.frame()) for badge in badges if not badge.isHidden()))
            word = self.tile_words.get(key)
            theme.tint(dot, background=("signal" if word in (tr("Desk"), tr("Own")) else "ink_3") if word else
                       "ink_3" 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")
            check = cycle_layer.sublayers()[0]
            check.setHidden_(not ticked)
            tick_scale = self._cycle_box(frame)[2] / CYCLE_BOX
            check.setAffineTransform_(Quartz.CGAffineTransformMakeScale(tick_scale, tick_scale))
            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)
            grip = self.resize_layers[key]
            grip.setHidden_(not (self._can_resize(key) and (selected or key == self.hovered)))
            gx, gy, gw, gh = self._resize_rect(frame)
            path = Quartz.CGPathCreateMutable()
            for inset in (4, 8):
                Quartz.CGPathMoveToPoint(path, None, gx + gw - inset, gy + gh - 3)
                Quartz.CGPathAddLineToPoint(path, None, gx + gw - 3, gy + gh - inset)
            grip.setPath_(path)
            theme.tint(grip, stroke="ink_2" if selected else "ink_3")
        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_(tr("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):
            if self.read_only:
                continue
            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():
            title_rect = self._title_rect(key, frame)
            name = self.labels.get(key, tr("Machine · {id}").format(id=key[-6:]))
            if _text_width(name, self.label_for_tile[key].font()) > title_rect[2]:
                self.addToolTipRect_owner_userData_(AppKit.NSMakeRect(*title_rect), self, 2)
            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 self.machine_picker or 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)
        self._draw_wraps(frames)

    @objc.python_method
    def _draw_wraps(self, frames):
        """A wrap-around edge: a seam along This Mac's own side, with a label inside the tile naming
        where it leads and, on a left or right side, an arrow pointing out of it. A side kept while
        Edge is off is a faint dashed seam and says so."""
        wanted = {}
        own = frames.get(self.own_id)
        if own is not None:
            pads = self._pad_corners(frames)
            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
                opacity = (1.0 if state.get("linked", True) else 0.55) * (1.0 if self.machine_picker or peer == self.selected else 0.7)
                for kept, sides in ((False, state.get("wrap_sides", [])), (True, state.get("kept_sides", []))):
                    for side in sides:
                        wanted[(peer, side)] = (kept, opacity)
        for key in list(self.wrap_layers):
            if key not in wanted:
                for layer in self.wrap_layers.pop(key):
                    layer.removeFromSuperlayer()
        for (peer, side), (kept, opacity) in wanted.items():
            if (peer, side) not in self.wrap_layers:
                seam = Quartz.CAShapeLayer.layer()
                seam.setFillColor_(AppKit.NSColor.clearColor().CGColor())
                seam.setLineCap_(Quartz.kCALineCapRound)
                arrow = Quartz.CAShapeLayer.layer()
                arrow.setFillColor_(AppKit.NSColor.clearColor().CGColor())
                arrow.setLineWidth_(1.6)
                arrow.setLineCap_(Quartz.kCALineCapRound)
                arrow.setLineJoin_(Quartz.kCALineJoinRound)
                text = _text_layer(theme.TYPE["eyebrow"], "signal", Quartz.kCAAlignmentLeft)
                for layer in (seam, arrow, text):
                    layer.setZPosition_(21)
                    self.layer().addSublayer_(layer)
                self.wrap_layers[(peer, side)] = (seam, arrow, text)
            seam, arrow, text = self.wrap_layers[(peer, side)]
            x, y, width, height = own
            horizontal = side in ("top", "bottom")
            first, last = {"left": ("top_left", "bottom_left"), "right": ("top_right", "bottom_right"),
                           "top": ("top_left", "top_right"), "bottom": ("bottom_left", "bottom_right")}[side]
            start = (x if horizontal else y) + (13 if first in pads else 2)
            end = (x + width if horizontal else y + height) - (13 if last in pads else 2)
            fixed = {"left": x, "right": x + width, "top": y, "bottom": y + height}[side]
            path = Quartz.CGPathCreateMutable()
            if end > start:
                Quartz.CGPathMoveToPoint(path, None, *((start, fixed) if horizontal else (fixed, start)))
                Quartz.CGPathAddLineToPoint(path, None, *((end, fixed) if horizontal else (fixed, end)))
            seam.setPath_(path)
            seam.setLineWidth_(2 if kept else 4)
            seam.setLineDashPattern_([3, 5] if kept else None)
            theme.tint(seam, stroke="signal")
            seam.setOpacity_(0.35 if kept else opacity)
            ink = "ink_3" if kept else "signal"
            label = "wrap kept, Edge off" if kept else f"wraps to {self.labels.get(peer, 'another machine')}"
            text.setString_(label)
            theme.tint(text, foreground=ink)
            text.setOpacity_(0.8 if kept else opacity)
            theme.tint(arrow, stroke=ink)
            arrow.setOpacity_(0.7 if kept else opacity)
        if own is not None:
            self._place_wrap_labels(own, [(side, *self.wrap_layers[(peer, side)][1:]) for peer, side in wanted])

    @objc.python_method
    def _place_wrap_labels(self, own, marks):
        """Each wrap label gets its own row below This Mac's name and status line, so none ever lands on
        them or on another label: a top side's row nearest the name, a bottom side's nearest the
        bottom edge, left and right in between, sharing one row when both fit. Sides that say the
        same thing, as when one machine wraps on several, share one label naming them. Rows that do
        not fit the tile are hidden; the seam still shows the side."""
        x, y, width, height = own
        header = y + (51 if height >= 72 else 30)
        first, last = header + 4, y + height - 22
        order = {"merged": 0, "top": 0, "left": 1, "right": 2, "bottom": 3}
        marks = sorted(marks, key=lambda mark: order[mark[0]])
        said = {}
        for side, arrow, text in marks:
            said.setdefault(text.string(), []).append((side, arrow, text))
        marks = []
        for words, same in said.items():
            marks.append(same[0])
            if len(same) > 1:
                side, arrow, text = same[0]
                # The sides named, else counted, else the plain words: the seams still show which.
                merged = next((option for option in (f"{words} · {', '.join(mark[0] for mark in same)}",
                                                     f"{words} · {len(same)} sides")
                               if _text_width(option, text.font()) + 2 <= width - 24), words)
                text.setString_(merged)
                marks[-1] = ("merged", arrow, text)
                for _side, other_arrow, other_text in same[1:]:
                    other_text.setHidden_(True)
                    other_arrow.setHidden_(True)
        rows = []
        for side, arrow, text in sorted(marks, key=lambda mark: order[mark[0]]):
            label_width = min(math.ceil(_text_width(text.string(), text.font())) + 2,
                              max(1, width - (52 if side in ("left", "right") else 24)))
            mark = (side, arrow, text, label_width)
            if (side == "right" and rows and len(rows[-1]) == 1 and rows[-1][0][0] == "left"
                    and 26 + rows[-1][0][3] + 8 + label_width + 26 <= width):
                rows[-1].append(mark)
            else:
                rows.append([mark])
        room = 0 if height < 56 or last < first else int((last - first) // 18) + 1
        wanted = {"top": first, "merged": first, "left": y + height / 2 + 10, "right": y + height / 2 + 10,
                  "bottom": last}
        tops = []
        for row in rows[:room]:
            tops.append(max(min(last, wanted[row[0][0]]), tops[-1] + 18 if tops else first))
        for index in range(len(tops) - 1, -1, -1):
            tops[index] = min(tops[index], last if index == len(tops) - 1 else tops[index + 1] - 18)
        for index, row in enumerate(rows):
            for side, arrow, text, label_width in row:
                shown = index < len(tops)
                text.setHidden_(not shown)
                arrow.setHidden_(not shown or side not in ("left", "right"))
                if not shown:
                    continue
                label_y = tops[index]
                label_x = (x + 26 if side == "left" else x + width - 26 - label_width if side == "right"
                           else x + width - 12 - label_width)
                _set_layer_frame_if_changed(text, ((label_x, label_y), (label_width, 16)))
                arrow_path = Quartz.CGPathCreateMutable()
                if side in ("left", "right"):
                    direction = -1 if side == "left" else 1
                    tip, centre = (x + 16 if side == "left" else x + width - 16), label_y + 8
                    Quartz.CGPathMoveToPoint(arrow_path, None, tip - direction * 9, centre)
                    Quartz.CGPathAddLineToPoint(arrow_path, None, tip, centre)
                    Quartz.CGPathMoveToPoint(arrow_path, None, tip - direction * 4, centre - 4)
                    Quartz.CGPathAddLineToPoint(arrow_path, None, tip, centre)
                    Quartz.CGPathAddLineToPoint(arrow_path, None, tip - direction * 4, centre + 4)
                arrow.setPath_(arrow_path)

    @objc.python_method
    def _pad_corners(self, frames):
        """Every corner of This Mac's tile that carries a pad, whichever machine's it is."""
        return {corner for peer, state in self.states.items()
                if peer != self.own_id and peer in frames and state.get("in_use") is not False
                for corner in state.get("corner_ways", [])}

    @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 = self._pad_corners(frames)
        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=None):
        if peer is None and self.machine_picker:
            return [segment for key in self.tiles if key != self.own_id
                    for segment in self._third_segments(frames, key)]
        peer, own = self.selected if peer is None else peer, 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)
        for peer in dict.fromkeys(segment[0] for segment in segments):
            state = self.states.get(peer, {})
            if state.get("edge_off") or not state.get("picked_thirds"):
                continue
            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):
        if self.read_only:
            return None
        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", [])
        # Translators: third names are one of the three sections of a screen edge.
        detail = tr("click to turn it off") if third in picked else tr("click to turn it on")
        return tr("{name} third: {detail}").format(name=name, detail=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
                for corner in state.get("corner_ways", []):
                    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()
                # The 7 pt bracket centred on the vertex, as in the 16 pt pad around it.
                Quartz.CGPathMoveToPoint(chevron_path, None, px - 3.5 * dx, py + 3.5 * dy)
                Quartz.CGPathAddLineToPoint(chevron_path, None, px - 3.5 * dx, py - 3.5 * dy)
                Quartz.CGPathAddLineToPoint(chevron_path, None, px + 3.5 * dx, py - 3.5 * dy)
                chevron.setPath_(chevron_path)
            selected = self.machine_picker or 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 or self.dragging.get("resize"):
            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 (not self.read_only and self.selected not in (None, self.own_id, self.fixed_machine_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.read_only or self.selected == self.fixed_machine_id or 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.resize_layers.get(key), self.focus_layer]
        layers.extend(self.display_layers.get(key, ()))
        layers.extend(self.display_number_layers.get(key, ()))
        for layer in layers:
            if layer is not None:
                layer.removeAllAnimations()

    @objc.python_method
    def toggle_cycle(self, key):
        if self.read_only or 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._resize_hit(point) is not None:
            self._resize_cursor().set()
        elif self._third_hit(point):
            AppKit.NSCursor.pointingHandCursor().set()
        elif hovered is not None and self.machine_picker:
            AppKit.NSCursor.pointingHandCursor().set()
        elif hovered is not None and hovered != self.fixed_machine_id and not self.read_only:
            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):
        if _data == 2:
            key = self.tile_at(point)
            return self.labels.get(key, tr("Machine · {id}").format(id=(key or "")[-6:]))
        hit = self._third_hit_segment(point)
        if hit:
            return self._third_tooltip(*hit)
        return tr("In the shortcut's cycle")

    def accessibilityPerformPress(self):
        if self.machine_picker and self.selected in self.tiles:
            self.select_tile(self.selected)
            return True
        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)
        resize_key = self._resize_hit(point)
        if resize_key is not None:
            frames, scale = self._map()
            original = copy.deepcopy(self.tiles[resize_key])
            frame = frames[resize_key]
            self._stop_tile_animations(resize_key)
            self.keyboard_focus = False
            self.selected = resize_key
            self.last_announcement = ""
            self.third_pressed = None
            self.dragging = {"key": resize_key, "resize": True, "original": original,
                             "pointer_x": point.x, "pointer_y": point.y, "scale": scale,
                             "map_x": frame[0] - original["x"] * scale,
                             "map_y": frame[1] - original["y"] * scale, "moved": False}
            # Picking a machine in profiles mode switches the viewed layout. A grip edits the
            # current picture instead; This Mac's move-selection handler also resets selection.
            if self.on_select and not self.machine_picker and resize_key != self.fixed_machine_id:
                self.on_select(resize_key)
            self._resize_cursor().set()
            self._draw(False)
            return
        hit_key = self.tile_at(point)
        picking = self.machine_picker and hit_key is not None and hit_key != self.own_id
        self.third_pressed = None if self.read_only or picking else 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 not self.machine_picker and not self.read_only and key != self.own_id and self.on_rename:
            self.selected = key
            self.on_rename(key)
            return
        if event.clickCount() > 1 and not self.machine_picker and key == self.own_id:
            self.announce(tr("Rename this Mac on Overview."))
            return
        if self._cycle_hit(key, point):
            self.toggle_cycle(key)
            return
        if key == self.fixed_machine_id:
            if self.machine_picker:
                self.select_tile(key)
            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)
        if self.read_only:
            self._draw(False)
            return
        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("resize"):
            original = self.dragging["original"]
            self.tiles[key] = core_ways.resize_from_drag(
                original, (point.x - self.dragging["pointer_x"]) / scale,
                (point.y - self.dragging["pointer_y"]) / scale)
            self.dragging["moved"] = self.tiles[key] != original
            self._draw(False)
            return
        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"]
        if self.dragging.get("resize"):
            self.dragging = None
            AppKit.NSCursor.arrowCursor().set()
            self._draw(False)
            if moved:
                self._commit_resize(key)
            return
        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.fixed_machine_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 self.machine_picker and event.keyCode() in (36, 49):
            self.select_tile(self.selected)
            return
        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 (not self.read_only and not self.machine_picker and 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):
                if self.machine_picker:
                    self.selected = ordered[next_index]
                    self._draw(False)
                else:
                    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 self.read_only and vector is not None:
            return
        if vector is not None and event.modifierFlags() & AppKit.NSEventModifierFlagOption:
            if not self._can_resize(self.selected):
                return
            tile = self.tiles[self.selected]
            long_side = max(tile["w"], tile["h"])
            resized = core_ways.resize_tile(tile, long_side + (vector[0] + vector[1]) * long_side / 8)
            if resized != tile:
                self.tiles[self.selected] = resized
                self._draw(True)
                self._commit_resize(self.selected)
            return
        if vector is None or self.selected is None or self.selected == self.fixed_machine_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):
    """A single accessible resistance slider with live pressure on the same 0–500 track."""

    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

    @objc.python_method
    def setup(self):
        self.setTranslatesAutoresizingMaskIntoConstraints_(False)
        self.minimum_height = self.heightAnchor().constraintEqualToConstant_(self.HEIGHT)
        self.minimum_height.setActive_(True)
        self.setWantsLayer_(True)
        root = self.layer()
        root.setCornerRadius_(3)
        root.setMasksToBounds_(True)
        theme.tint(root, background="ground", border="rule")
        root.setBorderWidth_(1)
        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 = tr("Other machine")
        self.setAccessibilityElement_(True)
        self.setAccessibilityRole_(AppKit.NSAccessibilitySliderRole)
        self.setAccessibilityLabel_(tr("Resistance"))
        self.setAccessibilityValue_(self._value)
        self._update_accessibility_description()
        return self

    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 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
        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 set_other_name(self, name):
        name = name or tr("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=None):
        other_name = other_name or tr("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))
        if pressure > 0:
            sentence = tr("Current pressure {pressure} of {value} pointer units at the {edge} edge.")
            self._accessibility_description = sentence.format(
                pressure=pressure, value=self._value, edge=tr(core_ways.EDGE_NAMES[self._active_edge]))
        else:
            self._accessibility_description = tr("No push. Current pressure is 0 of {value} pointer units.").format(
                value=self._value)
        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
        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 = tr("This Mac").upper()
        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