Skip to content

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

32.9 KB
Raw Blame
"""Live previews for the Design page: the notch and edge animations, played in the settings window by
the very classes that draw them on screen, so a preview cannot drift from the real thing. The crossing
effects' previews at the end of the file do the same through effects_overlay's replay.

Each renderer is hosted in a view rather than a screen-level panel. Only where it draws, and how it
is shown and hidden, is redirected; everything else runs as it does on screen. PreviewFeed stands in
for the controller: the live settings, so a change shows at once, with a scripted push instead of a
trackpad. The script builds pressure, goes through, keeps animating for the chosen time and rests,
on a loop. PreviewLoop plays a notch tile only while the pointer is over it, and only while the Design
page is showing.

Main thread only. A failing preview disables itself as the real renderer does; nothing depends on it.
"""

import time
import types
import math

import AppKit
import Quartz
import objc

import crossing
from core import effects
import effects_overlay
from frame_clock import PREVIEW_MAX_RATE, FrameClock
import motion
import notch_beam
import notch_island
from core.i18n import N_
import theme
import tokens

PUSH_S = 1.8
REST_S = 1.0
FALLBACK_NOTCH = (185.0, 32.0)


def preview_frame(elapsed, after):
    """(pressure, phase) `elapsed` seconds into the loop: pressure builds for PUSH_S and goes
    through, the crossing plays for `after` seconds, then everything rests for REST_S and it starts
    again. Phases are push, after and rest."""
    t = elapsed % (PUSH_S + after + REST_S)
    if t < PUSH_S:
        return (t / PUSH_S) ** 1.6, "push"
    return 0.0, "after" if t < PUSH_S + after else "rest"


def notch_size():
    """This Mac's notch as (width, height), or a typical MacBook's when it has none at the top of
    the desktop, so the Notch previews still show what the styles look like."""
    try:
        geometry = notch_island.notch_geometry()
    except Exception:
        geometry = None
    if geometry is None:
        return FALLBACK_NOTCH
    left, right, _top, height = geometry
    return (right - left, height)


class PreviewFeed:
    """What a hosted renderer reads from its controller. `overrides` pins crossing settings for one
    preview, such as the style a tile shows, while the rest follow the live settings."""

    def __init__(self, controller, **overrides):
        self.controller = controller
        self.overrides = overrides
        self.level = 0.0
        self.crossing = types.SimpleNamespace(touching=False)

    @property
    def cfg(self):
        cfg = self.controller.cfg
        if not self.overrides:
            return cfg
        return types.SimpleNamespace(crossing=dict(cfg.crossing, **self.overrides))

    def crossing_pressure_now(self):
        return self.level

    def _current_desktop_bounds(self):
        """A preview draws in its own small scene, not on the desktop, so there are no displays
        to cut its band to."""
        return None


class _Panel:
    """The panel calls the renderers make, answered by a view in the settings window."""

    def __init__(self, view, set_hidden):
        self.view = view
        self.set_hidden = set_hidden

    def contentView(self):
        return self.view

    def backingScaleFactor(self):
        window = self.view.window()
        return window.backingScaleFactor() if window is not None else 2.0

    def setFrame_display_(self, frame, _display):
        self.view.setFrame_(frame)

    def orderFrontRegardless(self):
        self.set_hidden(False)

    def orderOut_(self, _sender):
        self.set_hidden(True)


def hosted_notch(base):
    """NotchBeam or NotchIsland, drawing into a PreviewScreen instead of over the notch."""

    class HostedNotch(base):
        # On the window's screen, not the desktop: the window's palette decides which variant draws.
        dark_appearance = staticmethod(theme.is_dark)

        def __init__(self, feed, logger, screen):
            super().__init__(feed, logger)
            self.screen = screen

        def _show(self):
            if self.panel is None:
                width, height = self.screen.notch
                self._build((0.0, width, 0.0, height))
            self.panel.orderFrontRegardless()
            self.visible = True
            return True

        def _panel(self, frame):
            stage = Quartz.CALayer.layer()
            stage.setBounds_(((0.0, 0.0), (frame.size.width, frame.size.height)))
            stage.setGeometryFlipped_(True)
            stage.setAnchorPoint_((0.5, 1.0))
            self.screen.hold(stage)
            return _Panel(self.screen, stage.setHidden_), stage

    return HostedNotch


