Struct ListBox

pub struct ListBox<D: Display + Default> {
    pub handle: ControlHandle,
    /* private fields */
}

A list box is a control window that contains a simple list of items from which the user can choose.

Requires the list-box feature.

Builder parameters:

• parent: Required. The listbox parent container.
• size: The listbox size.
• position: The listbox position.
• enabled: If the listbox can be used by the user. It also has a grayed out look if disabled.
• focus: The control receive focus after being created
• flags: A combination of the ListBoxFlags 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 listbox text
• collection: The default collections of the listbox
• selected_index: The default selected index in the listbox collection
• multi_selection: The collections of indices to set as selected in a multi selection listbox

Control events:

• OnListBoxSelect: When the current listbox selection is changed
• OnListBoxDoubleClick: When a listbox item is clicked twice rapidly
• MousePress(_): Generic mouse press events on the listbox
• OnMouseMove: Generic mouse mouse event
• OnMouseWheel: Generic mouse wheel event

use native_windows_gui as nwg;
fn build_listbox(listb: &mut nwg::ListBox<&'static str>, window: &nwg::Window, font: &nwg::Font) {
    nwg::ListBox::builder()
        .flags(nwg::ListBoxFlags::VISIBLE | nwg::ListBoxFlags::MULTI_SELECT)
        .collection(vec!["Hello", "World", "!!!!"])
        .multi_selection(vec![0, 1, 2])
        .font(Some(font))
        .parent(window)
        .build(listb);
}

Fields

handle: ControlHandle

Implementations

impl<D: Display + Default> ListBox<D>

pub fn builder<'a>() -> ListBoxBuilder<'a, D>

Examples found in repository

