Enum FloatingSurfaceClientMessage 

pub enum FloatingSurfaceClientMessage {
    Hello {
        version: u16,
    },
    ActionMarkers {
        markers: Vec<PaintedActionMarker>,
    },
    MoveDeviceDisplay {
        request: u64,
        placement: DeviceDisplayMove,
    },
    DeviceShellOutcome {
        request: u64,
        result: Result<Value, String>,
    },
    AllowHostShell,
    OpenCaptureStudio {
        mode: CaptureStudioProtocolMode,
    },
    Present {
        request: FloatingSurfaceProtocolRequest,
    },
    UpdateRegion {
        id: String,
        region: [f64; 4],
    },
    SurfaceGeometry {
        id: String,
        rect: [f64; 4],
        content_rect: [f64; 4],
        input_rect: Option<[f64; 4]>,
    },
    SourceCleared {
        id: String,
    },
    DestinationPresented {
        id: String,
    },
    Suspend {
        id: String,
        rect: [f64; 4],
        content_rect: [f64; 4],
    },
    Dismiss {
        id: String,
    },
    SetCaptureProtection {
        protected: bool,
        generation: Option<u64>,
    },
    PaintStream {
        payload: String,
        page: [f64; 4],
        scale: f64,
    },
    PaintCapable,
    OpenTabBeside {
        target: Option<String>,
        background: bool,
        instance: Option<u64>,
    },
    CloseTab {
        instance: Option<u64>,
    },
    ReopenClosedTab,
    CycleTab {
        forward: bool,
        instance: Option<u64>,
    },
    PlaceNextWindowBeside {
        background: bool,
        instance: Option<u64>,
    },
    Toolbar {
        toolbar: Option<WindowToolbar>,
        instance: Option<u64>,
    },
    EditLocation {
        instance: Option<u64>,
    },
    WindowOffer {
        offer: WindowOffer,
        instance: Option<u64>,
    },
    OpenSearch {
        instance: Option<u64>,
        opening: SearchOpening,
    },
    OpenAppSearch {
        instance: Option<u64>,
        request: SearchRequest,
    },
    DescribeHistory {
        changes: Vec<HistoryChangeFacts>,
    },
    SelectionCapable,
    SendTo {
        to: Vec<Recipient>,
        attached: Vec<Attached>,
        text: String,
        bounds: Option<[f64; 4]>,
    },
    SearchRecipients {
        request: u64,
        query: String,
    },
    WindowResource {
        resource: Option<ActionResource>,
    },
    Pointed {
        request: u64,
        control: Option<PointedControl>,
    },
    PickAnswered {
        request: u64,
        answer: PickAnswer,
    },
    WindowRecord {
        record: String,
        kind: String,
        instance: Option<u64>,
    },
    Embeds {
        embeds: Vec<DeclaredEmbed>,
        instance: Option<u64>,
    },
    SharedWindows {
        shared: Vec<SharedWindow>,
    },
    WindowTargets {
        targets: Vec<WindowTarget>,
        instance: Option<u64>,
    },
    SidewaysWheel {
        travel: f64,
    },
}

App → shell lifecycle. Suspend is the reversible half of an attached ↔ desktop handoff: the authenticated native surface and its renderer stay warm while its pixels return to the app. Dismiss is deliberately permanent and reserved for hang-up, navigation-end, or an explicit close.

Variants

Hello

The first frame on every connection: the shell-ui version this app speaks ([FLOATING_SURFACE_PROTOCOL_VERSION]). Its shape never changes, so a shell of any version reads it.

Fields

version: u16

ActionMarkers

Complete primary-surface marker inventory from a successfully presented SDK frame. The host resolves surface and workspace from launch custody.

Fields

markers: Vec<PaintedActionMarker>

MoveDeviceDisplay

A typed Settings request on the existing authenticated app connection.

Fields

request: u64

placement: DeviceDisplayMove

DeviceShellOutcome

Bounded response to a trusted owner operation on this same connection.

Fields

request: u64

result: Result<Value, String>

AllowHostShell