class HostedNotchScene(effects_overlay.EffectsCanvas):
    """A complete notch crossing with the real hosted NotchBeam or NotchIsland layer tree."""

    @objc.python_method
    def setup(self, base, controller, logger, style, colour, notch):
        self.setTranslatesAutoresizingMaskIntoConstraints_(False)
        self.widthAnchor().constraintEqualToAnchor_multiplier_(self.heightAnchor(), 2.0).setActive_(True)
        self.setWantsLayer_(True)
        self.layer().setCornerRadius_(theme.RADIUS["field"])
        self.layer().setMasksToBounds_(True)
        self.logger = logger
        self.playing_since = None
        self.style = style
        self.colour = colour
        self.notch = notch
        self.controller = controller
        self.still_at = 1.9
        self.after = lambda: controller.cfg.crossing.get("notch_after_ms", 1200) / 1000.0
        self.feed = PreviewFeed(controller, glow_colour=colour(), notch_style=style)
        self.renderer = hosted_notch(base)(self.feed, logger, self._layer_host(notch))
        self.renderer._show()
        self.stage = self.renderer.screen.stage
        self.stage.removeFromSuperlayer()
        with notch_island._no_actions():
            self.stage.setAnchorPoint_((0.0, 0.0))
            self.stage.setPosition_((0.0, 0.0))
            self.stage.setAffineTransform_(Quartz.CGAffineTransformIdentity)
        self.painter = lambda ctx, width, height: self.paint_frame(ctx, width, height, self._time(),
                                                                   self._live())
        return self

    @staticmethod
    def _layer_host(notch):
        host = PreviewScreen.alloc().initWithFrame_(AppKit.NSMakeRect(0, 0, 600, 540))
        host.setup(notch)
        host.setFrame_(AppKit.NSMakeRect(0, 0, 600, 540))
        host.arrange()
        return host

    @objc.python_method
    def _time(self):
        since = self.playing_since
        elapsed = None if since is None else time.monotonic() - since
        return effects.preview_time(self.still_at, elapsed, effects_overlay.reduce_motion())

    @objc.python_method
    def _live(self):
        return (self.playing_since is not None and time.monotonic() >= self.playing_since
                and not effects_overlay.reduce_motion())

    @objc.python_method
    def paint_frame(self, ctx, width, height, at=None, live=False):
        """Paint a deterministic frame; callers may supply `t` for offline judging renders."""
        t = self._time() if at is None else at
        t %= effects.PREVIEW_LOOP_S
        current_colour = self.colour()
        dark = theme.is_dark()
        feel = self.controller.cfg.crossing
        pace = feel.get("effect_pace", effects.pace(feel.get("effect_length")))
        size = feel.get("effect_size", "medium")
        size_fraction = feel.get("effect_size_fraction")
        fx = effects.preview_effect("glow")
        crop = effects.still_view(fx, "notch", size, pace, size_fraction)
        scene = effects.preview_still_scene(fx, t, "notch", effects_overlay.palette(current_colour),
                                            dark=dark, pace=pace, effect_size=size, live=live,
                                            view_width=crop[2], effect_size_fraction=size_fraction,
                                            notch_geometry=self.notch)
        scene["pens"] = []
        effects_overlay.draw_scene(Quartz, ctx, scene, width, height, "notch", dark, crop=crop, pointer=11.0)
        self._set_renderer_frame(t, current_colour, dark)
        x, y, w, h, _radius = scene["notch"]
        stage_bounds = self.stage.bounds()
        stage_width = stage_bounds.size.width
        scene_w, scene_h = crop[2:]
        scale = min(width / scene_w, height / scene_h)
        Quartz.CGContextSaveGState(ctx)
        try:
            Quartz.CGContextTranslateCTM(ctx, (width - scene_w * scale) / 2.0,
                                          (height - scene_h * scale) / 2.0)
            Quartz.CGContextScaleCTM(ctx, scale, scale)
            Quartz.CGContextTranslateCTM(ctx, -crop[0], -crop[1])
            Quartz.CGContextClipToRect(ctx, ((crop[0], crop[1]), (scene_w, scene_h)))
            # The renderer's layers are a real notch's size, as the scene's effects are drawn on a
            # screen PREVIEW_REAL times its own and shrunk.
            Quartz.CGContextTranslateCTM(ctx, x + w / 2.0, y)
            Quartz.CGContextScaleCTM(ctx, 1.0 / effects.PREVIEW_REAL, 1.0 / effects.PREVIEW_REAL)
            Quartz.CGContextTranslateCTM(ctx, -stage_width / 2.0, 0.0)
            self.stage.renderInContext_(ctx)
        finally:
            Quartz.CGContextRestoreGState(ctx)

    @objc.python_method
    def _set_renderer_frame(self, t, colour, dark):
        """Set the existing renderer's layers directly from the shared crossing clock."""
        renderer = self.renderer
        push_start, cross_at = effects._P_PUSH, effects._P_CROSS
        after = self.after()
        pressure_end = cross_at
        if t < push_start:
            level, flash, elapsed = 0.0, 0.0, 0.0
        elif t < pressure_end:
            u = min(1.0, max(0.0, (t - push_start) / (pressure_end - push_start)))
            level, flash, elapsed = (1.0 - math.cos(math.pi * u)) / 2.0, 0.0, 0.0
        else:
            elapsed = t - cross_at
            phase = notch_island.breakthrough_phase(elapsed, after)
            level, flash = (1.0, phase[1]) if phase is not None else (0.0, 0.0)
        if isinstance(renderer, notch_beam.NotchBeam):
            self._set_beam_frame(renderer, level, flash, elapsed, colour, dark, after, t)
        else:
            self._set_island_frame(renderer, level, flash, elapsed, after)

    @staticmethod
    def _set_beam_frame(renderer, level, flash, elapsed, colour, dark, after, t):
        base = notch_beam.LAP * 0.3
        if t < effects._P_CROSS:
            position = (base + notch_beam.LAP * max(0.0, t - effects._P_PUSH)
                        / notch_beam.turn_seconds(level)) % notch_beam.LAP
        else:
            crossed = (base + notch_beam.LAP * (effects._P_CROSS - effects._P_PUSH)
                       / notch_beam.turn_seconds(1.0)) % notch_beam.LAP
            travel = notch_beam.lap_finish(crossed, after)
            position = (crossed + travel * notch_island.ease_out(elapsed / max(after, 0.001))) % notch_beam.LAP
        spans = notch_beam.comet_segments(position)
        with notch_island._no_actions():
            for gradient in renderer.gradients:
                gradient.setColors_(notch_beam.palette_colours(colour, closed=True, dark=dark))
            for segments in renderer.comets:
                for layer, (start, end) in zip(segments, spans):
                    layer.setHidden_(end - start < 0.002)
                    layer.setStrokeStart_(start)
                    layer.setStrokeEnd_(end)
            renderer.island.setOpacity_(min(1.0, level * 20.0))
            renderer.beam.setOpacity_(min(1.0, level + flash))
            renderer.bloom.setOpacity_(min(1.0, level * 0.8 + flash * 0.6))
            renderer.halo.setOpacity_(max(0.0, 1.0 - elapsed / notch_beam.HALO_S) * 0.9 if elapsed > 0 else 0.0)

    @staticmethod
    def _set_island_frame(renderer, level, flash, elapsed, after):
        grow_w = level * tokens.ISLAND["grow_width"]
        grow_d = level * tokens.ISLAND["grow_depth"]
        with notch_island._no_actions():
            renderer.island.removeAllAnimations()
            renderer.rim.removeAllAnimations()
            renderer.island.setPath_(renderer._island_path(grow_w, grow_d))
            renderer.rim.setPath_(renderer._rim_path(grow_w, grow_d))
            renderer.trace.setPath_(renderer._rim_path(grow_w, grow_d))
            renderer.island.setOpacity_(1.0 if level > 0.0 else 0.0)
            renderer.rim.setStrokeColor_(notch_island._colour(notch_island.FLASH_RIM) if flash else
                                          notch_island._colour("signal"))
            renderer.rim.setOpacity_(min(1.0, 0.25 + level * 0.9 + flash) if level or flash else 0.0)
            renderer.rim.setShadowOpacity_(min(1.0, level * 0.75 + flash))
            renderer.rim.setShadowRadius_(7.0 + flash * 7.0)
            if elapsed > 0.0:
                progress = min(1.0, elapsed / max(after, 0.001))
                head = notch_island.trace_head(progress, after)
                renderer.trace.setStrokeStart_(max(0.0, head - notch_island.TRACE_LENGTH))
                renderer.trace.setStrokeEnd_(min(1.0, head))
                renderer.trace.setOpacity_(1.0)
            else:
                renderer.trace.setOpacity_(0.0)
            meter = max(0.0, min(1.0, (grow_d - tokens.ISLAND["meter_after_depth"]) / 8.0))
            renderer._set_meter(level, meter)
            renderer.meter.setOpacity_(meter)


