Enum ResolvedSurfaceMode 

pub enum ResolvedSurfaceMode {
    Unknown,
    Opaque,
    Translucent,
    RefusedTranslucent,
}

App-facing resolved surface mode — the read-only outward half of the Mode B seam whose setter is deliberately absent (see the comment above): what the platform actually gave this process, not what the host asked for.

resolved_surface_mode answers ResolvedSurfaceMode::Unknown until a shell publishes (no surface yet, or the desktop preview, which has no Mode B host seam), then Opaque/Translucent — or ResolvedSurfaceMode::RefusedTranslucent, the case this exists for: the host declared Mode B and the platform resolved the surface opaque anyway (no matching CompositeAlphaMode; see docs/NATIVE_WIDGETS_ARCHITECTURE.md’s Mode-B paragraph). frust’s paint side degrades to the Mode A contract on its own, but the host’s native-sibling z-order was fixed at build time, so a sibling arranged behind the surface is invisible and untappable. Branch on ResolvedSurfaceMode::translucency_refused to render a deliberate fallback instead of a dead rect.

This is a poll, not a subscription — the same contract as set_app_theme’s slot: reading it subscribes to nothing and a change never wakes a frame by itself. Read it during a rebuild (or paint/an event handler) on the UI thread, exactly where you’d read any other process-global shell state, and if the answer must change your UI’s shape, write it into your own state so the normal dirty path runs.

use frust::{ResolvedSurfaceMode, resolved_surface_mode};

// A native-widget slot deciding whether its platform sibling can actually
// be seen this frame.
let native_sibling_visible = match resolved_surface_mode() {
    ResolvedSurfaceMode::RefusedTranslucent => false,
    ResolvedSurfaceMode::Unknown
    | ResolvedSurfaceMode::Opaque
    | ResolvedSurfaceMode::Translucent => true,
};

What the platform actually gave us, as opposed to what the host declared (SurfaceMode) — see the module docs’ The RESOLVED slot.

Read via resolved_surface_mode (re-exported by the frust facade); published only by the two mobile shells, once per frame, from the same value that drives RenderRoot::set_surface_translucent.

Variants

Unknown

No shell has published a resolution yet: no surface exists, or the running shell doesn’t participate (the desktop preview shell never publishes — it has no Mode B host seam). Not a synonym for Opaque: app code that must distinguish “opaque” from “don’t know yet” (e.g. deferring a fallback decision to the next frame) can.

Opaque

The live surface came up opaque, and that is what the host asked for — the ordinary Mode A contract every pre-platform-views app runs under.

Translucent

The live surface came up translucent: frust clears to a transparent base and platform_view punches its slot rects (Mode B).

RefusedTranslucent

The refusal (translucencyRefused): the host declared Mode B, and the platform resolved the surface opaque anyway — no matching CompositeAlphaMode (the engine’s premultiplied output has no other refusal case; see docs/NATIVE_WIDGETS_ARCHITECTURE.md’s Mode-B paragraph).

frust’s own paint side degrades correctly (opaque clear, no hole punch), but the host’s native-sibling z-order was fixed at build time: a sibling arranged behind the now-opaque surface is invisible and untappable. That is what this variant exists to tell app/plugin code — so it can render its own fallback content instead of a dead rect.

Implementations

impl ResolvedSurfaceMode

pub const fn resolve( declared: SurfaceMode, resolved_translucent: bool, ) -> ResolvedSurfaceMode

The pure mapping publish_resolved_surface_mode applies, split out so it is testable without touching the process-global slots: a resolved translucent surface is Translucent; a resolved opaque one is RefusedTranslucent when the host declared translucency and Opaque when it didn’t.

Never returns Unknown — that variant means “nobody published”, which is the slot’s initial state, not a resolution.

pub const fn translucency_refused(self) -> bool

true only for RefusedTranslucent — the one-liner a native-widget fallback branches on (if frust::resolved_surface_mode().translucency_refused() { ... }).

pub const fn is_translucent(self) -> bool

true only for Translucent, i.e. the frames being painted right now really do follow the Mode B contract. Both refusal and plain opacity answer false; so does Unknown, since no surface has reported in.

Trait Implementations

impl Clone for ResolvedSurfaceMode

fn clone(&self) -> ResolvedSurfaceMode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ResolvedSurfaceMode

impl Debug for ResolvedSurfaceMode

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

Formats the value using the given formatter.

impl Default for ResolvedSurfaceMode

fn default() -> ResolvedSurfaceMode

Returns the “default value” for a type.

impl Eq for ResolvedSurfaceMode

impl PartialEq for ResolvedSurfaceMode

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for ResolvedSurfaceMode