Struct Button 

pub struct Button {
    pub handle: ControlHandle,
}

A push button is a rectangle containing an application-defined text label. Use ImageButton if you need to have a button that ONLY contains an icon or a bitmap.

Button is not behind any features.

Builder parameters:

• parent: Required. The button parent container.
• text: The button text.
• size: The button size.
• position: The button position.
• enabled: If the button can be used by the user. It also has a grayed out look if disabled.
• flags: A combination of the ButtonFlags 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 button text
• bitmap: A bitmap to display next to the button text. If this value is set, icon is ignored.
• icon: An icon to display next to the button text
• focus: The control receive focus after being created

Control events:

• OnButtonClick: When the button is clicked once by the user
• OnButtonDoubleClick: When the button is clicked twice rapidly by the user
• 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_button(button: &mut nwg::Button, window: &nwg::Window, font: &nwg::Font) {
    nwg::Button::builder()
        .text("Hello")
        .flags(nwg::ButtonFlags::VISIBLE)
        .font(Some(font))
        .parent(window)
        .build(button);
}

Fields

handle: ControlHandle

Implementations

impl Button

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

Examples found in repository

examples/partial_simple.rs (line 99)

    fn build_partial<W: Into<nwg::ControlHandle>>(
        data: &mut SubmitForm,
        parent: Option<W>,
    ) -> Result<(), nwg::NwgError> {
        let parent = parent.unwrap().into();

        nwg::TextInput::builder()
            .text(&data.form_data)
            .parent(&parent)
            .build(&mut data.value)?;

        nwg::Button::builder()
            .text("Save")
            .parent(&parent)
            .build(&mut data.sumbit_button)?;

        nwg::GridLayout::builder()
            .child(0, 0, &data.value)
            .child(0, 1, &data.sumbit_button)
            .parent(&parent)
            .build(&data.layout)?;

        Ok(())
    }

examples/message_bank.rs (line 29)

    fn add_message(&self) {
        let title = self.message_title.text();
        let content = self.message_content.text();

        let mut new_button = Default::default();
        nwg::Button::builder()
            .text(&title)
            .parent(&self.window)
            .build(&mut new_button)
            .expect("Failed to build button");

        let mut buttons = self.buttons.borrow_mut();
        let mut handlers = self.handlers.borrow_mut();

        let blen = buttons.len() as u32;
        let (x, y) = (blen % 6, blen / 6);
        self.layout.add_child(x, y + 1, &new_button);

        // You can share controls handle with events handlers
        let new_button_handle = new_button.handle;
        let handler = nwg::bind_event_handler(
            &new_button.handle,
            &self.window.handle,
            move |evt, _evt_data, handle| match evt {
                nwg::Event::OnButtonClick => {
                    if handle == new_button_handle {
                        nwg::simple_message(&title, &content);
                    }
                }
                _ => {}
            },
        );

        buttons.push(new_button);
        handlers.push(handler);
    }

    fn exit(&self) {
        let handlers = self.handlers.borrow();
        for handler in handlers.iter() {
            nwg::unbind_event_handler(&handler);
        }

        nwg::stop_thread_dispatch();
    }
}

//
// ALL of this stuff is handled by native-windows-derive
//
mod message_bank_ui {
    use super::*;
    use native_windows_gui2 as nwg;
    use std::cell::RefCell;
    use std::ops::Deref;
    use std::rc::Rc;

    pub struct MessageBankUi {
        inner: Rc<MessageBank>,
        default_handler: RefCell<Vec<nwg::EventHandler>>,
    }

