Struct Child 

pub struct Child<T>
where
    T: Component,
{ /* private fields */ }

Available on crate feature winio only.

Helper to embed one component into another. It handles different types of messages and events.

Implementations

impl<T> Child<T>

where T: Component,

pub async fn init<'a>( init: impl Into<<T as Component>::Init<'a>>, ) -> Result<Child<T>, <T as Component>::Error>

Create and initialize the child component.

pub async fn start<C>( &mut self, sender: &ComponentSender<C>, f: impl FnMut(<T as Component>::Event) -> Option<<C as Component>::Message>, propagate: impl FnMut() -> <C as Component>::Message, ) -> !

where C: Component,

Start to receive and interp the events of the child component.

Define a root component MainModel, and it contains a window: Child<Window>. The message of MainModel is defined as

enum MainMessage {
    Noop,
    Close,
}

In the MainModel::start, you should write

async fn start(&mut self, sender: &ComponentSender<Self>) -> ! {
    start! {
        sender, default: MainMessage::Noop,
        self.window => {
            WindowEvent::Close => MainMessage::Close,
        },
        // ...other children
    }
}

It is equivalent to

async fn start(&mut self, sender: &ComponentSender<Self>) -> ! {
    let fut_window = self.window.start(
        sender,
        |e| match e {
            WindowEvent::Close => Some(MainMessage::Close),
            // ignore other events
            _ => None,
        },
        // you should always propagate internal messages
        || MainMessage::Noop,
    );
    // ...other children
    futures_util::join!(fut_window, /* ... */);
}

pub fn post(&mut self, message: <T as Component>::Message)

Post message to the child component.

pub async fn emit( &mut self, message: <T as Component>::Message, ) -> Result<bool, <T as Component>::Error>

Emit message to the child component.

pub async fn update(&mut self) -> Result<bool, <T as Component>::Error>

Respond to the child message.

pub fn render(&mut self) -> Result<(), <T as Component>::Error>

Render the child component.

pub fn sender(&self) -> &ComponentSender<T>

Get the sender of the child component.

pub async fn try_into_root(self) -> Result<Root<T>, <T as Component>::Error>

Try to convert the child component into a root component.

It clears the inner message cache and updates the child component if needed.

impl<T> Child<T>

where T: Component + 'static,

pub fn into_boxed( self, ) -> Child<BoxComponent<<T as Component>::Message, <T as Component>::Event, <T as Component>::Error>>

Box the component.

Trait Implementations

impl<T> AsContainer for Child<T>

where T: AsContainer + Component,

Available on crate feature handle only.

fn as_container(&self) -> BorrowedContainer<'_>

Get the container handle.

impl<T> AsWidget for Child<T>

where T: AsWidget + Component,

Available on crate feature handle only.

fn as_widget(&self) -> BorrowedWidget<'_>

Get the widget handle.

impl<T> AsWindow for Child<T>

where T: AsWindow + Component,

Available on crate feature handle only.

fn as_window(&self) -> BorrowedWindow<'_>

Get the window handle.

impl<T> Debug for Child<T>

where T: Component + Debug,

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

Formats the value using the given formatter.

impl<T> Deref for Child<T>

where T: Component,

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &<Child<T> as Deref>::Target

Dereferences the value.

impl<T> DerefMut for Child<T>

where T: Component,

fn deref_mut(&mut self) -> &mut <Child<T> as Deref>::Target

Mutably dereferences the value.

impl<T> Failable for Child<T>

where T: Component + Failable,

Available on crate feature primitive only.

type Error = <T as Failable>::Error

The error type associated.

impl<T> Layoutable for Child<T>

where T: Component + Layoutable,

fn loc( &self, ) -> Result<Point2D<f64, LogicalSpace>, <Child<T> as Failable>::Error>

The left top location.

fn set_loc( &mut self, p: Point2D<f64, LogicalSpace>, ) -> Result<(), <Child<T> as Failable>::Error>

Move the location.

fn size( &self, ) -> Result<Size2D<f64, LogicalSpace>, <Child<T> as Failable>::Error>

The size.

fn set_size( &mut self, s: Size2D<f64, LogicalSpace>, ) -> Result<(), <Child<T> as Failable>::Error>

Resize.

fn rect(&self) -> Result<Rect<f64, LogicalSpace>, <Child<T> as Failable>::Error>

The bounding rectangle.

fn set_rect( &mut self, r: Rect<f64, LogicalSpace>, ) -> Result<(), <Child<T> as Failable>::Error>

Set the location and size.

fn preferred_size( &self, ) -> Result<Size2D<f64, LogicalSpace>, <Child<T> as Failable>::Error>

The preferred size.

fn min_size( &self, ) -> Result<Size2D<f64, LogicalSpace>, <Child<T> as Failable>::Error>

Min acceptable size.