Struct Frame 

pub struct Frame {
    pub handle: ControlHandle,
}

A frame is a rectangle containing children controls. Frame is implemented as a custom control.

Requires the frame feature.

Builder parameters:

• parent: Required. The frame parent container.
• size: The frame size.
• position: The frame position.
• enabled: If the frame children can be used by the user.
• flags: A combination of the FrameFlags values.
• ex_flags: A combination of win32 window extended flags. Unlike flags, ex_flags must be used straight from winapi

Control events:

• MousePress(_): Generic mouse press events on the button
• OnMouseMove: Generic mouse mouse event
• OnMouseWheel: Generic mouse wheel event

Fields

handle: ControlHandle

Implementations

impl Frame

pub fn builder() -> FrameBuilder

Examples found in repository

examples/partials.rs (line 157)

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

Examples found in repository

examples/partials.rs (line 27)

    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::{Dimension as D, Style},
        };
        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 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 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 Frame

fn default() -> Frame

Returns the “default value” for a type.

impl Drop for Frame

fn drop(&mut self)

Executes the destructor for this type.

impl From<&Frame> for ControlHandle

fn from(control: &Frame) -> Self

Converts to this type from the input type.

impl From<&mut Frame> for ControlHandle

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

Converts to this type from the input type.

impl PartialEq<ControlHandle> for Frame

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

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

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

impl StructuralPartialEq for Frame