Enum PresenceKey 

pub enum PresenceKey {
    Widget {
        path: Vec<PathSegment>,
    },
    Tab {
        id: String,
    },
    Workspace {
        id: String,
    },
    App {
        app: AppKind,
        sub: String,
    },
    View {
        data: Vec<u8>,
    },
    Pointer {
        space: PointerSpace,
    },
    Resource {
        app: String,
        id: String,
        kind: String,
    },
}

Variants

Widget

Fields

path: Vec<PathSegment>

Tab

Fields

id: String

Workspace

Fields

id: String

App

Fields

app: AppKind

sub: String

View

A participant’s broadcast ViewSubset, carried as its postcard encoding. PresencePayload has no View variant of its own, so it rides the existing presence frame inside the routing key instead. Bytes rather than a live struct because the key must stay Hash + Eq, which f64 viewport fields are not.

Fields

data: Vec<u8>

Pointer

A pointer position, together with the coordinate space it was measured in. Every other variant is a scope; the scope of a pointer is the space its numbers mean something in. See PointerSpace.

Fields

space: PointerSpace

Resource

Stable action resource scope. It deliberately carries no pixels: the receiving app resolves id against its own live layout.

Fields

app: String

id: String

kind: String

Implementations

impl PresenceKey

pub fn widget(path: &[PathSegment]) -> Option<PresenceKey>

The key of the widget at path, or None for one without a presence path.

pub fn scope_digest(&self) -> Option<[u8; 16]>

16-byte digest of this key’s canonical (postcard) encoding. Used where a scope does not fit a bounded carrier, e.g. the 64-byte LIVE_V1 anchor, whose Writer keys can name 130-byte block ids.

pub fn from_scope_digest(digest: [u8; 16]) -> PresenceKey

The stand-in key a receiver files a digest-addressed scope under (Widget{[DIGEST_KEY_FIELD, hex(digest)]}). An editor that draws remote presence also looks its own keys up in this form (Self::digest_form), so the two meet without the receiver ever knowing the full scope.

pub fn digest_form(&self) -> Option<PresenceKey>

This key’s digest-addressed stand-in (see Self::from_scope_digest).

pub fn view(subset: &ViewSubset) -> PresenceKey

Wrap a ViewSubset as a presence key for broadcast. Encode failure yields empty bytes, which Self::as_view decodes back to None — a dropped frame, never a panic.

pub fn as_view(&self) -> Option<ViewSubset>

Decode a broadcast ViewSubset back out of a PresenceKey::View. None for any other variant, or for View bytes that fail to decode.

pub fn for_local_workspace() -> Option<PresenceKey>

The scope this process should publish its presence under — the room it collaborates in, or None when it has no room. Read from local_cluster_id, the same value the routing address is built from, so the two cannot drift apart.

None when the room is the nil uuid: that value addresses nobody (CrdtRoute::is_addressable rejects it — an unminted room would otherwise make every unconfigured machine share one room). Fail closed.

pub fn desktop_pointer(room: impl Into<String>) -> PresenceKey

The key a pointer measured on room’s desktop is published under.

pub fn tile_pointer(room: impl Into<String>, tab: u64) -> PresenceKey

The key a pointer placed relative to the tile of room’s tab tab is published under.

pub fn surface_pointer(surface: impl Into<String>) -> PresenceKey

The key a pointer measured inside surface’s content is published under.

pub fn local_surface_pointer() -> PresenceKey

Self::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.

pub fn resource( app: impl Into<String>, id: impl Into<String>, kind: impl Into<String>, ) -> PresenceKey

pub fn pointer_space(&self) -> Option<PointerSpace>

The coordinate space a pointer arriving under this key is measured in, or None for a key that is not a pointer scope at all. Two older spellings still mean “desktop”: PresenceKey::Workspace, the session’s own desktop pointer republished per room, and Self::pointer_default, the tag the keyless capnp publishCursor path was re-keyed to.

pub fn scopes_a_desktop_pointer(&self) -> bool

Whether a pointer arriving under this key is a position on the desktop — one the compositor overlay places, above every window — rather than inside one window’s content. Reading the legacy keyless tag as an ordinary widget scope is what drew one person once per window: the broker hands every inbound frame to every app in the room, so each window claimed the pointer as its own. Deliberately about the scope, not the transport: a pointer with no key at all never comes through here and stays the window’s to paint.

pub fn pointer_default() -> PresenceKey

The canonical PresenceKey used to attribute a pointer publish that carries no explicit scope — the broker synthesises this well-known routing tag for the capnp publishCursor(x, y) path, which accepts no key of its own. Chosen as Widget { path: [] }: the empty widget path is unambiguously the “app root” scope (no live widget can occupy it), and its postcard encoding is stable and doesn’t depend on a string tag that could drift.

Trait Implementations

impl Clone for PresenceKey

fn clone(&self) -> PresenceKey

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PresenceKey

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for PresenceKey

fn deserialize<__D>( __deserializer: __D, ) -> Result<PresenceKey, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for PresenceKey

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for PresenceKey

fn eq(&self, other: &PresenceKey) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for PresenceKey

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for PresenceKey

impl StructuralPartialEq for PresenceKey