def notch_crossing_still(base, colour, logger, controller=None, notch=None):
    """A notch style tile backed by its real renderer and the shared two-screen crossing scene."""
    if controller is None:
        cfg = types.SimpleNamespace(crossing={"notch_after_ms": 1200, "glow_colour": colour()})
        controller = types.SimpleNamespace(cfg=cfg)
    style = "beam" if issubclass(base, notch_beam.NotchBeam) else "island"
    view = HostedNotchScene.alloc().initWithFrame_(AppKit.NSMakeRect(0, 0, 1, 1))
    if notch is None:
        notch = (effects.PREVIEW_NOTCH["w"], effects.PREVIEW_NOTCH["h"])
    return view.setup(base, controller, logger, style, colour, notch)


def hosted_edge(base):
    """The app's EdgeGlow, drawing its band along the right side of a PreviewScreen."""

    class HostedEdge(base):
        # On the window's screen, not the desktop: the window's palette decides which variant draws.
        dark_appearance = staticmethod(theme.is_dark)

        def __init__(self, feed, logger, screen):
            super().__init__(feed, logger)
            self.screen = screen

        def _ensure_panel(self):
            if self.panel is not None:
                return
            band = AppKit.NSView.alloc().initWithFrame_(AppKit.NSMakeRect(0, 0, 1, 1))
            band.setWantsLayer_(True)
            self.screen.addSubview_(band)
            self.fill = Quartz.CAGradientLayer.layer()
            band.layer().addSublayer_(self.fill)
            self.comet = Quartz.CAGradientLayer.layer()
            self.panel = _Panel(band, band.setHidden_)

        def _band_frame(self, band):
            bounds = self.screen.bounds()
            return AppKit.NSMakeRect(bounds.size.width - band, 0, band, bounds.size.height)

    return HostedEdge