    impl nwg::NativeUi<MessageBankUi> for MessageBank {
        fn build_ui(mut data: MessageBank) -> Result<MessageBankUi, nwg::NwgError> {
            use nwg::Event as E;

            // Controls
            nwg::Window::builder()
                .flags(nwg::WindowFlags::MAIN_WINDOW | nwg::WindowFlags::VISIBLE)
                .size((400, 300))
                .position((800, 300))
                .title("My message bank")
                .build(&mut data.window)?;

            nwg::TextInput::builder()
                .text("Hello World!")
                .focus(true)
                .parent(&data.window)
                .build(&mut data.message_content)?;

            nwg::Button::builder()
                .text("Save")
                .parent(&data.window)
                .build(&mut data.add_message_btn)?;

            nwg::TextInput::builder()
                .text("Title")
                .parent(&data.window)
                .build(&mut data.message_title)?;

            // Wrap-up
            let ui = MessageBankUi {
                inner: Rc::new(data),
                default_handler: Default::default(),
            };

            // Events
            let window_handles = [&ui.window.handle];

            for handle in window_handles.iter() {
                let evt_ui = Rc::downgrade(&ui.inner);
                let handle_events = move |evt, _evt_data, handle| {
                    if let Some(evt_ui) = evt_ui.upgrade() {
                        match evt {
                            E::OnButtonClick => {
                                if &handle == &evt_ui.add_message_btn {
                                    MessageBank::add_message(&evt_ui);
                                }
                            }
                            E::OnWindowClose => {
                                if &handle == &evt_ui.window {
                                    MessageBank::exit(&evt_ui);
                                }
                            }
                            _ => {}
                        }
                    }
                };

                ui.default_handler
                    .borrow_mut()
                    .push(nwg::full_bind_event_handler(handle, handle_events));
            }

            // Layout
            nwg::GridLayout::builder()
                .parent(&ui.window)
                .max_row(Some(6))
                .child(0, 0, &ui.add_message_btn)
                .child_item(nwg::GridLayoutItem::new(&ui.message_title, 1, 0, 2, 1))
                .child_item(nwg::GridLayoutItem::new(&ui.message_content, 3, 0, 3, 1))
                .build(&ui.layout)?;

            return Ok(ui);
        }

examples/basic.rs (line 70)

        fn build_ui(mut data: BasicApp) -> Result<BasicAppUi, nwg::NwgError> {
            use nwg::Event as E;

            // Controls
            nwg::Window::builder()
                .flags(nwg::WindowFlags::WINDOW | nwg::WindowFlags::VISIBLE)
                .size((300, 135))
                .position((300, 300))
                .title("Basic example")
                .build(&mut data.window)?;

            nwg::TextInput::builder()
                .size((280, 35))
                .position((10, 10))
                .text("Heisenberg")
                .parent(&data.window)
                .focus(true)
                .build(&mut data.name_edit)?;

            nwg::Button::builder()
                .size((280, 70))
                .position((10, 50))
                .text("Say my name")
                .parent(&data.window)
                .build(&mut data.hello_button)?;

            // Wrap-up
            let ui = BasicAppUi {
                inner: Rc::new(data),
                default_handler: Default::default(),
            };

            // Events
            let evt_ui = Rc::downgrade(&ui.inner);
            let handle_events = move |evt, _evt_data, handle| {
                if let Some(ui) = evt_ui.upgrade() {
                    match evt {
                        E::OnButtonClick => {
                            if &handle == &ui.hello_button {
                                BasicApp::say_hello(&ui);
                            }
                        }
                        E::OnWindowClose => {
                            if &handle == &ui.window {
                                BasicApp::say_goodbye(&ui);
                            }
                        }
                        _ => {}
                    }
                }
            };

            *ui.default_handler.borrow_mut() = Some(nwg::full_bind_event_handler(
                &ui.window.handle,
                handle_events,
            ));

            return Ok(ui);
        }

examples/basic_barebone.rs (line 35)

fn main() {
    nwg::init().expect("Failed to init Native Windows GUI");
    nwg::Font::set_global_family("Segoe UI").expect("Failed to set default font");

    let mut window = Default::default();
    let mut name_edit = Default::default();
    let mut hello_button = Default::default();
    let layout = Default::default();

    nwg::Window::builder()
        .size((300, 115))
        .position((300, 300))
        .title("Basic example")
        .build(&mut window)
        .unwrap();

    nwg::TextInput::builder()
        .text("Heisenberg")
        .focus(true)
        .parent(&window)
        .build(&mut name_edit)
        .unwrap();

    nwg::Button::builder()
        .text("Say my name")
        .parent(&window)
        .build(&mut hello_button)
        .unwrap();

    nwg::GridLayout::builder()
        .parent(&window)
        .spacing(1)
        .child(0, 0, &name_edit)
        .child_item(nwg::GridLayoutItem::new(&hello_button, 0, 1, 1, 2))
        .build(&layout)
        .unwrap();

    let window = Rc::new(window);
    let events_window = window.clone();

    let handler = nwg::full_bind_event_handler(&window.handle, move |evt, _evt_data, handle| {
        use nwg::Event as E;

        match evt {
            E::OnWindowClose => {
                if &handle == &events_window as &nwg::Window {
                    nwg::modal_info_message(
                        &events_window.handle,
                        "Goodbye",
                        &format!("Goodbye {}", name_edit.text()),
                    );
                    nwg::stop_thread_dispatch();
                }
            }
            E::OnButtonClick => {
                if &handle == &hello_button {
                    nwg::modal_info_message(
                        &events_window.handle,
                        "Hello",
                        &format!("Hello {}", name_edit.text()),
                    );
                }
            }
            _ => {}
        }
    });

    nwg::dispatch_thread_events();
    nwg::unbind_event_handler(&handler);
}

examples/basic_layout.rs (line 69)