Terminal asks for the existing host-shell permission prompt.

OpenCaptureStudio

Ask the trusted session shell to show its ordinary user-confirmed chooser. This shares the same authenticated channel as floating surfaces so a separately hosted app and an embedded app have identical PiP UX.

Fields

mode: CaptureStudioProtocolMode

Present

Fields

request: FloatingSurfaceProtocolRequest

UpdateRegion

Fields

id: String

region: [f64; 4]

SurfaceGeometry

Live desktop placement of an app-owned secondary surface. The shell clamps it to the combined output before presentation.

Fields

id: String

rect: [f64; 4]

Full native-window bounds.

content_rect: [f64; 4]

Shared placement/hit geometry inside that transparent window.

input_rect: Option<[f64; 4]>

Interactive frame excluding shadow; absent means legacy window input.

SourceCleared

The primary window has presented a frame with the transferred pixels removed. The shell may now move its proxy/native surface away from the source rect without ever exposing two copies.

Fields

id: String

DestinationPresented

The primary app window has presented the first frame containing the reattached surface. Until this arrives, the compositor keeps a frozen copy of the last desktop-owned pixels in exactly the same place, so hiding the native secondary can never expose a blank transfer frame.

Fields

id: String

Suspend

Fields

id: String

rect: [f64; 4]

content_rect: [f64; 4]

Dismiss

Fields

id: String

SetCaptureProtection

Withhold every window of this app from captures — screenshots, recordings, screen sharing, remote viewers — or stop doing so. The local display is unaffected. The shell applies it to windows mapped later too, and drops it when this connection closes.

Fields

protected: bool

generation: Option<u64>

PaintStream

One frame of the page this app’s window shows, as a paint stream (tilo_paint_stream::wire::Payload, base64): the session shares it with web members as a display list they draw, instead of as video. page is where the page sits in the window, in logical pixels, and scale the window’s buffer scale, so the session can place input. Sent only while the shell has asked for it (FloatingSurfaceHostMessage::PaintKeyframe).

Fields

payload: String

page: [f64; 4]

scale: f64

PaintCapable

This app can stream its window’s page (sent once): the shell may ask it to with FloatingSurfaceHostMessage::PaintKeyframe.

OpenTabBeside

Open another instance of this app as a desktop tab right after this app’s own tab (see crate::shell_tabs). target is a URI the app’s manifest declares, or None for an empty instance. instance is the record instance the shell launched this process for; the shell only uses it to find a tab that already shows this same app.

Fields

target: Option<String>

background: bool

instance: Option<u64>

CloseTab

Close this app’s own tab through the desktop’s tab lifecycle.

Fields

instance: Option<u64>

ReopenClosedTab

Reopen the workspace’s most recently closed tab.

CycleTab

Show the next (forward) or previous tab of the window group this app’s tab is in: Ctrl+Tab or Ctrl+Shift+Tab that no widget of the app used. The shell steps only while that tab is the focused one.

Fields

forward: bool

instance: Option<u64>

PlaceNextWindowBeside

The next window this app maps lands as a tab right after this one.

Fields

background: bool

instance: Option<u64>

Toolbar

The slots this app shows in its window’s bar (crate::window_toolbar), or none: sent whenever they change. instance is the record instance the shell launched this process for, which names the tab, as for Self::OpenTabBeside.

Fields

toolbar: Option<WindowToolbar>

instance: Option<u64>

EditLocation

Turn this app’s editable location in its window’s bar into a field, as a click on it does (the app’s Ctrl+L).

Fields

instance: Option<u64>

WindowOffer

What this app’s window offers its bar’s own controls: what the search acts on in place and the open search’s count, and the History control (crate::window_toolbar::WindowOffer). Sent whenever it changes; the bar answers with FloatingSurfaceHostMessage::ToolbarEvent.

Fields

offer: WindowOffer

instance: Option<u64>

OpenSearch

Open the search in this app’s window’s bar, as a click on its control does (the app’s Ctrl+F), or with its replacement field holding the keyboard (the app’s Ctrl+H).