class PreviewScreen(AppKit.NSView):
    """The little desktop a preview plays on: a wallpaper-toned ground so a black notch tab reads
    against it and, for a notch preview, the notch itself drawn over whatever the renderer puts
    there, as the hardware covers it. The renderer's stage is scaled so the notch takes about 60% of
    the width, and never larger than life."""

    def layout(self):
        objc.super(PreviewScreen, self).layout()
        self.arrange()

    @objc.python_method
    def setup(self, notch=None):
        self.setTranslatesAutoresizingMaskIntoConstraints_(False)
        self.setWantsLayer_(True)
        layer = self.layer()
        layer.setCornerRadius_(theme.RADIUS["field"])
        layer.setMasksToBounds_(True)
        layer.setBorderWidth_(1)
        theme.tint(layer, border="rule")
        self.ground = Quartz.CAGradientLayer.layer()
        theme.tint(self.ground, colours=["edge", "well"])
        self.ground.setStartPoint_((0.5, 1.0))
        self.ground.setEndPoint_((0.5, 0.0))
        layer.addSublayer_(self.ground)
        self.notch = notch
        self.stage = None
        self.cutout = None
        if notch is not None:
            self.cutout = Quartz.CAShapeLayer.layer()
            self.cutout.setFillColor_(AppKit.NSColor.blackColor().CGColor())
            layer.addSublayer_(self.cutout)
        return self

    @objc.python_method
    def hold(self, stage):
        if self.stage is not None:
            self.stage.removeFromSuperlayer()
        self.stage = stage
        if self.cutout is not None:
            self.layer().insertSublayer_below_(stage, self.cutout)
        else:
            self.layer().addSublayer_(stage)
        self.arrange()

    @objc.python_method
    def arrange(self):
        if getattr(self, "ground", None) is None:
            return
        bounds = self.bounds()
        width, height = bounds.size.width, bounds.size.height
        scale = min(1.0, width * 0.6 / self.notch[0]) if self.notch is not None else 1.0
        Quartz.CATransaction.begin()
        Quartz.CATransaction.setDisableActions_(True)
        try:
            self.ground.setFrame_(bounds)
            if self.stage is not None:
                self.stage.setPosition_((width / 2.0, height))
                self.stage.setAffineTransform_(Quartz.CGAffineTransformMakeScale(scale, scale))
            if self.cutout is not None:
                notch_width, notch_height = self.notch[0] * scale, self.notch[1] * scale
                radius = 7.0 * scale
                # Taller than the notch by its radius, so only the bottom corners show rounded.
                rect = ((width / 2.0 - notch_width / 2.0, height - notch_height), (notch_width, notch_height + radius))
                self.cutout.setPath_(Quartz.CGPathCreateWithRoundedRect(rect, radius, radius, None))
        finally:
            Quartz.CATransaction.commit()


