Struct TextInput

Source

pub struct TextInput {
    pub handle: ControlHandle,
    /* private fields */
}

Expand description

An edit control is a rectangular control window to permit the user to enter and edit text by typing on the keyboard This control only allow a single line input. For block of text, use TextBox. Winapi documentation: https://docs.microsoft.com/en-us/windows/win32/controls/about-edit-controls#text-and-input-styles

TextInput is not behind any features.

Builder parameters:

parent: Required. The text input parent container.
text: The text input text.
size: The text input size.
position: The text input position.
flags: A combination of the TextInputFlags values.
ex_flags: A combination of win32 window extended flags. Unlike flags, ex_flags must be used straight from winapi
font: The font used for the text input text
limit: The maximum number of character that can be inserted in the control
readonly: If the text input should allow user input or not
password: The password character. If set to None, the textinput is a regular control.
align: The alignment of the text in the text input
background_color: The color of the textinput top and bottom padding. This is not the white background under the text.
focus: The control receive focus after being created

Control events:

OnTextInput: When a TextInput value is changed
MousePress(_): Generic mouse press events on the button
OnMouseMove: Generic mouse mouse event
OnMouseWheel: Generic mouse wheel event

use native_windows_gui2 as nwg;
fn build_box(tbox: &mut nwg::TextInput, window: &nwg::Window, font: &nwg::Font) {
    nwg::TextInput::builder()
        .text("Hello")
        .font(Some(font))
        .parent(window)
        .build(tbox);
}

Fields§

§handle: ControlHandle

Implementations§

Source §

impl TextInput

Source

pub fn builder<'a>() -> TextInputBuilder<'a>

Examples found in repository ?

examples/partial_simple.rs (line 94)

88    fn build_partial<W: Into<nwg::ControlHandle>>(
89        data: &mut SubmitForm,
90        parent: Option<W>,
91    ) -> Result<(), nwg::NwgError> {
92        let parent = parent.unwrap().into();
93
94        nwg::TextInput::builder()
95            .text(&data.form_data)
96            .parent(&parent)
97            .build(&mut data.value)?;
98
99        nwg::Button::builder()
100            .text("Save")
101            .parent(&parent)
102            .build(&mut data.sumbit_button)?;
103
104        nwg::GridLayout::builder()
105            .child(0, 0, &data.value)
106            .child(0, 1, &data.sumbit_button)
107            .parent(&parent)
108            .build(&data.layout)?;
109
110        Ok(())
111    }

More examples

Hide additional examples

examples/basic.rs (line 62)

51        fn build_ui(mut data: BasicApp) -> Result<BasicAppUi, nwg::NwgError> {
52            use nwg::Event as E;
53
54            // Controls
55            nwg::Window::builder()
56                .flags(nwg::WindowFlags::WINDOW | nwg::WindowFlags::VISIBLE)
57                .size((300, 135))
58                .position((300, 300))
59                .title("Basic example")
60                .build(&mut data.window)?;
61
62            nwg::TextInput::builder()
63                .size((280, 35))
64                .position((10, 10))
65                .text("Heisenberg")
66                .parent(&data.window)
67                .focus(true)
68                .build(&mut data.name_edit)?;
69
70            nwg::Button::builder()
71                .size((280, 70))
72                .position((10, 50))
73                .text("Say my name")
74                .parent(&data.window)
75                .build(&mut data.hello_button)?;
76
77            // Wrap-up
78            let ui = BasicAppUi {
79                inner: Rc::new(data),
80                default_handler: Default::default(),
81            };
82
83            // Events
84            let evt_ui = Rc::downgrade(&ui.inner);
85            let handle_events = move |evt, _evt_data, handle| {
86                if let Some(ui) = evt_ui.upgrade() {
87                    match evt {
88                        E::OnButtonClick => {
89                            if &handle == &ui.hello_button {
90                                BasicApp::say_hello(&ui);
91                            }
92                        }
93                        E::OnWindowClose => {
94                            if &handle == &ui.window {
95                                BasicApp::say_goodbye(&ui);
96                            }
97                        }
98                        _ => {}
99                    }
100                }
101            };
102
103            *ui.default_handler.borrow_mut() = Some(nwg::full_bind_event_handler(
104                &ui.window.handle,
105                handle_events,
106            ));
107
108            return Ok(ui);
109        }