Fields

instance: Option<u64>

opening: SearchOpening

OpenAppSearch

Open the session’s search on this app, the way the app asked (crate::search::SearchRequest): Ctrl+K, a search button, or one of its actions whose arguments the search asks for. Inside a session there is one search, the shell’s; the app opens none of its own.

Fields

instance: Option<u64>

request: SearchRequest

DescribeHistory

Describe these changes of the resource whose History is open: the shell asks the model on this device and answers with FloatingSurfaceHostMessage::HistoryDescriptions. The app holds no model and needs none.

Fields

changes: Vec<HistoryChangeFacts>

SelectionCapable

This app answers FloatingSurfaceHostMessage::ShareSelection and FloatingSurfaceHostMessage::PointAt (sent once). An app that never says so is never asked.

SendTo

The person sent what the box beside this app’s context menu held: a message to these recipients about these subjects. The shell makes a new agent when one recipient is one, opens or makes the one conversation they share, and posts the message there — as the person. The app’s identity is the launcher’s, never the message’s.

Fields

to: Vec<Recipient>

attached: Vec<Attached>

What the message carries besides its words, as the chips named it.

text: String

bounds: Option<[f64; 4]>

Where the box stood in this window, in its logical coordinates ([x0, y0, x1, y1]): the conversation it opens stands there.

SearchRecipients

The person typed query into the box’s recipient field: the shell answers with FloatingSurfaceHostMessage::Recipients, from the one search every part of the desk shares.

Fields

request: u64

query: String

WindowResource

The resource this window shows (the first it publishes), sent when it changes: the desktop’s own menus for the window (its window menu) attach it, as the app’s own menus do. None when it publishes none.

Fields

resource: Option<ActionResource>

Pointed

The answer to FloatingSurfaceHostMessage::PointAt request: the control at that point, None where there is none.

Fields

request: u64

control: Option<PointedControl>

PickAnswered

The answer to FloatingSurfaceHostMessage::Pick request, read from this window’s retained tree (crate::pick_wire::answer).

Fields

request: u64

answer: PickAnswer

WindowRecord

The record this window shows, as its route names it (empty for the app’s own record of the workspace), and the kind of resource it keeps: the desktop lists the window among those a person may share (crate::window_share). Sent once per connection.

Fields

record: String

kind: String

instance: Option<u64>

Embeds

Where this window wants other apps’ views of resources drawn, at most crate::window_share::MAX_EMBEDS (crate::window_share::declare): sent whenever they change. The shell answers with FloatingSurfaceHostMessage::EmbedStates. Only the sharing app’s embeds are drawn.

Fields

embeds: Vec<DeclaredEmbed>

instance: Option<u64>

SharedWindows

The windows this app shares (crate::window_share::publish_shared), sent whenever they change, so the desktop offers “Stop sharing” on them. Only the sharing app’s are taken.

Fields

shared: Vec<SharedWindow>

WindowTargets

The controls of this window’s own content, as the app’s accessibility tree exports them (crate::window_targets), at most crate::window_targets::MAX_TARGETS: what a session, a test or an agent finds them by name and presses (FloatingSurfaceHostMessage::PressTarget). Sent whenever the tree they come from changes, never per frame. instance names the tab, as for Self::Toolbar.

Fields

targets: Vec<WindowTarget>

instance: Option<u64>

SidewaysWheel

The app under the pointer could not scroll sideways with this wheel event: the shell pans the window strip under it by travel logical pixels, positive toward later windows, by the same rules it applies to a wheel over its own canvas. Sent for every event of a gesture the app left to the shell, and never for one it took, so a gesture is never split between app and strip. An app outside a session’s shell has no such connection and keeps every wheel.

Fields

travel: f64

Trait Implementations

impl Clone for FloatingSurfaceClientMessage

fn clone(&self) -> FloatingSurfaceClientMessage

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FloatingSurfaceClientMessage

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for FloatingSurfaceClientMessage

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for FloatingSurfaceClientMessage

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

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 FloatingSurfaceClientMessage