HOVER_INTENT_S = 0.1


def on_screen(view):
    """Whether any of `view` can be seen: in a window on screen and not covered, not hidden, and not
    scrolled out of its page."""
    window = view.window()
    if window is None or not window.isVisible() or view.isHiddenOrHasHiddenAncestor():
        return False
    if not window.occlusionState() & AppKit.NSWindowOcclusionStateVisible:
        return False
    visible = view.visibleRect()
    return visible.size.width > 0 and visible.size.height > 0


class PreviewLoop:
    """Plays the page's hosted renderers from one clock: the tile the pointer is over, else the
    tiles set `resting`. Every other tile holds a still, the push part way in, and a tile that starts
    playing goes on from that push rather than from nothing."""

    HOLD = 0.7

    def __init__(self, controller, host=None):
        """`host` is a view on screen whenever the loop runs, the page itself, to time it by: a
        view's display link stops while the view is hidden, as a tile's is in the other mode."""
        self.controller = controller
        self.players = []
        self.running = False
        self.resting = ()
        self.hovered = None
        self.hovered_at = 0.0
        self.clock = None if host is None else FrameClock(host, self._tick, PREVIEW_MAX_RATE)

    def add(self, feed, renderer, update, screen):
        """`update(kind, pressure)` passes an event to `renderer` the way the app's crossing
        feedback would. The renderer's own timer is swapped for a FrameClock on `screen`."""
        renderer.timer = FrameClock(screen, lambda: renderer._tick(None), PREVIEW_MAX_RATE)
        self.players.append(types.SimpleNamespace(feed=feed, renderer=renderer, update=update, screen=screen,
                                                  started_at=None, phase=None, quarter=0))
        if self.clock is None:
            self.clock = FrameClock(screen, self._tick, PREVIEW_MAX_RATE)

    def owns(self, view):
        return any(player.screen is view for player in self.players)

    def set_resting(self, screens):
        self.resting = tuple(screens)

    def hover(self, view):
        """`view` is the preview of the tile under the pointer, one of this loop's or not, or None."""
        self.hovered = view
        self.hovered_at = time.monotonic()
        # Under Reduce Motion nothing plays, so the clock has nothing to drive.
        if self.running and self.owns(view) and self.clock is not None and not effects_overlay.reduce_motion():
            self.clock.start()

    def start(self):
        if self.running:
            self.sync_clock()
            return
        self.running = True
        self.repaint()
        if self.owns(self.hovered) and self.clock is not None:
            self.clock.start()

    def sync_clock(self):
        if self.clock is None:
            return
        wanted = (self.running and not effects_overlay.reduce_motion()
                  and any(on_screen(player.screen) and
                          (player.screen is self.hovered or player.screen in self.resting)
                          for player in self.players))
        if wanted:
            self.clock.start()
        else:
            for player in self.players:
                if player.started_at is not None:
                    player.started_at = None
                    self._hold(player)
            self.clock.stop()

    def stop(self):
        if not self.running:
            return
        self.running = False
        if self.clock is not None:
            self.clock.stop()
        for player in self.players:
            player.started_at = None
            player.feed.level = 0.0
            player.feed.crossing.touching = False
            try:
                player.renderer._hide()
                player.renderer.timer.stop()
            except Exception:
                pass

    def repaint(self):
        """Draws every tile that is not playing again, as a colour or palette change needs."""
        for player in self.players:
            if player.started_at is None:
                self._hold(player)

    def _wanted(self, player):
        # A pointer only passing over, or any under Reduce Motion, leaves the resting tile playing.
        if (self.hovered is not None and time.monotonic() - self.hovered_at >= HOVER_INTENT_S
                and not effects_overlay.reduce_motion()):
            return player.screen is self.hovered
        return player.screen in self.resting

    def _hold(self, player):
        feed, renderer = player.feed, player.renderer
        feed.level = self.HOLD
        feed.crossing.touching = True
        try:
            # Left mid-breakthrough, a renderer would freeze its flash, halo and run-off into the
            # still and snap to the end of the crossing when it next played.
            for name, value in (("cross_at", None), ("halo_at", None), ("flash_at", None), ("flare", 0.0),
                                ("kick", 0.0), ("held", 0.0), ("finish", 0.0)):
                if hasattr(renderer, name):
                    setattr(renderer, name, value)
            player.update("pressure", self.HOLD)
            # Drawn once and left: a moving light part way along, at full strength rather than
            # easing up to it from nothing.
            if hasattr(renderer, "finish"):
                renderer.centre = 0.5
            if hasattr(renderer, "cross_travel"):
                renderer.position = notch_beam.LAP * 0.3
                renderer.strength = self.HOLD
            if hasattr(renderer, "drawn_at"):
                renderer.drawn_at = None
            renderer._draw()
            renderer.timer.stop()
        except Exception:
            pass

    def _tick(self):
        if not self.running:
            return
        now = time.monotonic()
        after = self.controller.cfg.crossing["notch_after_ms"] / 1000.0
        for player in self.players:
            playing = self._wanted(player) and on_screen(player.screen)
            if not playing:
                if player.started_at is not None:
                    player.started_at = None
                    motion.cross_fade(player.screen)
                    self._hold(player)
                continue
            if player.started_at is None:
                # Where the script's push reaches the held still's pressure.
                player.started_at = now - PUSH_S * self.HOLD ** (1 / 1.6)
                player.phase, player.quarter = "push", min(3, int(4 * self.HOLD))
            level, phase = preview_frame(now - player.started_at, after)
            quarter = min(3, int(4 * level)) if phase == "push" else 0
            crossed = phase == "after" and player.phase == "push"
            ticked = quarter > player.quarter
            player.phase, player.quarter = phase, quarter
            player.feed.level = level
            player.feed.crossing.touching = phase == "push"
            if crossed:
                player.update("cross", 1.0)
            elif phase == "push" and level > 0.0:
                player.update("tick" if ticked else "pressure", level)
        self.sync_clock()


