Struct ComponentSender 

pub struct ComponentSender<T>(/* private fields */)
where
    T: Component;

Available on crate feature winio only.

Sender of input messages and output events.

Implementations

impl<T> ComponentSender<T>

where T: Component,

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

Post the message to the queue.

Examples found in repository

examples/options/options.rs (line 69)

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

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

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

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

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

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

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

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

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

        sender.post(MainMessage::EnabledClick);

        window.show();

        Self {
            window,
            enabled,
            b,
            s_label,
            s,
            e_label,
            e,
        }
    }

pub fn output(&self, event: <T as Component>::Event)

Post the event to the queue.

Examples found in repository

examples/options/options.rs (line 102)

    async fn update(&mut self, message: Self::Message, sender: &ComponentSender<Self>) -> bool {
        futures_util::join!(self.window.update());
        match message {
            MainMessage::Noop => false,
            MainMessage::Close => {
                sender.output(());
                false
            }
            MainMessage::Redraw => true,
            MainMessage::EnabledClick => {
                let enabled = self.enabled.is_checked();
                self.b.set_enabled(enabled);
                self.e.set_enabled(enabled);
                self.s.set_enabled(enabled);
                false
            }
            MainMessage::OptionsPage(m) => {
                tracing::debug!(?m, "Options page message");
                match m {
                    OptionsPageMessage::Save(config, tx) => {
                        config.enabled = self.enabled.is_checked();
                        config.b = self.b.is_checked();
                        config.e = match self.e.selection() {
                            Some(0) => Mode::A,
                            Some(1) => Mode::B,
                            _ => Default::default(),
                        };
                        config.s = self.s.text();
                        tx.send(config).unwrap()
                    }
                }
                false
            }
        }
    }

examples/test/widgets.rs (line 192)

    async fn update(&mut self, message: Self::Message, sender: &ComponentSender<Self>) -> bool {
        futures_util::future::join(self.window.update(), self.canvas.update()).await;
        match message {
            MainMessage::Noop => false,
            MainMessage::Close => {
                sender.output(());
                false
            }
            MainMessage::Redraw => true,
            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(
                    match self.rindex {
                        0 => &self.r1,
                        1 => &self.r2,
                        2 => &self.r3,
                        _ => unreachable!(),
                    }
                    .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)
                    .show(&self.window)
                    .await;
                false
            }
            MainMessage::OptionsPage(m) => {
                tracing::debug!(?m, "Options page message");
                match m {
                    OptionsPageMessage::Save(config, tx) => {
                        config.s = self.mltext.text();
                        tx.send(config).unwrap()
                    }
                }
                false
            }
        }
    }

pub fn cast<U>(&self) -> &ComponentSender<U>

where U: Component<Message = <T as Component>::Message, Event = <T as Component>::Event>,

Cast the sender for a different component type with the same message and event types.

Trait Implementations

impl<T> Clone for ComponentSender<T>

where T: Component,

fn clone(&self) -> ComponentSender<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for ComponentSender<T>

where T: Debug + Component, <T as Component>::Message: Debug, <T as Component>::Event: Debug,

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

Formats the value using the given formatter.