Struct Cx 

pub struct Cx<'a, B: Backend, T> {
    pub world: &'a mut B::World,
    /* private fields */
}

Fields

world: &'a mut B::World

Implementations

impl<'a, B: Backend, T: 'static> Cx<'a, B, T>

pub fn new( world: &'a mut B::World, theme: &'a T, mounted: &'a mut Mounted<B, T>, ) -> Self

pub fn theme(&self) -> &'a T

pub fn parent(&self) -> Option<B::Node>

Where a view built now hangs. None at the root.

pub fn effect<P>( &mut self, node: B::Node, value: Prop<B::World, P>, run: impl FnMut(&mut B::World, B::Node, &P) + Send + Sync + 'static, )

where P: PartialEq + Clone + Send + Sync + 'static,

Runs run on node with what value holds: once now, and again whenever a bound value changes to something different, until the node is unmounted. An unset prop never runs it.

This is how a composite follows a bound value: an element reads its own props, and a composite hands one to this.

pub fn spawn(&mut self) -> B::Node

A new, empty node where a view built now hangs. It is the root of every rule set since the last node was spawned.

pub fn build(&mut self, view: impl View<B, T>) -> B::Node

Builds view where a view built now hangs.

pub fn under<R>( &mut self, parent: B::Node, build: impl FnOnce(&mut Self) -> R, ) -> R

Runs build with views hanging under parent.

pub fn at_root<R>(&mut self, build: impl FnOnce(&mut Self) -> R) -> R

Runs build with views hanging at the root, whatever they were built under. The rules in force still apply.

pub fn scope<R>(&mut self, build: impl FnOnce(&mut Self) -> R) -> R

Runs build in a scope of its own: rules it sets end with it.

pub fn when<C: Condition<B>>(&mut self, set: impl FnOnce(&mut Self))

Runs set with the rules it sets holding only while the root of the view they are set for is in the state C.

On that root they beat its call site, as a state rule does. On a view under it they only fill what that view’s call site left unset, as a set rule does. Either way they beat rules that do not wait on a state.

pub fn root(&mut self, set: impl FnOnce(&mut Self))

Runs set with the rules it sets reaching only the root of the view they are set for: the first node spawned after them.

pub fn defaults(&mut self, set: impl FnOnce(&mut Self))

Runs set with the rules it sets weaker than any that are not, wherever they are: a composite’s defaults, which an app’s rules should restyle.

pub fn set<V: Styled>( &mut self, rule: impl Fn(V, &T) -> V + Send + Sync + 'static, )

Restyles every V built from here to the end of the scope. A call-site value still beats it.

pub fn transition(&mut self, motion: Motion)

where T: MotionTokens,

Makes every element built from here to the end of the scope travel to new values over the theme’s curve for motion, if it says how its values blend.

pub fn transition_over(&mut self, curve: Curve)

As transition, over curve.

pub fn set_field<P, X>(&mut self, path: Cursor<P>, value: X)

where P: FieldPath<Target = Prop<B::World, X>>, P::Source: Styled, X: Clone + Send + Sync + 'static,

Sets the field path names to value, on every view path starts from, from here to the end of the scope. A set rule like set, but one that says which field it sets.

The path may reach into a composite’s own parts: Card::cursor().title().size() sets the size of a card’s title, and of nothing else.

pub fn set_field_with<P, X>( &mut self, path: Cursor<P>, read: impl Fn(&T) -> X + Send + Sync + 'static, )

where P: FieldPath<Target = Prop<B::World, X>>, P::Source: Styled, X: Send + Sync + 'static,

As set_field, with the value read from the theme.

pub fn trace<V: Styled>(&self, field: FieldId) -> Trace

Which set rules in force for a V could decide field.

pub fn show<V: Styled>( &mut self, rule: impl Fn(V, &T) -> V + Send + Sync + 'static, )

Transforms every V built from here to the end of the scope, after its call site, so unlike a set rule it wins over it.

pub fn resolve<V: Styled>(&self, view: V) -> V

view with the rules in force applied: set rules fill what its call site left unset, defaults first, then outer scopes before inner, then show rules transform the result. Rules waiting on a state are left out: an element puts them on top while mounted.

Trait Implementations

impl<B: Backend, T> Drop for Cx<'_, B, T>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.