class TileStack(AppKit.NSView):
    """A tile's picture that is one of several views laid over each other, only one shown: Glow and
    Beam's still, or at the notch, where the notch style plays in their place, that style's own
    hosted preview."""

    def layout(self):
        objc.super(TileStack, self).layout()
        if self.shown is not None:
            self.shown.setFrame_(self.bounds())
            self.shown.setNeedsLayout_(True)

    @objc.python_method
    def setup(self, children, height=84):
        self.setTranslatesAutoresizingMaskIntoConstraints_(False)
        self.widthAnchor().constraintEqualToAnchor_multiplier_(self.heightAnchor(), 2.0).setActive_(True)
        self.children = list(children)
        for child in self.children:
            child.setTranslatesAutoresizingMaskIntoConstraints_(False)
            AppKit.NSLayoutConstraint.deactivateConstraints_([
                c for c in child.constraints()
                if c.firstItem() == child and c.secondItem() in (None, child)
            ])
            self.addSubview_(child)
        self.shown = None
        self.show(self.children[0])
        return self

    @objc.python_method
    def show(self, child):
        if child is self.shown:
            return
        if self.shown is not None:
            motion.cross_fade(self)
        self.shown = child
        for other in self.children:
            other.setHidden_(other is not child)
        self.setNeedsLayout_(True)

    @objc.python_method
    def current(self):
        return self.shown


