Struct Label 

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

A label is a single line of static text. Use \r\n to split the text on multiple lines.

Label is not behind any features.

Builder parameters:

• parent: Required. The label parent container.
• text: The label text.
• size: The label size.
• position: The label position.
• enabled: If the label is enabled. A disabled label won’t trigger events
• flags: A combination of the LabelFlags 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 label text
• background_color: The background color of the label
• h_align: The horizontal aligment of the label

Control events:

• OnLabelClick: When the user click the label
• OnLabelDoubleClick: When the user double click a label
• MousePress(_): Generic mouse press events on the label
• OnMouseMove: Generic mouse mouse event
• OnMouseWheel: Generic mouse wheel event

** Example **

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

Fields

handle: ControlHandle

Implementations

impl Label

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

Examples found in repository

examples/partials.rs (line 275)

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

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 label in the parent window

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

Set the size of the label in the parent window

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

Return the position of the label in the parent window

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

Set the position of the label in the parent window

pub fn text(&self) -> String

Return the label text

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

Set the label text

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 Label

fn default() -> Label

Returns the “default value” for a type.

impl Drop for Label

fn drop(&mut self)

Executes the destructor for this type.

impl From<&Label> for ControlHandle

fn from(control: &Label) -> Self

Converts to this type from the input type.

impl From<&mut Label> for ControlHandle

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

Converts to this type from the input type.

impl PartialEq<ControlHandle> for Label

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<Label> for ControlHandle

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

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.