Enum FloatingSurfaceHostMessage 

pub enum FloatingSurfaceHostMessage {
    VersionMismatch {
        shell: u16,
    },
    DeviceDisplayMoveResult {
        request: u64,
        result: Result<(), String>,
    },
    DeviceShellOperation {
        request: u64,
        operation: DeviceShellOperation,
    },
    CaptureProtectionApplied {
        generation: u64,
        protected: bool,
    },
    HostShellAllowed {
        allowed: bool,
    },
    DesktopBounds {
        bounds: [f64; 4],
    },
    PaintKeyframe,
    PaintStop,
    ShareSelection {
        to: Vec<Recipient>,
    },
    Recipients {
        request: u64,
        rows: Vec<Recipient>,
    },
    PointAt {
        request: u64,
        point: [f64; 2],
    },
    Pick {
        request: u64,
        query: PickQuery,
    },
    ActivateTestId {
        test_id: String,
    },
    ToolbarEvent {
        event: ToolbarEvent,
        after_input: Option<u32>,
    },
    HistoryDescriptions {
        described: Vec<HistoryChangeDescription>,
    },
    PrepareSurface {
        id: String,
        token: String,
        rect: [f64; 4],
        content_rect: [f64; 4],
        transfer_covered: bool,
        coordinate_offset: [f64; 2],
    },
    Adopted {
        id: String,
        rect: [f64; 4],
    },
    Suspended {
        id: String,
    },
    Reattach {
        id: String,
    },
    Closed {
        id: String,
    },
    Appearance {
        theme: Option<ThemeDocument>,
        network_status: Option<HostNetworkStatus>,
        workspace_hue: Option<f32>,
        your_colour: Option<String>,
        workspace_sync: Option<WorkspaceSync>,
        corner_radius: Option<f32>,
    },
    DrawsEmbeds,
    EmbedStates {
        states: Vec<KeyedEmbedState>,
    },
    OpenWindows {
        windows: Vec<OpenWindow>,
    },
    WindowShareAsk {
        ask: Ask,
    },
    Unanswered {
        message: String,
        reason: String,
    },
    PressTarget {
        name: String,
        role: String,
        action: TargetAction,
    },
}

Shell → app lifecycle. The shell supplies one authoritative combined desktop coordinate space and explicitly acknowledges ownership changes; transports must not infer either from timing.

Variants

VersionMismatch

The shell speaks shell-ui version shell, not the app’s: its answer to a FloatingSurfaceClientMessage::Hello at another version, after which it closes the connection and updates whichever side is behind. Its shape never changes, so an app of any version reads it.

Fields

shell: u16

DeviceDisplayMoveResult

Admission/delivery result. The owner’s published topology confirms application.

Fields

request: u64

result: Result<(), String>

DeviceShellOperation

The authenticated device owner selected Terminal’s device-shell target. This requests its ordinary permission flow; it is not a grant.

Fields

request: u64

operation: DeviceShellOperation

CaptureProtectionApplied

Sent only after the compositor has installed the requested policy.

Fields

generation: u64

protected: bool

HostShellAllowed

The trusted desktop’s answer, after supervisor admission.

Fields

allowed: bool

DesktopBounds

Fields

bounds: [f64; 4]

PaintKeyframe

Someone started watching this app’s window: send its page as a paint stream, starting from a whole frame.

PaintStop

Nobody watches the window any more: stop capturing the page.

ShareSelection

The person pressed the desktop’s “ask an agent” chord over this app’s focused window: answer with FloatingSurfaceClientMessage::SendTo for what the box shows, or nothing when it shows none. Sent only to an app that announced FloatingSurfaceClientMessage::SelectionCapable.

to is whom the box opens to when the session names it — the one place a report goes — and empty when the person names whom it goes to.

Fields

to: Vec<Recipient>

Recipients

What the one search finds for FloatingSurfaceClientMessage::SearchRecipients request: agents, people and conversations to send to, the people and conversations this window is already in first.

Fields

request: u64

rows: Vec<Recipient>

PointAt

The person pointed at point of this app’s focused window, in its logical coordinates, to say what something is about (feedback on one control): answer with FloatingSurfaceClientMessage::Pointed. Sent only to an app that announced FloatingSurfaceClientMessage::SelectionCapable.

Fields

request: u64

point: [f64; 2]

Pick

The person is picking parts of the screen to report a problem with them, over this app’s window: answer query with FloatingSurfaceClientMessage::PickAnswered. Sent only to an app that announced FloatingSurfaceClientMessage::SelectionCapable.

Fields

request: u64

query: PickQuery

ActivateTestId

A development session’s test control activates the control whose test id is test_id in this app’s focused window, as an assistive technology activates a control: by what it is, never by where it is drawn. Sent to every window of the focused app; only the focused one acts. Never sent outside a development session’s test control.

Fields

test_id: String

ToolbarEvent