        fn build_ui(mut data: BasicApp) -> Result<BasicAppUi, nwg::NwgError> {
            use nwg::Event as E;

            // Controls
            nwg::Window::builder()
                .flags(nwg::WindowFlags::WINDOW | nwg::WindowFlags::VISIBLE)
                .size((300, 115))
                .position((300, 300))
                .title("Basic example")
                .build(&mut data.window)?;

            nwg::TextInput::builder()
                .text("Heisenberg")
                .parent(&data.window)
                .focus(true)
                .build(&mut data.name_edit)?;

            nwg::Button::builder()
                .text("Say my name")
                .parent(&data.window)
                .build(&mut data.hello_button)?;

            // Wrap-up
            let ui = BasicAppUi {
                inner: Rc::new(data),
                default_handler: Default::default(),
            };

            // Events
            let evt_ui = Rc::downgrade(&ui.inner);
            let handle_events = move |evt, _evt_data, handle| {
                if let Some(evt_ui) = evt_ui.upgrade() {
                    match evt {
                        E::OnButtonClick => {
                            if &handle == &evt_ui.hello_button {
                                BasicApp::say_hello(&evt_ui);
                            }
                        }
                        E::OnWindowClose => {
                            if &handle == &evt_ui.window {
                                BasicApp::say_goodbye(&evt_ui);
                            }
                        }
                        _ => {}
                    }
                }
            };

            *ui.default_handler.borrow_mut() = Some(nwg::full_bind_event_handler(
                &ui.window.handle,
                handle_events,
            ));

            // Layouts
            nwg::GridLayout::builder()
                .parent(&ui.window)
                .spacing(1)
                .child(0, 0, &ui.name_edit)
                .child_item(nwg::GridLayoutItem::new(&ui.hello_button, 0, 1, 1, 2))
                .build(&ui.layout)?;

            return Ok(ui);
        }

examples/partials.rs (line 309)

