Struct PlatformViewView 

pub struct PlatformViewView { /* private fields */ }

Platform-view embedding (platform-views feature): reserve layout space for a native view (a map, a video player, …) composited alongside the frust surface. platform_view takes the "dev.frust.<Factory>"-style native factory name registered on each platform and returns a builder (PlatformViewView) over the params/size contract — flat-re-exported from frust-widgets so app code never names that crate directly.

Paint contract (Mode B)

Under Mode B compositing the frust surface itself is translucent, so any region this slot’s parent doesn’t paint over is a window straight through to the native view (or the OS background) behind it — this is the mechanism Mode B relies on, not a bug. Size/position a slot deliberately, and don’t rely on an unpainted sibling region staying opaque.

Mode B is selected by the generated host’s FRUST_TRANSLUCENT_SURFACE (Android)/translucentSurface (iOS) build-time constant — not from Rust: that constant drives, in one host-glue branch, the native window’s pixel format (PixelFormat.TRANSLUCENT/CAMetalLayer.isOpaque = false), the native-sibling z-order/subview arrangement, and the nativeSetSurfaceMode/frust_set_surface_mode call together (flipping only some of these is a host-template defect). There is no app-Rust opt-in call; the generated project’s template is the sole route into Mode B.

use frust::{AnyView, Column, Component, any, platform_view, text};

#[derive(Default)]
struct MapDemo;

impl Component for MapDemo {
    type State = ();

    fn init(&self) -> Self::State {}

    fn build(&self, _state: &mut Self::State) -> AnyView<Self::State> {
        any(Column(vec![
            any(text("map below")),
            any(platform_view("dev.frust.MapFactory")
                .params_json(r#"{"style":"dark"}"#)
                .size(320.0, 240.0)),
        ]))
    }
}

frust::app!(MapDemo);

Z-shields (shield)

A slot marked .interactive() forwards a touch-DOWN inside its rect to the native view, including one that landed on frust chrome painted over it (the OS-side hit test knows nothing about the frust scene). Wrap that chrome in shield and it keeps winning input: the wrapper reports the rect it painted every frame, and the shell hands the overlapping ones to the host with the slot’s placement. A declarative platform-view slot. See the module docs.

Implementations

impl PlatformViewView

pub fn params_json(self, params_json: impl Into<String>) -> PlatformViewView

Set the opaque creation params handed to the native factory (default empty). Changing this across a rebuild bumps the widget’s retained params_generation counter exactly once (see the module’s Identity notes) — the differ uses the bump to decide whether to re-create or merely update the native view.

pub fn size(self, width: f64, height: f64) -> PlatformViewView

Force an explicit (width, height) slot size, clamped into whatever constraints this widget’s parent hands it. Overrides PlatformViewView::expand when called after it (last builder call wins, matching the crate’s other size-mode builders).

pub fn expand(self) -> PlatformViewView

Fill the incoming constraints’ maximum — the default (see [SlotSize::Expand]), provided as an explicit builder call for readability at call sites that want to make the choice visible.

pub fn debug_fill(self) -> PlatformViewView

Debug aid: paint a translucent magenta slab over the slot’s bounds (see [DEBUG_FILL_COLOR]) so the reserved region is visible even with no native host attached — invaluable on desktop, where a platform view never actually composites. Compiled only into debug builds, so it can never ship live in a release binary.

pub fn semantics_label(self, label: impl Into<String>) -> PlatformViewView

Attach a plain accessible label over the slot’s bounds (a Role::GenericContainer semantics node) — the v1 accessibility-gap mitigation: the native view itself carries no frust-visible semantics, so this is the only signal an assistive technology gets for the region.

pub fn interactive(self) -> PlatformViewView

Mode B input forwarding: mark this slot’s native view as pointer-interactive. A touch-DOWN inside the slot’s rect — and outside every shield rect (Self::shield_local) — hands the whole gesture to the native sibling instead of the frust surface. Default off (the v1 no-input contract).

pub fn shield_local(self, rect: Rect) -> PlatformViewView

Declare a slot-relative region where frust content drawn OVER this slot must keep receiving input (the z-shield).

The manual escape hatch, not the ordinary path. Wrap the frust chrome in shield instead: a shield(child) reports the rect it actually painted every frame, so it can’t drift out of sync with a moving/resizing widget the way a hand-written rect does. Reach for this builder only for a region no widget paints (a reserved gutter, a gesture-only zone). Both sources are honored — the shell-side differ unions a slot’s manual rects with the intersecting auto-collected ones.

The rect is slot-relative; the widget translates it into absolute window coordinates when it publishes its frame.

Trait Implementations

impl<State> View<State> for PlatformViewView

where State: 'static,

type Element = PlatformViewWidget

The retained widget this view produces.

fn build(&self, _ctx: &mut BuildCtx<'_>) -> PlatformViewWidget

Materialise a fresh widget for this view.

fn rebuild( &self, prev: &PlatformViewView, element: &mut PlatformViewWidget, _ctx: &mut BuildCtx<'_>, ) -> ChangeFlags

Reconcile prev (the previous view of the same type) against the live element, mutating it in place and reporting what changed.

fn teardown(&self, element: &mut PlatformViewWidget, _ctx: &mut BuildCtx<'_>)

Tear down element when this view is being removed.

fn message(&self, _element: &mut Self::Element, _state: &mut State)

Deliver an event message to this view, mutating application state.