class _HoverOwner(AppKit.NSObject):
    def mouseEntered_(self, _event):
        self.entered()

    def mouseExited_(self, _event):
        self.exited()


class TileHover:
    """The hovered tile plays after intent and restores its still on leaving. Crossings begin
    with approach; shortcut arrivals resume their still. Reduce Motion keeps the still."""

    def __init__(self, loop):
        self.loop = loop
        self.owners = []
        self.current = None
        # What plays for the tile under the pointer: its preview, or the one a TileStack shows.
        self.target = None
        self.clock = None

    def track(self, tile, preview):
        owner = _HoverOwner.alloc().init()
        owner.entered = lambda: (tile.set_tile_state(hovered=True), self.enter(preview))
        owner.exited = lambda: (tile.set_tile_state(hovered=False), self.leave(preview))
        options = (AppKit.NSTrackingMouseEnteredAndExited | AppKit.NSTrackingActiveInActiveApp
                   | AppKit.NSTrackingInVisibleRect)
        tile.addTrackingArea_(AppKit.NSTrackingArea.alloc().initWithRect_options_owner_userInfo_(
            AppKit.NSZeroRect, options, owner, None))
        tile._tile_hover_owner = owner
        # A tracking area does not keep its owner.
        self.owners.append(owner)

    def enter(self, preview):
        if self.current is preview:
            return
        self.stop()
        self.current = preview
        target = self.target = preview.current() if isinstance(preview, TileStack) else preview
        self.loop.hover(target)
        if self.loop.owns(target) or effects_overlay.reduce_motion():
            return
        # A pointer passing over on its way elsewhere leaves the tiles it crosses still.
        target.playing_since = time.monotonic() + HOVER_INTENT_S
        self.clock = FrameClock(target, self._tick, PREVIEW_MAX_RATE)
        self.clock.start()

    def sync_clock(self):
        if self.clock is None:
            return
        if on_screen(self.target) and not effects_overlay.reduce_motion():
            self.clock.start()
        else:
            self.clock.stop()

    def _tick(self):
        self.sync_clock()
        if self.clock is not None and self.clock.is_alive():
            self.target.setNeedsDisplay_(True)

    def leave(self, preview):
        if preview is self.current:
            self.stop()

    def stop(self):
        preview, self.current, self.target = self.target, None, None
        self.loop.hover(None)
        if self.clock is not None:
            self.clock.stop()
            self.clock = None
        if preview is not None and getattr(preview, "playing_since", None) is not None:
            if time.monotonic() > preview.playing_since:
                motion.cross_fade(preview)
            preview.playing_since = None
            preview.setNeedsDisplay_(True)


