Struct ComboBox 

pub struct ComboBox { /* private fields */ }

Available on crate feature winio only.

A simple combo box.

Implementations

impl ComboBox

pub fn selection(&self) -> Result<Option<usize>, Error>

The selection index.

Examples found in repository

examples/options/options.rs (line 127)

    async fn update(
        &mut self,
        message: Self::Message,
        sender: &ComponentSender<Self>,
    ) -> Result<bool, Self::Error> {
        // futures_util::join!(self.window.update());
        Ok(match message {
            MainMessage::Noop => false,
            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::Redraw => true,
                    OptionsPageMessage::Close => {
                        sender.output(());
                        false
                    }
                    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 195)

    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 set_selection(&mut self, i: usize) -> Result<(), Error>

Set the selection.

Examples found in repository

examples/options/options.rs (lines 64-67)

    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,
        })
    }

pub fn is_editable(&self) -> Result<bool, Error>

If the combo box is editable.

pub fn set_editable(&mut self, v: bool) -> Result<(), Error>

Set if the combo box is editable.

pub fn len(&self) -> Result<usize, Error>

The length of list.

pub fn is_empty(&self) -> Result<bool, Error>

If the list is empty.

pub fn clear(&mut self) -> Result<(), Error>

Clear the list.

pub fn get(&self, i: usize) -> Result<String, Error>

Get the item by index.

pub fn set(&mut self, i: usize, s: impl AsRef<str>) -> Result<(), Error>

Set the item by index.

pub fn insert(&mut self, i: usize, s: impl AsRef<str>) -> Result<(), Error>

Insert an item by index.

Examples found in repository

examples/options/options.rs (line 51)

    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,
        })
    }

pub fn remove(&mut self, i: usize) -> Result<(), Error>

Remove the item by index.

pub fn push(&mut self, s: impl AsRef<str>) -> Result<(), Error>

Push an item to the end of the list.

pub fn set_items<U>( &mut self, items: impl IntoIterator<Item = U>, ) -> Result<(), Error>

where U: Into<String>,

Clears all items, and appends the new items one by one.

Trait Implementations

impl AsWidget for ComboBox

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

Get the widget handle.

impl Component for ComboBox

type Error = Error

The error type.

type Event = ComboBoxEvent

The output event type to the parent.

type Init<'a> = BorrowedContainer<'a>

Initial parameter type.

type Message = ComboBoxMessage

The input message type to update.

async fn init( init: <ComboBox as Component>::Init<'_>, _sender: &ComponentSender<ComboBox>, ) -> Result<ComboBox, Error>

Create the initial component.

async fn start(&mut self, sender: &ComponentSender<ComboBox>) -> !

Start the event listening.

async fn update( &mut self, message: <ComboBox as Component>::Message, _sender: &ComponentSender<ComboBox>, ) -> Result<bool, Error>

Respond to the message. Return true if need render.

fn render(&mut self, sender: &ComponentSender<Self>) -> Result<(), Self::Error>

Render the widgets.

async fn update_children(&mut self) -> Result<bool, Self::Error>

Update the children components. Return true if any child needs render.

fn render_children(&mut self) -> Result<(), Self::Error>

Render the children components. It will be called if any child or self needs render.

impl Debug for ComboBox

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

Formats the value using the given formatter.

impl Enable for ComboBox

fn is_enabled(&self) -> Result<bool, Error>

If the widget is enabled.

fn set_enabled(&mut self, v: bool) -> Result<(), Error>

Set if the widget is enabled.

fn enable(&mut self) -> Result<(), Self::Error>

Enable the widget.

fn disable(&mut self) -> Result<(), Self::Error>

Disable the widget.

impl Failable for ComboBox

type Error = Error

The error type associated.

impl Layoutable for ComboBox

fn loc(&self) -> Result<Point2D<f64, LogicalSpace>, Error>

The left top location.

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

Move the location.

fn size(&self) -> Result<Size2D<f64, LogicalSpace>, Error>

The size.

fn set_size(&mut self, v: Size2D<f64, LogicalSpace>) -> Result<(), Error>

Resize.

fn preferred_size(&self) -> Result<Size2D<f64, LogicalSpace>, Error>

The preferred size.

fn rect(&self) -> Result<Rect<f64, LogicalSpace>, Self::Error>

The bounding rectangle.

fn set_rect(&mut self, r: Rect<f64, LogicalSpace>) -> Result<(), Self::Error>

Set the location and size.

fn min_size(&self) -> Result<Size2D<f64, LogicalSpace>, Self::Error>

Min acceptable size.

impl TextWidget for ComboBox

fn text(&self) -> Result<String, Error>

Get the text of the widget.

fn set_text(&mut self, s: impl AsRef<str>) -> Result<(), Error>

Set the text of the widget.

impl ToolTip for ComboBox

fn tooltip(&self) -> Result<String, Error>

Get the tooltip text of the widget.

fn set_tooltip(&mut self, s: impl AsRef<str>) -> Result<(), Error>

Set the tooltip text of the widget.

impl Visible for ComboBox

fn is_visible(&self) -> Result<bool, Error>

If the widget is visible.

fn set_visible(&mut self, v: bool) -> Result<(), Error>

Set the visibility.

fn show(&mut self) -> Result<(), Self::Error>

Show the widget.

fn hide(&mut self) -> Result<(), Self::Error>

Hide the widget.