        fn build_partial<W: Into<ControlHandle>>(
            data: &mut PeopleUi,
            parent: Option<W>,
        ) -> Result<(), NwgError> {
            let parent = parent.unwrap().into();

            nwg::Label::builder()
                .text("Name:")
                .h_align(nwg::HTextAlign::Right)
                .parent(&parent)
                .build(&mut data.label1)?;

            nwg::Label::builder()
                .text("Age:")
                .h_align(nwg::HTextAlign::Right)
                .parent(&parent)
                .build(&mut data.label2)?;

            nwg::Label::builder()
                .text("Job:")
                .h_align(nwg::HTextAlign::Right)
                .parent(&parent)
                .build(&mut data.label3)?;

            nwg::TextInput::builder()
                .text("John Doe")
                .parent(&parent)
                .build(&mut data.name_input)?;

            nwg::TextInput::builder()
                .text("75")
                .flags(nwg::TextInputFlags::VISIBLE | nwg::TextInputFlags::NUMBER)
                .parent(&parent)
                .build(&mut data.age_input)?;

            nwg::TextInput::builder()
                .text("Programmer")
                .parent(&parent)
                .build(&mut data.job_input)?;

            nwg::Button::builder()
                .text("Save")
                .parent(&parent)
                .build(&mut data.save_btn)?;

            nwg::GridLayout::builder()
                .parent(&parent)
                .max_size([1000, 150])
                .min_size([100, 120])
                .child(0, 0, &data.label1)
                .child(0, 1, &data.label2)
                .child(0, 2, &data.label3)
                .child(1, 0, &data.name_input)
                .child(1, 1, &data.age_input)
                .child(1, 2, &data.job_input)
                .build(&data.layout)?;

            nwg::GridLayout::builder()
                .min_size([100, 200])
                .max_column(Some(2))
                .max_row(Some(6))
                .child(1, 5, &data.save_btn)
                .parent(&parent)
                .build(&data.layout2)?;

            Ok(())
        }

        fn process_event<'a>(
            &self,
            _evt: nwg::Event,
            _evt_data: &nwg::EventData,
            _handle: ControlHandle,
        ) {
        }

        fn handles(&self) -> Vec<&ControlHandle> {
            Vec::new()
        }
    }
}

mod partial_animal_ui {
    use self::nwg::{ControlHandle, NwgError, PartialUi};
    use super::*;
    use native_windows_gui2 as nwg;

    impl PartialUi for AnimalUi {
        fn build_partial<W: Into<ControlHandle>>(
            data: &mut AnimalUi,
            parent: Option<W>,
        ) -> Result<(), NwgError> {
            let parent = parent.unwrap().into();

            nwg::Label::builder()
                .text("Name:")
                .h_align(nwg::HTextAlign::Right)
                .parent(&parent)
                .build(&mut data.label1)?;

            nwg::Label::builder()
                .text("Race:")
                .h_align(nwg::HTextAlign::Right)
                .parent(&parent)
                .build(&mut data.label2)?;

            nwg::Label::builder()
                .text("Is fluffy:")
                .h_align(nwg::HTextAlign::Right)
                .parent(&parent)
                .build(&mut data.label3)?;

            nwg::TextInput::builder()
                .text("Mittens")
                .parent(&parent)
                .build(&mut data.name_input)?;

            nwg::ComboBox::builder()
                .collection(vec!["Cat", "Dog", "Pidgeon", "Monkey"])
                .selected_index(Some(0))
                .parent(&parent)
                .build(&mut data.race_input)?;

            nwg::CheckBox::builder()
                .text("")
                .check_state(nwg::CheckBoxState::Checked)
                .parent(&parent)
                .build(&mut data.is_soft_input)?;

            nwg::Button::builder()
                .text("Save")
                .parent(&parent)
                .build(&mut data.save_btn)?;

            nwg::GridLayout::builder()
                .parent(&parent)
                .max_size([1000, 150])
                .min_size([100, 120])
                .child(0, 0, &data.label1)
                .child(0, 1, &data.label2)
                .child(0, 2, &data.label3)
                .child(1, 0, &data.name_input)
                .child(1, 1, &data.race_input)
                .child(1, 2, &data.is_soft_input)
                .build(&data.layout)?;

            nwg::GridLayout::builder()
                .min_size([100, 200])
                .max_column(Some(2))
                .max_row(Some(6))
                .child(1, 5, &data.save_btn)
                .parent(&parent)
                .build(&data.layout2)?;

            Ok(())
        }

        fn process_event<'a>(
            &self,
            _evt: nwg::Event,
            _evt_data: &nwg::EventData,
            _handle: ControlHandle,
        ) {
        }

        fn handles(&self) -> Vec<&ControlHandle> {
            Vec::new()
        }
    }
}

mod partial_food_ui {
    use self::nwg::{ControlHandle, NwgError, PartialUi};
    use super::*;
    use native_windows_gui2 as nwg;