examples/basic_barebone.rs (line 28)

12fn main() {
13    nwg::init().expect("Failed to init Native Windows GUI");
14    nwg::Font::set_global_family("Segoe UI").expect("Failed to set default font");
15
16    let mut window = Default::default();
17    let mut name_edit = Default::default();
18    let mut hello_button = Default::default();
19    let layout = Default::default();
20
21    nwg::Window::builder()
22        .size((300, 115))
23        .position((300, 300))
24        .title("Basic example")
25        .build(&mut window)
26        .unwrap();
27
28    nwg::TextInput::builder()
29        .text("Heisenberg")
30        .focus(true)
31        .parent(&window)
32        .build(&mut name_edit)
33        .unwrap();
34
35    nwg::Button::builder()
36        .text("Say my name")
37        .parent(&window)
38        .build(&mut hello_button)
39        .unwrap();
40
41    nwg::GridLayout::builder()
42        .parent(&window)
43        .spacing(1)
44        .child(0, 0, &name_edit)
45        .child_item(nwg::GridLayoutItem::new(&hello_button, 0, 1, 1, 2))
46        .build(&layout)
47        .unwrap();
48
49    let window = Rc::new(window);
50    let events_window = window.clone();
51
52    let handler = nwg::full_bind_event_handler(&window.handle, move |evt, _evt_data, handle| {
53        use nwg::Event as E;
54
55        match evt {
56            E::OnWindowClose => {
57                if &handle == &events_window as &nwg::Window {
58                    nwg::modal_info_message(
59                        &events_window.handle,
60                        "Goodbye",
61                        &format!("Goodbye {}", name_edit.text()),
62                    );
63                    nwg::stop_thread_dispatch();
64                }
65            }
66            E::OnButtonClick => {
67                if &handle == &hello_button {
68                    nwg::modal_info_message(
69                        &events_window.handle,
70                        "Hello",
71                        &format!("Hello {}", name_edit.text()),
72                    );
73                }
74            }
75            _ => {}
76        }
77    });
78
79    nwg::dispatch_thread_events();
80    nwg::unbind_event_handler(&handler);
81}

examples/basic_layout.rs (line 63)

52        fn build_ui(mut data: BasicApp) -> Result<BasicAppUi, nwg::NwgError> {
53            use nwg::Event as E;
54
55            // Controls
56            nwg::Window::builder()
57                .flags(nwg::WindowFlags::WINDOW | nwg::WindowFlags::VISIBLE)
58                .size((300, 115))
59                .position((300, 300))
60                .title("Basic example")
61                .build(&mut data.window)?;
62
63            nwg::TextInput::builder()
64                .text("Heisenberg")
65                .parent(&data.window)
66                .focus(true)
67                .build(&mut data.name_edit)?;
68
69            nwg::Button::builder()
70                .text("Say my name")
71                .parent(&data.window)
72                .build(&mut data.hello_button)?;
73
74            // Wrap-up
75            let ui = BasicAppUi {
76                inner: Rc::new(data),
77                default_handler: Default::default(),
78            };
79
80            // Events
81            let evt_ui = Rc::downgrade(&ui.inner);
82            let handle_events = move |evt, _evt_data, handle| {
83                if let Some(evt_ui) = evt_ui.upgrade() {
84                    match evt {
85                        E::OnButtonClick => {
86                            if &handle == &evt_ui.hello_button {
87                                BasicApp::say_hello(&evt_ui);
88                            }
89                        }
90                        E::OnWindowClose => {
91                            if &handle == &evt_ui.window {
92                                BasicApp::say_goodbye(&evt_ui);
93                            }
94                        }
95                        _ => {}
96                    }
97                }
98            };
99
100            *ui.default_handler.borrow_mut() = Some(nwg::full_bind_event_handler(
101                &ui.window.handle,
102                handle_events,
103            ));
104
105            // Layouts
106            nwg::GridLayout::builder()
107                .parent(&ui.window)
108                .spacing(1)
109                .child(0, 0, &ui.name_edit)
110                .child_item(nwg::GridLayoutItem::new(&ui.hello_button, 0, 1, 1, 2))
111                .build(&ui.layout)?;
112
113            return Ok(ui);
114        }

examples/partials.rs (line 293)

