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.

Examples found in repository

examples/options/options.rs (line 42)

    async fn init(
        mut init: Self::Init<'_>,
        sender: &ComponentSender<Self>,
    ) -> Result<Self, Self::Error> {
        let mut window = init.window(sender).await?;
        // window.set_size(Size::new(800.0, 600.0));

        let mut enabled = Child::<CheckBox>::init(&window).await?;
        enabled.set_text("Enable");

        let mut b = Child::<CheckBox>::init(&window).await?;
        b.set_text("Switch");

        let mut e_label = Child::<Label>::init(&window).await?;
        e_label.set_text("Mode:");
        let mut e = Child::<ComboBox>::init(&window).await?;
        e.insert(0, "A");
        e.insert(1, "B");

        let mut s_label = Child::<Label>::init(&window).await?;
        s_label.set_text("Message:");
        let mut s = Child::<Edit>::init(&window).await?;

        HANDLER.with_app(|a| {
            let config = a.config();

            enabled.set_checked(config.enabled);
            b.set_checked(config.b);

            e.set_selection(match config.e {
                Mode::A => 0,
                Mode::B => 1,
            });

            s.set_text(&config.s);
        });

        sender.post(MainMessage::EnabledClick);

        window.show();

        Ok(Self {
            window,
            enabled,
            b,
            s_label,
            s,
            e_label,
            e,
        })
    }

examples/test/widgets.rs (line 77)

    async fn init(
        mut init: Self::Init<'_>,
        sender: &ComponentSender<Self>,
    ) -> Result<Self, Self::Error> {
        // let mut window = Child::<Window>::init(init);
        let mut window = init.window(sender).await?;
        // window.set_text("Widgets example");
        window.set_size(Size::new(800.0, 600.0));

        let canvas = Child::<Canvas>::init(&window).await?;
        let mut ulabel = Child::<Label>::init(&window).await?;
        ulabel.set_text("Username:");
        ulabel.set_halign(HAlign::Right);
        let mut plabel = Child::<Label>::init(&window).await?;
        plabel.set_text("Password:");
        plabel.set_halign(HAlign::Right);
        let mut uentry = Child::<Edit>::init(&window).await?;
        uentry.set_text("AAA");
        let mut pentry = Child::<Edit>::init(&window).await?;
        pentry.set_text("123456");
        pentry.set_password(true);
        let mut pcheck = Child::<CheckBox>::init(&window).await?;
        pcheck.set_text("Show");
        pcheck.set_checked(false);
        let combo = Child::<ComboBox>::init(&window).await?;
        let mut list = Child::<ObservableVec<String>>::init(Vec::new())
            .await
            .unwrap();
        // https://www.zhihu.com/question/23600507/answer/140640887
        list.push("烫烫烫".to_string());
        list.push("昍昍昍".to_string());
        list.push("ﾌﾌﾌﾌﾌﾌ".to_string());
        list.push("쳌쳌쳌".to_string());
        let mut r1 = Child::<RadioButton>::init(&window).await?;
        r1.set_text("屯屯屯");
        r1.set_checked(true);
        let mut r2 = Child::<RadioButton>::init(&window).await?;
        r2.set_text("锟斤拷");
        let mut r3 = Child::<RadioButton>::init(&window).await?;
        r3.set_text("╠╠╠");
        // Initialize radio group with the radio buttons
        let radio_group = Child::<RadioButtonGroup>::init(vec![r1, r2, r3]).await?;

        let mut push_button = Child::<Button>::init(&window).await?;
        push_button.set_text("Push");
        let mut pop_button = Child::<Button>::init(&window).await?;
        pop_button.set_text("Pop");
        let mut show_button = Child::<Button>::init(&window).await?;
        show_button.set_text("Show");
        let mut progress = Child::<Progress>::init(&window).await?;
        progress.set_indeterminate(true);
        let mut mltext = Child::<TextBox>::init(&window).await?;
        HANDLER.with_app(|a| mltext.set_text(&a.config().s));

        window.show();

        Ok(Self {
            window,
            ulabel,
            plabel,
            uentry,
            pentry,
            pcheck,
            canvas,
            combo,
            list,
            index: None,
            radio_group,
            rindex: 0,
            push_button,
            pop_button,
            show_button,
            progress,
            mltext,
        })
    }

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.

Examples found in repository

examples/test/widgets.rs (line 191)

    async fn update(
        &mut self,
        message: Self::Message,
        sender: &ComponentSender<Self>,
    ) -> Result<bool, Self::Error> {
        // futures_util::future::join(self.window.update(), self.canvas.update()).await;
        Ok(match message {
            MainMessage::Noop => false,
            MainMessage::PasswordCheck => {
                self.pentry.set_password(!self.pcheck.is_checked()?);
                true
            }
            MainMessage::List(e) => {
                self.pop_button.set_enabled(!self.list.is_empty());
                self.combo
                    .emit(ComboBoxMessage::from_observable_vec_event(e))
                    .await?
            }
            MainMessage::Select => {
                self.index = self.combo.selection()?;
                false
            }
            MainMessage::Push => {
                self.list.push(self.radio_group[self.rindex].text()?);
                false
            }
            MainMessage::Pop => {
                self.list.pop();
                false
            }
            MainMessage::RSelect(i) => {
                self.rindex = i;
                false
            }
            MainMessage::Show => {
                MessageBox::new()
                    .title("Show selected item")
                    .message(
                        self.index
                            .and_then(|index| self.list.get(index))
                            .map(|s| s.as_str())
                            .unwrap_or("No selection."),
                    )
                    .buttons(MessageBoxButton::Ok)
                    // https://github.com/compio-rs/winio/issues/105
                    .show(unsafe { BorrowedWindow::win32(self.window.as_container().as_win32()) })
                    .await;
                false
            }
            MainMessage::OptionsPage(m) => {
                tracing::debug!(?m, "Options page message");
                match m {
                    OptionsPageMessage::Redraw => true,
                    OptionsPageMessage::Close => {
                        sender.output(());
                        false
                    }
                    OptionsPageMessage::Save(config, tx) => {
                        config.s = self.mltext.text()?;
                        tx.send(config).unwrap();
                        false
                    }
                }
            }
        })
    }

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.

Examples found in repository

examples/options/options.rs (line 142)

    fn render(&mut self, _sender: &ComponentSender<Self>) -> Result<(), Self::Error> {
        self.window.render();

        let csize = self.window.size()?;

        let m = Margin::new(5., 0., 5., 0.);
        let m_l = Margin::new(0., 5., 0., 0.);

        let mut form = layout! {
            Grid::from_str("auto,1*", "auto,auto").unwrap(),
            self.e_label => { column: 0, row: 0, margin: m_l, valign: VAlign::Center },
            self.e => { column: 1, row: 0, margin: m },
            self.s_label => { column: 0, row: 1, margin: m_l, valign: VAlign::Center },
            self.s => { column: 1, row: 1, margin: m },
        };

        let mut grid = layout! {
            Grid::from_str("auto,1*", "auto,auto,auto,1*").unwrap(),
            self.enabled => { column: 0, row: 0, margin: m },
            self.b => { column: 0, row: 1, margin: m },
            form => { column: 0, row: 2, margin: m },
        };
        grid.set_size(csize);
        Ok(())
    }

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.