The person used this app’s slots in its window’s bar (FloatingSurfaceClientMessage::Toolbar), or the bar’s search or History control on its window (FloatingSurfaceClientMessage::WindowOffer).

after_input is the serial of the last input event (a key, a pointer button, a touch going down or up) the shell had sent this app’s process on its Wayland connection when the person used the bar: the app runs the event once it has handled that input, and before any input that came after it, so the two ways input reaches it keep the order the person used them in. None: the app had been sent no input.

Fields

event: ToolbarEvent

after_input: Option<u32>

HistoryDescriptions

What the changes of a FloatingSurfaceClientMessage::DescribeHistory did, as the model on this device described them. A change it could not describe is left out.

Fields

described: Vec<HistoryChangeDescription>

PrepareSurface

Authorises creation of one secondary toplevel. token is random and scoped to this authenticated connection; merely copying an app id can never gain overlay authority.

Fields

id: String

token: String

rect: [f64; 4]

content_rect: [f64; 4]

transfer_covered: bool

True when the shell has already installed a frozen, pixel-exact transfer frame for this surface. The app can hide its in-window copy immediately in that case; if capture failed it keeps drawing until the native surface acknowledges its first buffer.

coordinate_offset: [f64; 2]

App-local → desktop pointer-coordinate translation. Kept separate from clamped window geometry so a live drag can rebase without treating compositor clamping as pointer motion.

Adopted

Fields

id: String

rect: [f64; 4]

Suspended

The shell has hidden, but retained, the authenticated native surface. A later Present for the same connection/id resumes that exact surface instead of issuing a new capability or renderer.

Fields

id: String

Reattach

Fields

id: String

Closed

Fields

id: String

Appearance

Where and for whom the app’s window is shown (crate::theme::WindowAppearance): the temperature of the workspace holding it and the person’s colour. Sent when the app connects and again whenever either changes — a workspace switch, a new wallpaper, a window moved to another workspace, a colour chosen in Settings.

Fields

theme: Option<ThemeDocument>

The host’s configured palette; apps cannot read its settings file through their private sandbox configuration directory.

network_status: Option<HostNetworkStatus>

Absent on older hosts or launches without network access.

workspace_hue: Option<f32>

OKLCH degrees; absent while the workspace has no temperature.

your_colour: Option<String>

A presence hue by its stored name (PresenceHue::id).

workspace_sync: Option<WorkspaceSync>

Whether the workspace the window is in has synced with its host (crate::workspace_sync); absent for a workspace that syncs with no host, and from older shells.

corner_radius: Option<f32>

How round the shell draws the window’s corners, in logical pixels: its window radius while the window is framed among others, 0 while it is drawn edge to edge. Absent from older shells.

DrawsEmbeds

This shell draws the views windows embed of other apps’ resources (FloatingSurfaceClientMessage::Embeds): sent when the app connects, so the app draws no stand-in for them.

EmbedStates

How each embed of this app’s window is coming along, every one the shell draws: sent whenever one changes.

Fields

states: Vec<KeyedEmbedState>

OpenWindows

The windows the person has open on a record, for the sharing app’s picker: sent to the sharing app alone, whenever they change.

Fields

windows: Vec<OpenWindow>

WindowShareAsk

A window’s menu asked the sharing app to share it, or to stop sharing it.

Fields

ask: Ask

Unanswered

This shell does not answer that message: the app is told rather than left waiting on an answer that never came. message names the variant it sent, reason says what the session cannot do of it.

Fields

message: String

reason: String

PressTarget

The person, an agent or a test pressed the control name of role in this window’s content, which the app described in FloatingSurfaceClientMessage::WindowTargets. The app answers it as an assistive technology does on that control, through the same path; a control its window no longer shows presses nothing.

Fields

name: String

role: String

action: TargetAction

Implementations

impl FloatingSurfaceHostMessage

pub fn appearance(appearance: &WindowAppearance) -> FloatingSurfaceHostMessage

pub fn appearance_with_theme( appearance: &WindowAppearance, theme: &Theme, ) -> FloatingSurfaceHostMessage

The host’s configured theme and the window’s workspace appearance.

pub fn configured_theme(&self) -> Option<Theme>

Validate the host’s authored palette before applying it.

pub fn window_appearance(&self) -> Option<WindowAppearance>

What an Self::Appearance message says, None for any other. A colour this build does not name, or a hue that is not a number, counts as unsaid.

Trait Implementations

impl Clone for FloatingSurfaceHostMessage

fn clone(&self) -> FloatingSurfaceHostMessage

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FloatingSurfaceHostMessage

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for FloatingSurfaceHostMessage

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for FloatingSurfaceHostMessage

fn eq(&self, other: &FloatingSurfaceHostMessage) -> 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 FloatingSurfaceHostMessage

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 StructuralPartialEq for FloatingSurfaceHostMessage