Struct PageCx 

pub struct PageCx<'a, P> { /* private fields */ }

What a page’s drawing is handed.

Carries the page type, not because drawing needs it, but because reading does: what a segment may read is a fact about where it sits, and this is where that fact enters the signature.

Implementations

impl<P: Segment> PageCx<'_, P>

pub fn state<R, I>(&self) -> (Rc<R>, Dispatch)

where R: Reducer, P: Reaches<R, I>,

The reducer’s state and actions.

No subscription, as in the terminal: egui redraws the whole frame, so there is nothing to invalidate - the next pass reads the state again. What does need saying is when a frame should happen at all, and that is the dispatcher’s job.

Which feature answers is settled at build time: this page installed it, or a segment above listed it in Exports. The _ is Reaches’s index, which says which of several impls applied - Rust has no partial turbofish, so it has to be written.

The state comes shared, not copied: reading it every frame costs a count, and a change made mid-frame goes to a copy.

pub fn binding<R, I>(&self) -> ReducerBinding<R>

where R: Reducer, P: Reaches<R, I>,

The reducer’s binding: its state, and a push straight into it.

For state the UI owns outright - what is picked in a tree, which tab is open - claimed with cx.state::<R>().plain(). There is no domain to ask, so there is no actor to ask it through: a click is the whole story.

State a feature drives is not this: pushing into it goes behind the back of whatever answers for it. Use PageCx::state and emit.

impl<P> PageCx<'_, P>

pub fn ui(&mut self) -> &mut Ui

pub fn navigate<R>(&self) -> NavigateHandle<Egui, R>

where R: RouteChain<Egui> + Clone + PartialEq + 'static,

A navigator over the route type the application runs.

Trait Implementations

impl<P: Segment> Reads for PageCx<'_, P>

type Segment = P

The segment being drawn, whose reach decides what it may read.

fn read<R, I>(&mut self) -> (Rc<R>, Dispatch)

where R: Reducer + PartialEq, P: Reaches<R, I>,

R as it is now, and what may be asked of the feature that owns it.

fn dispatch<R, I>(&self) -> Dispatch

where R: Reducer, P: Reaches<R, I>,

What may be asked of the feature that owns R, without reading it: the segment is not drawn again when R changes.