    impl PartialUi for FoodUi {
        fn build_partial<W: Into<ControlHandle>>(
            data: &mut FoodUi,
            parent: Option<W>,
        ) -> Result<(), NwgError> {
            let parent = parent.unwrap().into();

            nwg::Label::builder()
                .text("Name:")
                .h_align(nwg::HTextAlign::Right)
                .parent(&parent)
                .build(&mut data.label1)?;

            nwg::Label::builder()
                .text("Tasty:")
                .h_align(nwg::HTextAlign::Right)
                .parent(&parent)
                .build(&mut data.label2)?;

            nwg::TextInput::builder()
                .text("Banana")
                .parent(&parent)
                .build(&mut data.name_input)?;

            nwg::CheckBox::builder()
                .text("")
                .check_state(nwg::CheckBoxState::Checked)
                .parent(&parent)
                .build(&mut data.tasty_input)?;

            nwg::Button::builder()
                .text("Save")
                .parent(&parent)
                .build(&mut data.save_btn)?;

            nwg::GridLayout::builder()
                .parent(&parent)
                .max_size([1000, 90])
                .min_size([100, 80])
                .child(0, 0, &data.label1)
                .child(0, 1, &data.label2)
                .child(1, 0, &data.name_input)
                .child(1, 1, &data.tasty_input)
                .build(&data.layout)?;

            nwg::GridLayout::builder()
                .min_size([100, 200])
                .max_column(Some(2))
                .max_row(Some(6))
                .child(1, 5, &data.save_btn)
                .parent(&parent)
                .build(&data.layout2)?;

            Ok(())
        }

Additional examples can be found in:

• examples/flexbox_sub_layout.rs
• examples/flexbox.rs
• examples/calculator.rs

pub fn click(&self)

Simulate a user click

pub fn set_bitmap<'a>(&self, image: Option<&'a Bitmap>)

Sets the bitmap image of the button. Replace the current bitmap or icon. Set image to None to remove the image

pub fn set_icon<'a>(&self, image: Option<&'a Icon>)

Sets the bitmap image of the button. Replace the current bitmap or icon. Set image to None to remove the image

pub fn image<'a>(&self, bitmap: &mut Option<Bitmap>, icon: &mut Option<Icon>)

Returns the current image in the button. If the button has a bitmap, the value will be returned in bitmap If the button has a icon, the value will be returned in icon

pub fn font(&self) -> Option<Font>

Returns the font of the control

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

Sets the font of the control

pub fn focus(&self) -> bool

Returns true if the control currently has the keyboard focus

pub fn set_focus(&self)

Sets the keyboard focus on the button.

pub fn enabled(&self) -> bool

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

pub fn set_enabled(&self, v: bool)

Enable or disable the control

pub fn visible(&self) -> bool

Returns 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))

pub fn set_visible(&self, v: bool)

Show or hide the control to the user

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

Returns the size of the button in the parent window

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

Sets the size of the button in the parent window

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

Returns the position of the button in the parent window

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

Sets the position of the button in the parent window

pub fn text(&self) -> String

Returns the button label

Examples found in repository

examples/calculator.rs (line 47)

    fn number(&self, button: &nwg::Button) {
        let text = self.input.text();
        self.input.set_text(&format!("{}{}", text, button.text()));
    }

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

Sets the button label

pub fn class_name(&self) -> &'static str

Winapi class name used during control creation

pub fn flags(&self) -> u32

Winapi base flags used during window creation

pub fn forced_flags(&self) -> u32

Winapi flags required by the control

Trait Implementations

impl Default for Button

fn default() -> Button

Returns the “default value” for a type.

impl Drop for Button

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl Eq for Button

impl From<&Button> for ControlHandle

fn from(control: &Button) -> Self

Converts to this type from the input type.

impl From<&mut Button> for ControlHandle

fn from(control: &mut Button) -> Self

Converts to this type from the input type.

impl PartialEq for Button

fn eq(&self, other: &Button) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Button> for ControlHandle

fn eq(&self, other: &Button) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<ControlHandle> for Button

fn eq(&self, other: &ControlHandle) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Button