Struct NativeComponentView 

pub struct NativeComponentView<C: NativeComponent> { /* private fields */ }

One mounted NativeComponent — build it with native_component.

Implementations

impl<C: NativeComponent> NativeComponentView<C>

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

Explicit slot size — see crate::api::builders’ resolve_size doc for the no-call fallback (fill the parent; there is no measure step in v1, and a native subtree’s own content size is invisible to frust by design).

pub fn interactive(self) -> Self

Mark the slot interactive, so the host routes touches to the native view (and the differ collects the frust chrome overlapping it as input shields). Off by default: a component the user never touches wants neither.

A platform_view slot never receives Widget::event (docs/CODE_STANDARDS.md’s Platform-View Conventions) — the platform owns this input end to end. It reaches Rust only through a listener the component attached (ComponentCtx::attach_listener), as NativeComponent::on_event and then Self::on_event — never EventCtx. A touch on a view the component attached nothing to still behaves natively (a button highlights) and reports nothing.

pub fn on_event( self, handler: impl Fn(NativeEvent) + Send + Sync + 'static, ) -> Self

Fires on the platform main thread with every NativeEvent the component’s NativeComponent::on_event answers — the builders’ events-as-signals idiom (write an RwSignal from inside for the one-frame wake; the module doc’s Events).

Nothing fires unless the component attached a listener for the event’s family, and the event is whatever the component answered (by default, the event its listener reported). Send + Sync for the same reason the builders’ handlers carry it: the runtime’s callback table is typed that way, though every call arrives on the main thread.

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

The slot’s frust-side accessibility label. A native subtree already gets the platform’s own a11y traversal for free (the platform owns it); this labels the slot for frust’s semantics pass, which publishes nothing for an unlabelled one.

Trait Implementations

impl<C: NativeComponent> Clone for NativeComponentView<C>

Hand-written (rather than derived) so the builder is Clone whatever C is: #[derive(Clone)] would demand C: Clone + C::Props: Clone, and only the second is a trait bound this crate can rely on.

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<C: NativeComponent> Component for NativeComponentView<C>

type State = u64

The retained local state this component owns across rebuilds.

fn init(&self) -> SlotId

Create the component’s initial local state. Runs exactly once, when the ComponentWidget is first built, under the component’s Owner (so on_cleanup/provide_context registered here bind to that owner).

fn build(&self, state: &mut SlotId) -> AnyView<SlotId>

Produce the component’s subtree from its current local state.

impl<C: NativeComponent, Outer: 'static> View<Outer> for NativeComponentView<C>

View<Outer> for every Outer, by delegating to frust_core::component — the generic counterpart of crate::api::builders’ impl_native_view! macro, hand-written here because that macro takes a concrete type and this one carries a parameter. Same contract, same rationale: each call clones self/prev into a throwaway ComponentView (cheap — an Rc bump plus the props), and it is correct because ComponentView::rebuild never reads its prev argument, always re-running Component::build against the retained State.

type Element = ComponentWidget<NativeComponentView<C>>

The retained widget this view produces.

fn build(&self, ctx: &mut BuildCtx<'_>) -> Self::Element

Materialise a fresh widget for this view.

fn rebuild( &self, prev: &Self, element: &mut Self::Element, 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 Self::Element, 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.