The workspace’s presence as state of the frame: the host lends it around the
pass every widget gets whether or not it is drawn
(crate::widget::Widget::update), so a widget that is not on screen
still knows who is here.
The numbers a workspace’s participants are told apart by, resolved once from
its roster and read for each label shown. Cheap to rebuild whenever the
roster changes.
Which layer paints a peer’s pointer — a screen position, so only one
layer may place it correctly (an app painting a desktop coordinate into
its own window space is right only at the origin). The compositor owns
desktop-scoped pointers, since it alone spans the strip, chrome and gaps
between windows continuously; an app owns presence inside its own
content (caret, selection, typing swipe), since the compositor has no
access to the text.
What a subscriber still has to do after
PresenceCtx::apply_remote_presence folds a frame in, beyond the
presence stores. A subscriber with no document (the compositor) ignores it.
How long a person stays shown as composing after their last word: a draft under way is
said again as they type, so one who stops drops out shortly after, with no message.
Every colour a peer can be drawn in:the design language’s twelve
presence hues (PRESENCE_HUES, 30° apart) at the dark
material’s presence lightness and chroma (OKLCH L 0.74, C 0.14, gamut
mapped), as sRGB. Equal lightness and chroma, so no participant looks
more important than another; a closed ring rather than a hash over all
360 hues, so two people never land a few degrees apart.
Longest a peer’s pointer takes to glide to a newly heard position. Peers publish at ~30 Hz, so a
moving pointer glides over the gap between its last two samples and arrives as the next is due;
this caps the glide after a pause (crate::motion::Follow::GLIDE_MAX).
How long a peer’s pointer stays painted after it was last heard about.
Comfortably past the ~1s restate interval a live peer keeps, so this
notices a peer gone quiet rather than blinking one whose keepalive was
briefly delayed. See PresenceCtx::prune_pointers.
How long a still pointer keeps its name beside it. The pointer itself
stays until it goes quiet (super::POINTER_IDLE); the name is there to
say who is moving, and steps aside once they stop.
The face of someone here whose colour the workspace has not settled yet:
grey, which the presence palette paints neutral
(crate::tokens::colors::PresencePalette::of), never a ring colour
they would then change from.
Black or white ink for text on bg, by luma — a fixed white label is
unreadable on over half the peer palette (11 of 24 entries under 2:1,
palest 1.24:1 against white).
Paint pointers, then tethers, then pills — in that layer order so a
later peer’s halo can’t wash over an earlier peer’s name. viewport
bounds the pills; positions are assumed already filtered to it.
Paint already-resolved peer cursors in one coordinate space. On-screen
peers get moving dots and collision-free name pills; off-screen peers
become directional edge mist. This is the compositor-facing sibling of
draw_remote_presence, which resolves cursors from a PresenceCtx.
Paint every entry in presence.remote_cursors as a dot + name pill, for
non-shell apps drawing cross-process ghost cursors without reimplementing
the geometry. No viewport, so pills are de-overlapped but not clamped —
prefer draw_remote_presence, which keeps names on screen.
The one call the app makes each frame to render all cross-process peer
presence: on-screen peers get a dot + pill, off-screen peers get an edge
mist. viewport is the visible rect in the same (logical) space as
cursor positions.
Leave out the name of each pointer whose name tag would crowd a caret
tag with the same name (tags_crowd): one person, one tag, wherever
the two tags would sit within a tag height of each other. A pointer’s
tag is measured where it goes beside its pointer within viewport, as
super::draw_peer_cursors places a lone name. carets are in the
pointers’ coordinates. A pointer saying something keeps its bubble.
Place one name pill per peer so none overlap and none leaves viewport.
Each pill tries the four corners around its pointer, taking the first
clear of the viewport and every already-placed pill; only when all four
are taken does it slide along the vertical and get marked tethered.
Placement order is by position, not arrival, so a peer reconnecting
doesn’t reshuffle everyone else’s names.
PresenceKey::surface_pointer for this process’s own surface. The
coordinates a winit CursorMoved carries are surface-local, so this
is the only representation an app can provide.
The scope this process should publish its presence under — the workspace
it collaborates in, or None when it has no workspace. Read from
local_cluster_id, the
same value the routing address is built from, so the two cannot drift apart.
The frame round the work while following someone: their colour, a
chrome rule either side of area’s edge at the tile radius, as present
as the follow is (openness, 0 to 1).
This person’s own cursor-chat bubble while they type, beside their
pointer at at: the same bubble everyone else sees, in their colour and
under their name, sized for message and at least min_text_w wide,
kept inside bounds (left of or above the pointer near an edge).
Paints its shape and name and returns the bubble and the one-line rect
the caller puts its text field in.
The ring a speaking participant’s tile wears over its picture: their
colour, as strong as their voice is now (level, 0 to 1), a chrome rule
thick on each side of the tile’s edge.
A presence colour as the surfaces paint it: the (r, g, b) a person’s
colour travels as (user_color, a colour they chose), in the colour a
face or a row is drawn with.
The emoji text is, when it is exactly one (surrounding spaces aside):
what makes a cursor-chat message a reaction rather than words. The
:name: of an emoji the window’s workspace has is one too.
Whether a caret tag and a pointer tag of the same person read as one
name twice: their gap is within one tag height (the taller of the two),
so the eye takes them as one cluster.
Stable identity colour for a collaborator who has not chosen one: the
presence hue PresenceHue::of_identity derives from
their id, as the sRGB colour in PEER_PALETTE. A pure function of the
id alone: two hosts painting the same room see different peer sets
(everyone but themselves), so a colour derived from who’s present
couldn’t agree across machines.