examples/partials.rs (line 142)

        fn build_ui(mut data: PartialDemo) -> Result<Rc<PartialDemoUi>, nwg::NwgError> {
            use nwg::Event as E;
            
            // Controls
            nwg::Window::builder()
                .size((500, 400))
                .position((300, 300))
                .title("Many UI")
                .build(&mut data.window)?;

            nwg::ListBox::builder()
                .collection(vec!["People", "Animals", "Food"])
                .focus(true)
                .parent(&data.window)
                .build(&mut data.menu)?;

            nwg::Frame::builder()
                .parent(&data.window)
                .build(&mut data.frame1)?;

            nwg::Frame::builder()
                .flags(nwg::FrameFlags::BORDER)
                .parent(&data.window)
                .build(&mut data.frame2)?;

            nwg::Frame::builder()
                .flags(nwg::FrameFlags::BORDER)
                .parent(&data.window)
                .build(&mut data.frame3)?;

            // Partials
            PeopleUi::build_partial(&mut data.people_ui, Some(&data.frame1))?;
            AnimalUi::build_partial(&mut data.animal_ui, Some(&data.frame2))?;
            FoodUi::build_partial(&mut data.food_ui, Some(&data.frame3))?;

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

            // Events
            let mut window_handles = vec![&ui.window.handle];
            window_handles.append(&mut ui.people_ui.handles());
            window_handles.append(&mut ui.animal_ui.handles());
            window_handles.append(&mut ui.food_ui.handles());

            for handle in window_handles.iter() {
                let evt_ui = ui.clone();
                let handle_events = move |evt, evt_data, handle| {
                    evt_ui.people_ui.process_event(evt, &evt_data, handle);
                    evt_ui.animal_ui.process_event(evt, &evt_data, handle);
                    evt_ui.food_ui.process_event(evt, &evt_data, handle);
                    
                    match evt {
                        E::OnListBoxSelect => 
                            if &handle == &evt_ui.menu {
                                PartialDemo::change_interface(&evt_ui.inner);
                            },
                        E::OnWindowClose => 
                            if &handle == &evt_ui.window {
                                PartialDemo::exit(&evt_ui.inner);
                            },
                        E::OnButtonClick => 
                            if &handle == &evt_ui.people_ui.save_btn || &handle == &evt_ui.animal_ui.save_btn ||&handle == &evt_ui.food_ui.save_btn  {
                                PartialDemo::save(&evt_ui.inner);
                            },
                        _ => {}
                    }
                };

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

            // Layout
            use nwg::stretch::{geometry::Size, style::Dimension as D};

           nwg::FlexboxLayout::builder()
                .parent(&ui.window)
                .child(&ui.menu)
                    .child_size(Size { width: D::Percent(0.3), height: D::Auto })
                .child(&ui.frame1)
                    .child_size(Size { width: D::Percent(1.0), height: D::Auto })
                .build(&ui.layout)?;
            
            return Ok(ui);
        }

pub fn push(&self, item: D)

Add a new item to the listbox. Sort the collection if the listbox is sorted.

pub fn insert(&self, index: usize, item: D)

Insert an item in the collection and the control.

SPECIAL behaviour! If index is std::usize::MAX, the item is added at the end of the collection. The method will still panic if index > len with every other values.

pub fn remove(&self, index: usize) -> D

Remove the item at the selected index and returns it. Panic of the index is out of bounds

pub fn selection(&self) -> Option<usize>

Return the index of the currencty selected item for single value list box. Return None if no item is selected.

Examples found in repository

examples/partials.rs (line 42)

    fn change_interface(&self) {
        self.frame1.set_visible(false);
        self.frame2.set_visible(false);
        self.frame3.set_visible(false);

        let layout = &self.layout;
        if layout.has_child(&self.frame1) { layout.remove_child(&self.frame1); }
        if layout.has_child(&self.frame2) { layout.remove_child(&self.frame2); }
        if layout.has_child(&self.frame3) { layout.remove_child(&self.frame3); }

        use nwg::stretch::{geometry::Size, style::{Style, Dimension as D}};
        let mut style = Style::default();
        style.size = Size { width: D::Percent(1.0), height: D::Auto };

        match self.menu.selection() {
            None | Some(0) => {
                layout.add_child(&self.frame1, style).unwrap();
                self.frame1.set_visible(true);
            },
            Some(1) => {
                layout.add_child(&self.frame2, style).unwrap();
                self.frame2.set_visible(true);
            },
            Some(2) => {
                layout.add_child(&self.frame3, style).unwrap();
                self.frame3.set_visible(true);
            },
            Some(_) => unreachable!()
        }
    }

pub fn multi_selection_len(&self) -> usize

Return the number of selected item in the list box Returns 0 for single select list box

pub fn multi_selection(&self) -> Vec<usize>

Return a list index Returns an empty vector for single select list box.

pub fn selection_string(&self) -> Option<String>

Return the display value of the currenctly selected item for single value Return None if no item is selected. This reads the visual value.

pub fn set_selection(&self, index: Option<usize>)

Set the currently selected item in the list box for single value list box. Does nothing if the index is out of bound If the value is None, remove the selected value

pub fn multi_add_selection(&self, index: usize)

Select the item as index index in a multi item list box

pub fn multi_remove_selection(&self, index: usize)

Unselect the item as index index in a multi item list box

pub fn unselect_all(&self)

Unselect every item in the list box

pub fn select_all(&self)

Select every item in the list box

pub fn multi_select_range(&self, range: Range<usize>)

Select a range of items in a multi list box

pub fn multi_unselect_range(&self, range: Range<usize>)

Unselect a range of items in a multi list box

pub fn set_selection_string(&self, value: &str) -> Option<usize>

Search an item that begins by the value and select the first one found. The search is not case sensitive, so this string can contain any combination of uppercase and lowercase letters. Return the index of the selected string or None if the search was not successful

pub fn selected(&self, index: usize) -> bool

Check if the item at index is selected by the user Return false if the index is out of range.

pub fn sync(&self)

Update the visual of the control with the inner collection. This rebuild every item in the list box and can take some time on big collections.

pub fn set_collection(&self, col: Vec<D>) -> Vec<D>

Set the item collection of the list box. Return the old collection

pub fn clear(&self)

Clears the control and free the underlying collection. Same as set_collection(Vec::new())

pub fn len(&self) -> usize

Return the number of items in the control. NOT the inner rust collection

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

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

Set the size of the button in the parent window

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

Return the position of the button in the parent window

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

Set the position of the button in the parent window

pub fn collection(&self) -> Ref<'_, Vec<D>>

Get read-only access to the inner collection of the list box This call refcell.borrow under the hood. Be sure to drop the value before calling other list box methods

pub fn collection_mut(&self) -> RefMut<'_, Vec<D>>

Get mutable access to the inner collection of the list box. Does not update the visual control. Call sync to update the view. This call refcell.borrow_mut under the hood. Be sure to drop the value before calling other list box methods

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<D: Default + Display + Default> Default for ListBox<D>

fn default() -> ListBox<D>

Returns the “default value” for a type.

impl<D: Display + Default> Drop for ListBox<D>

fn drop(&mut self)

Executes the destructor for this type.

impl<D: Display + Default> From<&ListBox<D>> for ControlHandle

fn from(control: &ListBox<D>) -> Self

Converts to this type from the input type.

impl<D: Display + Default> PartialEq<ControlHandle> for ListBox<D>

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<D: Display + Default> PartialEq<ListBox<D>> for ControlHandle

fn eq(&self, other: &ListBox<D>) -> 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<D: Display + Default> PartialEq for ListBox<D>

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.