269        fn build_partial<W: Into<ControlHandle>>(
270            data: &mut PeopleUi,
271            parent: Option<W>,
272        ) -> Result<(), NwgError> {
273            let parent = parent.unwrap().into();
274
275            nwg::Label::builder()
276                .text("Name:")
277                .h_align(nwg::HTextAlign::Right)
278                .parent(&parent)
279                .build(&mut data.label1)?;
280
281            nwg::Label::builder()
282                .text("Age:")
283                .h_align(nwg::HTextAlign::Right)
284                .parent(&parent)
285                .build(&mut data.label2)?;
286
287            nwg::Label::builder()
288                .text("Job:")
289                .h_align(nwg::HTextAlign::Right)
290                .parent(&parent)
291                .build(&mut data.label3)?;
292
293            nwg::TextInput::builder()
294                .text("John Doe")
295                .parent(&parent)
296                .build(&mut data.name_input)?;
297
298            nwg::TextInput::builder()
299                .text("75")
300                .flags(nwg::TextInputFlags::VISIBLE | nwg::TextInputFlags::NUMBER)
301                .parent(&parent)
302                .build(&mut data.age_input)?;
303
304            nwg::TextInput::builder()
305                .text("Programmer")
306                .parent(&parent)
307                .build(&mut data.job_input)?;
308
309            nwg::Button::builder()
310                .text("Save")
311                .parent(&parent)
312                .build(&mut data.save_btn)?;
313
314            nwg::GridLayout::builder()
315                .parent(&parent)
316                .max_size([1000, 150])
317                .min_size([100, 120])
318                .child(0, 0, &data.label1)
319                .child(0, 1, &data.label2)
320                .child(0, 2, &data.label3)
321                .child(1, 0, &data.name_input)
322                .child(1, 1, &data.age_input)
323                .child(1, 2, &data.job_input)
324                .build(&data.layout)?;
325
326            nwg::GridLayout::builder()
327                .min_size([100, 200])
328                .max_column(Some(2))
329                .max_row(Some(6))
330                .child(1, 5, &data.save_btn)
331                .parent(&parent)
332                .build(&data.layout2)?;
333
334            Ok(())
335        }
336
337        fn process_event<'a>(
338            &self,
339            _evt: nwg::Event,
340            _evt_data: &nwg::EventData,
341            _handle: ControlHandle,
342        ) {
343        }
344
345        fn handles(&self) -> Vec<&ControlHandle> {
346            Vec::new()
347        }
348    }
349}
350
351mod partial_animal_ui {
352    use self::nwg::{ControlHandle, NwgError, PartialUi};
353    use super::*;
354    use native_windows_gui2 as nwg;
355
356    impl PartialUi for AnimalUi {
357        fn build_partial<W: Into<ControlHandle>>(
358            data: &mut AnimalUi,
359            parent: Option<W>,
360        ) -> Result<(), NwgError> {
361            let parent = parent.unwrap().into();
362
363            nwg::Label::builder()
364                .text("Name:")
365                .h_align(nwg::HTextAlign::Right)
366                .parent(&parent)
367                .build(&mut data.label1)?;
368
369            nwg::Label::builder()
370                .text("Race:")
371                .h_align(nwg::HTextAlign::Right)
372                .parent(&parent)
373                .build(&mut data.label2)?;
374
375            nwg::Label::builder()
376                .text("Is fluffy:")
377                .h_align(nwg::HTextAlign::Right)
378                .parent(&parent)
379                .build(&mut data.label3)?;
380
381            nwg::TextInput::builder()
382                .text("Mittens")
383                .parent(&parent)
384                .build(&mut data.name_input)?;
385
386            nwg::ComboBox::builder()
387                .collection(vec!["Cat", "Dog", "Pidgeon", "Monkey"])
388                .selected_index(Some(0))
389                .parent(&parent)
390                .build(&mut data.race_input)?;
391
392            nwg::CheckBox::builder()
393                .text("")
394                .check_state(nwg::CheckBoxState::Checked)
395                .parent(&parent)
396                .build(&mut data.is_soft_input)?;
397
398            nwg::Button::builder()
399                .text("Save")
400                .parent(&parent)
401                .build(&mut data.save_btn)?;
402
403            nwg::GridLayout::builder()
404                .parent(&parent)
405                .max_size([1000, 150])
406                .min_size([100, 120])
407                .child(0, 0, &data.label1)
408                .child(0, 1, &data.label2)
409                .child(0, 2, &data.label3)
410                .child(1, 0, &data.name_input)
411                .child(1, 1, &data.race_input)
412                .child(1, 2, &data.is_soft_input)
413                .build(&data.layout)?;
414
415            nwg::GridLayout::builder()
416                .min_size([100, 200])
417                .max_column(Some(2))
418                .max_row(Some(6))
419                .child(1, 5, &data.save_btn)
420                .parent(&parent)
421                .build(&data.layout2)?;
422
423            Ok(())
424        }
425
426        fn process_event<'a>(
427            &self,
428            _evt: nwg::Event,
429            _evt_data: &nwg::EventData,
430            _handle: ControlHandle,
431        ) {
432        }
433
434        fn handles(&self) -> Vec<&ControlHandle> {
435            Vec::new()
436        }
437    }
438}
439
440mod partial_food_ui {
441    use self::nwg::{ControlHandle, NwgError, PartialUi};
442    use super::*;
443    use native_windows_gui2 as nwg;
444
445    impl PartialUi for FoodUi {
446        fn build_partial<W: Into<ControlHandle>>(
447            data: &mut FoodUi,
448            parent: Option<W>,
449        ) -> Result<(), NwgError> {
450            let parent = parent.unwrap().into();
451
452            nwg::Label::builder()
453                .text("Name:")
454                .h_align(nwg::HTextAlign::Right)
455                .parent(&parent)
456                .build(&mut data.label1)?;
457
458            nwg::Label::builder()
459                .text("Tasty:")
460                .h_align(nwg::HTextAlign::Right)
461                .parent(&parent)
462                .build(&mut data.label2)?;
463
464            nwg::TextInput::builder()
465                .text("Banana")
466                .parent(&parent)
467                .build(&mut data.name_input)?;
468
469            nwg::CheckBox::builder()
470                .text("")
471                .check_state(nwg::CheckBoxState::Checked)
472                .parent(&parent)
473                .build(&mut data.tasty_input)?;
474
475            nwg::Button::builder()
476                .text("Save")
477                .parent(&parent)
478                .build(&mut data.save_btn)?;
479
480            nwg::GridLayout::builder()
481                .parent(&parent)
482                .max_size([1000, 90])
483                .min_size([100, 80])
484                .child(0, 0, &data.label1)
485                .child(0, 1, &data.label2)
486                .child(1, 0, &data.name_input)
487                .child(1, 1, &data.tasty_input)
488                .build(&data.layout)?;
489
490            nwg::GridLayout::builder()
491                .min_size([100, 200])
492                .max_column(Some(2))
493                .max_row(Some(6))
494                .child(1, 5, &data.save_btn)
495                .parent(&parent)
496                .build(&data.layout2)?;
497
498            Ok(())
499        }

examples/message_bank.rs (line 98)

87        fn build_ui(mut data: MessageBank) -> Result<MessageBankUi, nwg::NwgError> {
88            use nwg::Event as E;
89
90            // Controls
91            nwg::Window::builder()
92                .flags(nwg::WindowFlags::MAIN_WINDOW | nwg::WindowFlags::VISIBLE)
93                .size((400, 300))
94                .position((800, 300))
95                .title("My message bank")
96                .build(&mut data.window)?;
97
98            nwg::TextInput::builder()
99                .text("Hello World!")
100                .focus(true)
101                .parent(&data.window)
102                .build(&mut data.message_content)?;
103
104            nwg::Button::builder()
105                .text("Save")
106                .parent(&data.window)
107                .build(&mut data.add_message_btn)?;
108
109            nwg::TextInput::builder()
110                .text("Title")
111                .parent(&data.window)
112                .build(&mut data.message_title)?;
113
114            // Wrap-up
115            let ui = MessageBankUi {
116                inner: Rc::new(data),
117                default_handler: Default::default(),
118            };
119
120            // Events
121            let window_handles = [&ui.window.handle];
122
123            for handle in window_handles.iter() {
124                let evt_ui = Rc::downgrade(&ui.inner);
125                let handle_events = move |evt, _evt_data, handle| {
126                    if let Some(evt_ui) = evt_ui.upgrade() {
127                        match evt {
128                            E::OnButtonClick => {
129                                if &handle == &evt_ui.add_message_btn {
130                                    MessageBank::add_message(&evt_ui);
131                                }
132                            }
133                            E::OnWindowClose => {
134                                if &handle == &evt_ui.window {
135                                    MessageBank::exit(&evt_ui);
136                                }
137                            }
138                            _ => {}
139                        }
140                    }
141                };
142
143                ui.default_handler
144                    .borrow_mut()
145                    .push(nwg::full_bind_event_handler(handle, handle_events));
146            }
147
148            // Layout
149            nwg::GridLayout::builder()
150                .parent(&ui.window)
151                .max_row(Some(6))
152                .child(0, 0, &ui.add_message_btn)
153                .child_item(nwg::GridLayoutItem::new(&ui.message_title, 1, 0, 2, 1))
154                .child_item(nwg::GridLayoutItem::new(&ui.message_content, 3, 0, 3, 1))
155                .build(&ui.layout)?;
156
157            return Ok(ui);
158        }

Additional examples can be found in:

examples/calculator.rs

Source

pub fn font(&self) -> Option

Return the font of the control

Source

pub fn set_font(&self, font: Option<&Font>)

Set the font of the control

Source

pub fn password_char(&self) -> Option<char>

Return the password character displayed by the text input. If the input is not a password, return None.

Source

pub fn set_password_char(&self, c: Option<char>)

Set or Remove the password character displayed by the text input. If the input is not a password all character are re-rendered with the new character

Source

pub fn limit(&self) -> u32

Return the number of maximum character allowed in this text input

Source

pub fn set_limit(&self, limit: usize)

Set the number of maximum character allowed in this text input If limit is 0, the text length is set to 0x7FFFFFFE characters

Source

pub fn modified(&self) -> bool

Check if the content of the text input was modified after it’s creation

Source

pub fn set_modified(&self, e: bool)

Manually set modified flag of the text input

Source

pub fn undo(&self)

Undo the last action by the user in the control

Source

pub fn selection(&self) -> Range<u32>

Return the selected range of characters by the user in the text input

Source

pub fn set_selection(&self, r: Range<u32>)

Return the selected range of characters by the user in the text input

Source

pub fn len(&self) -> u32

Return the length of the user input in the control. This is better than input.text().len() as it does not allocate a string in memory

Source

pub fn readonly(&self) -> bool

Return true if the TextInput value cannot be edited. Retrurn false otherwise. A user can still copy text from a readonly TextEdit (unlike disabled)

Source

pub fn set_readonly(&self, r: bool)

Set the readonly flag of the text input A user can still copy text from a readonly TextEdit (unlike disabled)

Source

pub fn focus(&self) -> bool

Return true if the control currently has the keyboard focus

Source

pub fn set_focus(&self)

Set the keyboard focus on the button

Source

pub fn enabled(&self) -> bool

Return true if the control user can interact with the control, return false otherwise

Source

pub fn set_enabled(&self, v: bool)

Enable or disable the control

Source

pub fn visible(&self) -> bool

Return true if the control is visible to the user. Will return true even if the control is outside of the parent client view (ex: at the position (10000, 10000))

Source

pub fn set_visible(&self, v: bool)

Show or hide the control to the user

Source

pub fn size(&self) -> (u32, u32)

Return the size of the button in the parent window

Source

pub fn set_size(&self, x: u32, y: u32)

Set the size of the button in the parent window

Source

pub fn position(&self) -> (i32, i32)

Return the position of the button in the parent window

Source

pub fn set_position(&self, x: i32, y: i32)

Set the position of the button in the parent window

Source

pub fn text(&self) -> String

Return the text displayed in the TextInput

Examples found in repository ?

examples/calculator.rs (line 46)

45    fn number(&self, button: &nwg::Button) {
46        let text = self.input.text();
47        self.input.set_text(&format!("{}{}", text, button.text()));
48    }
49
50    fn clear(&self) {
51        self.input.set_text("");
52    }
53
54    fn compute(&self) {
55        use Token::*;
56        static SYMBOLS: &'static [char] = &['+', '-', '*', '/'];
57
58        let eq = self.input.text();
59        if eq.len() == 0 {
60            return;
61        }
62
63        let mut tokens: Vec<Token> = Vec::with_capacity(5);
64        let mut last = 0;
65
66        for (i, chr) in eq.char_indices() {
67            if SYMBOLS.iter().any(|&s| s == chr) {
68                let left = &eq[last..i];
69                match left.parse::<i32>() {
70                    Ok(i) => tokens.push(Token::Number(i)),
71                    _ => {
72                        nwg::error_message("Error", "Invalid equation!");
73                        self.input.set_text("");
74                        return;
75                    }
76                }
77
78                let tk = match chr {
79                    '+' => Plus,
80                    '-' => Minus,
81                    '*' => Mult,
82                    '/' => Div,
83                    _ => unreachable!(),
84                };
85
86                tokens.push(tk);
87
88                last = i + 1;
89            }
90        }
91
92        let right = &eq[last..];
93        match right.parse::<i32>() {
94            Ok(i) => tokens.push(Token::Number(i)),
95            _ => {
96                nwg::error_message("Error", "Invalid equation!");
97                self.input.set_text("");
98                return;
99            }
100        }
101
102        let mut i = 1;
103        let mut result = match &tokens[0] {
104            Token::Number(n) => *n,
105            _ => unreachable!(),
106        };
107        while i < tokens.len() {
108            match [&tokens[i], &tokens[i + 1]] {
109                [Plus, Number(n)] => {
110                    result += n;
111                }
112                [Minus, Number(n)] => {
113                    result -= n;
114                }
115                [Mult, Number(n)] => {
116                    result *= n;
117                }
118                [Div, Number(n)] => {
119                    result /= n;
120                }
121                _ => unreachable!(),
122            }
123            i += 2;
124        }
125
126        self.input.set_text(&result.to_string());
127    }

More examples

Hide additional examples

examples/basic.rs (line 21)

17    fn say_hello(&self) {
18        nwg::modal_info_message(
19            &self.window,
20            "Hello",
21            &format!("Hello {}", self.name_edit.text()),
22        );
23    }
24
25    fn say_goodbye(&self) {
26        nwg::modal_info_message(
27            &self.window,
28            "Goodbye",
29            &format!("Goodbye {}", self.name_edit.text()),
30        );
31        nwg::stop_thread_dispatch();
32    }

examples/basic_layout.rs (line 22)

18    fn say_hello(&self) {
19        nwg::modal_info_message(
20            &self.window,
21            "Hello",
22            &format!("Hello {}", self.name_edit.text()),
23        );
24    }
25
26    fn say_goodbye(&self) {
27        nwg::modal_info_message(
28            &self.window,
29            "Goodbye",
30            &format!("Goodbye {}", self.name_edit.text()),
31        );
32        nwg::stop_thread_dispatch();
33    }

examples/message_bank.rs (line 25)

24    fn add_message(&self) {
25        let title = self.message_title.text();
26        let content = self.message_content.text();
27
28        let mut new_button = Default::default();
29        nwg::Button::builder()
30            .text(&title)
31            .parent(&self.window)
32            .build(&mut new_button)
33            .expect("Failed to build button");
34
35        let mut buttons = self.buttons.borrow_mut();
36        let mut handlers = self.handlers.borrow_mut();
37
38        let blen = buttons.len() as u32;
39        let (x, y) = (blen % 6, blen / 6);
40        self.layout.add_child(x, y + 1, &new_button);
41
42        // You can share controls handle with events handlers
43        let new_button_handle = new_button.handle;
44        let handler = nwg::bind_event_handler(
45            &new_button.handle,
46            &self.window.handle,
47            move |evt, _evt_data, handle| match evt {
48                nwg::Event::OnButtonClick => {
49                    if handle == new_button_handle {
50                        nwg::simple_message(&title, &content);
51                    }
52                }
53                _ => {}
54            },
55        );
56
57        buttons.push(new_button);
58        handlers.push(handler);
59    }

examples/basic_barebone.rs (line 61)

12fn main() {
13    nwg::init().expect("Failed to init Native Windows GUI");
14    nwg::Font::set_global_family("Segoe UI").expect("Failed to set default font");
15
16    let mut window = Default::default();
17    let mut name_edit = Default::default();
18    let mut hello_button = Default::default();
19    let layout = Default::default();
20
21    nwg::Window::builder()
22        .size((300, 115))
23        .position((300, 300))
24        .title("Basic example")
25        .build(&mut window)
26        .unwrap();
27
28    nwg::TextInput::builder()
29        .text("Heisenberg")
30        .focus(true)
31        .parent(&window)
32        .build(&mut name_edit)
33        .unwrap();
34
35    nwg::Button::builder()
36        .text("Say my name")
37        .parent(&window)
38        .build(&mut hello_button)
39        .unwrap();
40
41    nwg::GridLayout::builder()
42        .parent(&window)
43        .spacing(1)
44        .child(0, 0, &name_edit)
45        .child_item(nwg::GridLayoutItem::new(&hello_button, 0, 1, 1, 2))
46        .build(&layout)
47        .unwrap();
48
49    let window = Rc::new(window);
50    let events_window = window.clone();
51
52    let handler = nwg::full_bind_event_handler(&window.handle, move |evt, _evt_data, handle| {
53        use nwg::Event as E;
54
55        match evt {
56            E::OnWindowClose => {
57                if &handle == &events_window as &nwg::Window {
58                    nwg::modal_info_message(
59                        &events_window.handle,
60                        "Goodbye",
61                        &format!("Goodbye {}", name_edit.text()),
62                    );
63                    nwg::stop_thread_dispatch();
64                }
65            }
66            E::OnButtonClick => {
67                if &handle == &hello_button {
68                    nwg::modal_info_message(
69                        &events_window.handle,
70                        "Hello",
71                        &format!("Hello {}", name_edit.text()),
72                    );
73                }
74            }
75            _ => {}
76        }
77    });
78
79    nwg::dispatch_thread_events();
80    nwg::unbind_event_handler(&handler);
81}

Source

pub fn set_text<'a>(&self, v: &'a str)

Set the text displayed in the TextInput

Examples found in repository ?

examples/calculator.rs (line 47)

45    fn number(&self, button: &nwg::Button) {
46        let text = self.input.text();
47        self.input.set_text(&format!("{}{}", text, button.text()));
48    }
49
50    fn clear(&self) {
51        self.input.set_text("");
52    }
53
54    fn compute(&self) {
55        use Token::*;
56        static SYMBOLS: &'static [char] = &['+', '-', '*', '/'];
57
58        let eq = self.input.text();
59        if eq.len() == 0 {
60            return;
61        }
62
63        let mut tokens: Vec<Token> = Vec::with_capacity(5);
64        let mut last = 0;
65
66        for (i, chr) in eq.char_indices() {
67            if SYMBOLS.iter().any(|&s| s == chr) {
68                let left = &eq[last..i];
69                match left.parse::<i32>() {
70                    Ok(i) => tokens.push(Token::Number(i)),
71                    _ => {
72                        nwg::error_message("Error", "Invalid equation!");
73                        self.input.set_text("");
74                        return;
75                    }
76                }
77
78                let tk = match chr {
79                    '+' => Plus,
80                    '-' => Minus,
81                    '*' => Mult,
82                    '/' => Div,
83                    _ => unreachable!(),
84                };
85
86                tokens.push(tk);
87
88                last = i + 1;
89            }
90        }
91
92        let right = &eq[last..];
93        match right.parse::<i32>() {
94            Ok(i) => tokens.push(Token::Number(i)),
95            _ => {
96                nwg::error_message("Error", "Invalid equation!");
97                self.input.set_text("");
98                return;
99            }
100        }
101
102        let mut i = 1;
103        let mut result = match &tokens[0] {
104            Token::Number(n) => *n,
105            _ => unreachable!(),
106        };
107        while i < tokens.len() {
108            match [&tokens[i], &tokens[i + 1]] {
109                [Plus, Number(n)] => {
110                    result += n;
111                }
112                [Minus, Number(n)] => {
113                    result -= n;
114                }
115                [Mult, Number(n)] => {
116                    result *= n;
117                }
118                [Div, Number(n)] => {
119                    result /= n;
120                }
121                _ => unreachable!(),
122            }
123            i += 2;
124        }
125
126        self.input.set_text(&result.to_string());
127    }

Source

pub fn placeholder_text<'a>(&self, text_length: usize) -> String

Return the placeholder text displayed in the TextInput when it is empty and does not have focus. The string returned will be as long as the user specified, however it might be longer or shorter than the actual placeholder text.

Source