def edge_update(renderer):
    step = crossing.Step
    return lambda kind, level: renderer.update(kind, step(pressure=level, mac_edge="right", region=(0, 0, 1, 1)))


def notch_update(renderer):
    return lambda kind, _level: renderer.update(kind)


# The crossing effects' previews: effects.preview_scene drawn by effects_overlay.draw_scene, the same
# replay the overlay uses on screen. Every tile shows one still frame at the place the page's Show at
# chooses, and plays the full journey while TileHover says the pointer is over it.
STAGE_METHODS = (("edge", N_("Edge")), ("corner", N_("Corner")), ("notch", N_("Notch")))


def _played(view, still_at, switch=False):
    """Crossings start at approach; shortcut arrivals resume their specimen frame."""
    since = view.playing_since
    return effects.preview_time(still_at, None if since is None else time.monotonic() - since,
                                effects_overlay.reduce_motion(), switch=switch)


def _live(view):
    return (view.playing_since is not None and time.monotonic() >= view.playing_since
            and not effects_overlay.reduce_motion())


def effect_still(effect_id, colour, logger, height=84, place=lambda: "edge", pace=lambda: 1.0,
                 effect_size=lambda: "medium", effect_size_fraction=lambda: None):
    """A tile's still frame of `effect_id`, in the selected colour, place, length and size."""
    view = effects_overlay.EffectsCanvas.alloc().initWithFrame_(AppKit.NSMakeRect(0, 0, 1, 1))
    view.setTranslatesAutoresizingMaskIntoConstraints_(False)
    view.widthAnchor().constraintEqualToAnchor_multiplier_(view.heightAnchor(), 2.0).setActive_(True)
    view.setWantsLayer_(True)
    view.layer().setCornerRadius_(theme.RADIUS["field"])
    view.layer().setMasksToBounds_(True)
    view.layer().setBorderWidth_(0)
    view.logger = logger
    view.playing_since = None

    def paint(ctx, width, height):
        fx = effects.preview_effect(effect_id)
        dark = theme.is_dark()
        where = place()
        current_pace, current_size, size_fraction = pace(), effect_size(), effect_size_fraction()
        held_at = effects.still_time(fx, where, current_size, current_pace, size_fraction)
        crop = effects.still_view(fx, where, current_size, current_pace, size_fraction)
        scene = effects.preview_still_scene(
            fx, _played(view, held_at), where, effects_overlay.palette(colour()), dark=dark,
            pace=current_pace, effect_size=current_size, live=_live(view), view_width=crop[2],
            effect_size_fraction=size_fraction)
        effects_overlay.draw_scene(Quartz, ctx, scene, width, height, where, dark, crop=crop, pointer=11.0)

    view.painter = paint
    return view


def switch_still(fx, colour, logger, height=84, pace=lambda: 1.0, effect_size=lambda: "medium",
                 effect_size_fraction=lambda: None):
    """A tile's still frame of what a switch plays: `fx()` is the Effect, asked when it draws, since
    Same as crossing follows the crossing style."""
    view = effect_still(None, colour, logger, height)

    def paint(ctx, width, height):
        dark = theme.is_dark()
        effect = fx()
        current_pace, current_size, size_fraction = pace(), effect_size(), effect_size_fraction()
        t = _played(view, effects.still_time(effect, "switch", current_size, current_pace, size_fraction), switch=True)
        crop = effects.still_view(effect, "switch", current_size, current_pace, size_fraction)
        scene = effects.preview_still_scene(
            effect, t, "switch", effects_overlay.palette(colour()), dark=dark, pace=current_pace,
            effect_size=current_size, live=_live(view), view_width=crop[2],
            effect_size_fraction=size_fraction)
        effects_overlay.draw_scene(Quartz, ctx, scene, width, height, "switch", dark,
                                   crop=crop, pointer=11.0)

    view.painter = paint
    return view