Struct CheckBox

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

A check box consists of a square box and an application-defined labe that indicates a choice the user can make by selecting the button. Applications typically display check boxes to enable the user to choose one or more options that are not mutually exclusive.

CheckBox is not behind any features.

Builder parameters:

• parent: Required. The checkbox parent container.
• text: The checkbox text.
• size: The checkbox size.
• position: The checkbox position.
• enabled: If the checkbox can be used by the user. It also has a grayed out look if disabled.
• flags: A combination of the CheckBoxFlags 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 checkbox text
• background_color: The background color of the checkbox. Defaults to the default window background (light gray)
• check_state: The default check state
• focus: The control receive focus after being created

Control events:

• OnButtonClick: When the checkbox is clicked once by the user
• OnButtonDoubleClick: When the checkbox is clicked twice rapidly by the user
• MousePress(_): Generic mouse press events on the checkbox
• OnMouseMove: Generic mouse mouse event
• OnMouseWheel: Generic mouse wheel event

use native_windows_gui as nwg;
fn build_checkbox(button: &mut nwg::CheckBox, window: &nwg::Window, font: &nwg::Font) {
    nwg::CheckBox::builder()
        .text("Hello")
        .flags(nwg::CheckBoxFlags::VISIBLE)
        .font(Some(font))
        .parent(window)
        .build(button);
}

Fields

handle: ControlHandle

Implementations

impl CheckBox

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

Examples found in repository

examples/partials.rs (line 363)

        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 native_windows_gui as nwg;
    use self::nwg::{PartialUi, NwgError, ControlHandle};
    use super::*;

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

pub fn tristate(&self) -> bool

Return true if the checkbox can have a third state or false otherwise

pub fn set_tristate(&self, tri: bool)

Sets or unsets the checkbox as tristate

pub fn check_state(&self) -> CheckBoxState

Return the check state of the check box

pub fn set_check_state(&self, state: CheckBoxState)

Sets the check state of the check box

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

Return the font of the control

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

Set the font of the control

pub fn focus(&self) -> bool

Return true if the control currently has the keyboard focus

pub fn set_focus(&self)

Set the keyboard focus on the button.

pub fn enabled(&self) -> bool

Return 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

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

pub fn set_visible(&self, v: bool)

Show or hide the control to the user

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

Return the size of the check box in the parent window

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

Set the size of the check box in the parent window

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

Return the position of the check box in the parent window

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

Set the position of the check box in the parent window

pub fn text(&self) -> String

Return the check box label

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

Set the check box 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 CheckBox

fn default() -> CheckBox

Returns the “default value” for a type.

impl Drop for CheckBox

fn drop(&mut self)

Executes the destructor for this type.

impl From<&CheckBox> for ControlHandle

fn from(control: &CheckBox) -> Self

Converts to this type from the input type.

impl From<&mut CheckBox> for ControlHandle

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

Converts to this type from the input type.

impl PartialEq<CheckBox> for ControlHandle

fn eq(&self, other: &CheckBox) -> 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 CheckBox

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 PartialEq for CheckBox

fn eq(&self, other: &Self) -> 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.