Struct MessageBox 

pub struct MessageBox(/* private fields */);

Available on crate feature winio only.

Message box.

Implementations

impl MessageBox

pub fn new() -> MessageBox

Create MessageBox.

Examples found in repository

examples/test/widgets.rs (line 211)

    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 show( self, parent: impl Into<MaybeBorrowedWindow<'_>>, ) -> Result<MessageBoxResponse, Error>

Show message box.

Examples found in repository

examples/test/widgets.rs (line 221)

    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 fn message(self, msg: impl AsRef<str>) -> MessageBox

Main message.

Examples found in repository

examples/test/widgets.rs (lines 213-218)

    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 fn title(self, title: impl AsRef<str>) -> MessageBox

Box title.

Examples found in repository

examples/test/widgets.rs (line 212)

    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 fn instruction(self, instr: impl AsRef<str>) -> MessageBox

Optional instruction title.

pub fn style(self, style: MessageBoxStyle) -> MessageBox

Style.

pub fn buttons(self, btns: MessageBoxButton) -> MessageBox

Pre-defined buttons.

Examples found in repository

examples/test/widgets.rs (line 219)

    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 fn custom_button(self, btn: impl Into<CustomButton>) -> MessageBox

Add a custom button.

pub fn custom_buttons( self, btn: impl IntoIterator<Item = CustomButton>, ) -> MessageBox

Set custom buttons.

Trait Implementations

impl Clone for MessageBox

fn clone(&self) -> MessageBox

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MessageBox

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

Formats the value using the given formatter.

impl Default for MessageBox

fn default() -> MessageBox

Returns the “default value” for a type.