Struct TextBox 

pub struct TextBox { /* private fields */ }

Available on crate feature winio only.

A simple multi-line text input box.

Implementations

impl TextBox

pub fn text(&self) -> String

The text.

Examples found in repository

examples/test/widgets.rs (line 248)

    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 set_text(&mut self, s: impl AsRef<str>)

Set the text.

Lines are separated with \n. You don’t need to handle CRLF.

Examples found in repository

examples/test/widgets.rs (line 128)

    fn init(mut init: Self::Init<'_>, sender: &ComponentSender<Self>) -> Self {
        // let mut window = Child::<Window>::init(init);
        let mut window = init.window(sender);
        window.set_text("Widgets example");
        window.set_size(Size::new(800.0, 600.0));
        init! {
            canvas: Canvas = (&window),
            ulabel: Label = (&window) => {
                text: "Username:",
                halign: HAlign::Right,
            },
            plabel: Label = (&window) => {
                text: "Password:",
                halign: HAlign::Right,
            },
            uentry: Edit = (&window) => {
                text: "AAA",
            },
            pentry: Edit = (&window) => {
                text: "123456",
                password: true,
            },
            pcheck: CheckBox = (&window) => {
                text: "Show",
                checked: false,
            },
            combo: ComboBox = (&window),
            list: ObservableVec<String> = (()) => {
                // https://www.zhihu.com/question/23600507/answer/140640887
                items: [
                    "烫烫烫",
                    "昍昍昍",
                    "ﾌﾌﾌﾌﾌﾌ",
                    "쳌쳌쳌"
                ],
            },
            r1: RadioButton = (&window) => {
                text: "屯屯屯",
                checked: true,
            },
            r2: RadioButton = (&window) => {
                text: "锟斤拷",
            },
            r3: RadioButton = (&window) => {
                text: "╠╠╠"
            },
            push_button: Button = (&window) => {
                text: "Push",
            },
            pop_button: Button = (&window) => {
                text: "Pop",
            },
            show_button: Button = (&window) => {
                text: "Show",
            },
            progress: Progress = (&window) => {
                indeterminate: true,
            },
            mltext: TextBox = (&window) => {
            },
        }
        HANDLER.with_app(|a| mltext.set_text(&a.config().s));

        window.show();

        Self {
            window,
            ulabel,
            plabel,
            uentry,
            pentry,
            pcheck,
            canvas,
            combo,
            list,
            index: None,
            r1,
            r2,
            r3,
            rindex: 0,
            push_button,
            pop_button,
            show_button,
            progress,
            mltext,
        }
    }

pub fn halign(&self) -> HAlign

The horizontal alignment.

pub fn set_halign(&mut self, align: HAlign)

Set the horizontal alignment.

Trait Implementations

impl AsRawWidget for TextBox

fn as_raw_widget(&self) -> RawWidget

Get the raw window handle.

impl AsWidget for TextBox

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

Get the window handle.

impl Component for TextBox

type Event = TextBoxEvent

The output event type to the parent.

type Init<'a> = BorrowedWindow<'a>

Initial parameter type.

type Message = ()

The input message type to update.

fn init( init: <TextBox as Component>::Init<'_>, _sender: &ComponentSender<TextBox>, ) -> TextBox

Create the initial component.

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

Start the event listening.

async fn update( &mut self, _message: <TextBox as Component>::Message, _sender: &ComponentSender<TextBox>, ) -> bool

Respond to the message.

fn render(&mut self, _sender: &ComponentSender<TextBox>)

Render the widgets.

impl Debug for TextBox

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

Formats the value using the given formatter.

impl Enable for TextBox

fn is_enabled(&self) -> bool

If the widget is enabled.

fn set_enabled(&mut self, v: bool)

Set if the widget is enabled.

fn enable(&mut self)

Enable the widget.

fn disable(&mut self)

Disable the widget.

impl Layoutable for TextBox

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

The left top location.

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

Move the location.

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

The size.

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

Resize.

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

The preferred size.

fn rect(&self) -> Rect<f64, LogicalSpace>

The bounding rectangle.

fn set_rect(&mut self, r: Rect<f64, LogicalSpace>)

Set the location and size.

fn min_size(&self) -> Size2D<f64, LogicalSpace>

Min acceptable size.

impl Visible for TextBox

fn is_visible(&self) -> bool

If the widget is visible.

fn set_visible(&mut self, v: bool)

Set the visibility.

fn show(&mut self)

Show the widget.

fn hide(&mut self)

Hide the widget.