Window

native_windows_gui2

Struct Window 

Source 
pub struct Window {
    pub handle: ControlHandle,
}
Expand description

A basic top level window. At least one top level window is required to make a NWG application.

Windows can be heavily customized using the window flags. If your application don’t need a visible window (ex: a system tray app), use MessageWindow instead.

Builder parameters:

  • flags: The window flags. See WindowFlags
  • ex_flags: A combination of win32 window extended flags. Unlike flags, ex_flags must be used straight from winapi
  • title: The text in the window title bar
  • size: The default size of the window
  • position: The default position of the window in the desktop
  • icon: The window icon
  • accept_file: If the window should accept files by drag & drop
  • maximized: If the window should be maximized at creation
  • minimized: If the window should be minimized at creation
  • center: Center the window in the current monitor based on its size. If true, this overrides position
  • topmost: If the window should always be on top of other system window
  • parent: Logical parent of the window, unlike children controls, this is NOT required.

Control events:

  • OnInit: The window was created
  • MousePress(_): Generic mouse press events on the button
  • OnMouseMove: Generic mouse mouse event
  • OnMouseWheel: Generic mouse wheel event
  • OnPaint: Generic on paint event
  • OnKeyPress: Generic key press
  • OnKeyRelease: Generic ket release
  • OnResize: When the window is resized
  • OnResizeBegin: Just before the window begins being resized by the user
  • OnResizeEnd: Just after the user stops resizing the window
  • OnWindowMaximize: When the window is maximized
  • OnWindowMinimize: When the window is minimized
  • OnMove: When the window is moved by the user
  • OnFileDrop: When a file is dropped in the window (only raised if accept_file is set)
  • OnMinMaxInfo: When the size or position of the window is about to change and the size of the windows must be restricted

Fields§

§handle: ControlHandle

Implementations§

Source§

impl Window

Source

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

Examples found in repository?
examples/partial_simple.rs (line 27)
26    fn build_ui(mut data: MainUi) -> Result<MainUiWrapper, nwg::NwgError> {
27        nwg::Window::builder()
28            .size((500, 200))
29            .position((500, 300))
30            .title("My Form")
31            .build(&mut data.window)?;
32
33        // !!! Partials controls setup !!!
34        SubmitForm::build_partial(&mut data.form, Some(&data.window))?;
35
36        let ui = MainUiWrapper {
37            inner: Rc::new(data),
38            default_handler: Default::default(),
39        };
40
41        // !!! Partials Event Binding !!!
42        let mut window_handles = vec![&ui.window.handle];
43        window_handles.append(&mut ui.form.handles());
44
45        for handle in window_handles.iter() {
46            let evt_ui = Rc::downgrade(&ui.inner);
47            let handle_events = move |evt, evt_data, handle| {
48                use nwg::Event as E;
49
50                if let Some(ui) = evt_ui.upgrade() {
51                    // !!! Partials Event Dispatch !!!
52                    ui.form.process_event(evt, &evt_data, handle);
53
54                    match evt {
55                        E::OnButtonClick => {
56                            if &handle == &ui.form.sumbit_button {
57                                println!("SAVING!");
58                            }
59                        }
60                        E::OnWindowClose => {
61                            if &handle == &ui.window {
62                                nwg::stop_thread_dispatch();
63                            }
64                        }
65                        _ => {}
66                    }
67                }
68            };
69
70            ui.default_handler
71                .borrow_mut()
72                .push(nwg::full_bind_event_handler(handle, handle_events));
73        }
74
75        return Ok(ui);
76    }
More examples
Hide additional examples
examples/basic.rs (line 55)
51        fn build_ui(mut data: BasicApp) -> Result<BasicAppUi, nwg::NwgError> {
52            use nwg::Event as E;
53
54            // Controls
55            nwg::Window::builder()
56                .flags(nwg::WindowFlags::WINDOW | nwg::WindowFlags::VISIBLE)
57                .size((300, 135))
58                .position((300, 300))
59                .title("Basic example")
60                .build(&mut data.window)?;
61
62            nwg::TextInput::builder()
63                .size((280, 35))
64                .position((10, 10))
65                .text("Heisenberg")
66                .parent(&data.window)
67                .focus(true)
68                .build(&mut data.name_edit)?;
69
70            nwg::Button::builder()
71                .size((280, 70))
72                .position((10, 50))
73                .text("Say my name")
74                .parent(&data.window)
75                .build(&mut data.hello_button)?;
76
77            // Wrap-up
78            let ui = BasicAppUi {
79                inner: Rc::new(data),
80                default_handler: Default::default(),
81            };
82
83            // Events
84            let evt_ui = Rc::downgrade(&ui.inner);
85            let handle_events = move |evt, _evt_data, handle| {
86                if let Some(ui) = evt_ui.upgrade() {
87                    match evt {
88                        E::OnButtonClick => {
89                            if &handle == &ui.hello_button {
90                                BasicApp::say_hello(&ui);
91                            }
92                        }
93                        E::OnWindowClose => {
94                            if &handle == &ui.window {
95                                BasicApp::say_goodbye(&ui);
96                            }
97                        }
98                        _ => {}
99                    }
100                }
101            };
102
103            *ui.default_handler.borrow_mut() = Some(nwg::full_bind_event_handler(
104                &ui.window.handle,
105                handle_events,
106            ));
107
108            return Ok(ui);
109        }
examples/basic_barebone.rs (line 21)
12fn main() {
13    nwg::init().expect("Failed to init Native Windows GUI");
14    nwg::Font::set_global_family("Segoe UI").expect("Failed to set default font");
15
16    let mut window = Default::default();
17    let mut name_edit = Default::default();
18    let mut hello_button = Default::default();
19    let layout = Default::default();
20
21    nwg::Window::builder()
22        .size((300, 115))
23        .position((300, 300))
24        .title("Basic example")
25        .build(&mut window)
26        .unwrap();
27
28    nwg::TextInput::builder()
29        .text("Heisenberg")
30        .focus(true)
31        .parent(&window)
32        .build(&mut name_edit)
33        .unwrap();
34
35    nwg::Button::builder()
36        .text("Say my name")
37        .parent(&window)
38        .build(&mut hello_button)
39        .unwrap();
40
41    nwg::GridLayout::builder()
42        .parent(&window)
43        .spacing(1)
44        .child(0, 0, &name_edit)
45        .child_item(nwg::GridLayoutItem::new(&hello_button, 0, 1, 1, 2))
46        .build(&layout)
47        .unwrap();
48
49    let window = Rc::new(window);
50    let events_window = window.clone();
51
52    let handler = nwg::full_bind_event_handler(&window.handle, move |evt, _evt_data, handle| {
53        use nwg::Event as E;
54
55        match evt {
56            E::OnWindowClose => {
57                if &handle == &events_window as &nwg::Window {
58                    nwg::modal_info_message(
59                        &events_window.handle,
60                        "Goodbye",
61                        &format!("Goodbye {}", name_edit.text()),
62                    );
63                    nwg::stop_thread_dispatch();
64                }
65            }
66            E::OnButtonClick => {
67                if &handle == &hello_button {
68                    nwg::modal_info_message(
69                        &events_window.handle,
70                        "Hello",
71                        &format!("Hello {}", name_edit.text()),
72                    );
73                }
74            }
75            _ => {}
76        }
77    });
78
79    nwg::dispatch_thread_events();
80    nwg::unbind_event_handler(&handler);
81}
examples/basic_layout.rs (line 56)
52        fn build_ui(mut data: BasicApp) -> Result<BasicAppUi, nwg::NwgError> {
53            use nwg::Event as E;
54
55            // Controls
56            nwg::Window::builder()
57                .flags(nwg::WindowFlags::WINDOW | nwg::WindowFlags::VISIBLE)
58                .size((300, 115))
59                .position((300, 300))
60                .title("Basic example")
61                .build(&mut data.window)?;
62
63            nwg::TextInput::builder()
64                .text("Heisenberg")
65                .parent(&data.window)
66                .focus(true)
67                .build(&mut data.name_edit)?;
68
69            nwg::Button::builder()
70                .text("Say my name")
71                .parent(&data.window)
72                .build(&mut data.hello_button)?;
73
74            // Wrap-up
75            let ui = BasicAppUi {
76                inner: Rc::new(data),
77                default_handler: Default::default(),
78            };
79
80            // Events
81            let evt_ui = Rc::downgrade(&ui.inner);
82            let handle_events = move |evt, _evt_data, handle| {
83                if let Some(evt_ui) = evt_ui.upgrade() {
84                    match evt {
85                        E::OnButtonClick => {
86                            if &handle == &evt_ui.hello_button {
87                                BasicApp::say_hello(&evt_ui);
88                            }
89                        }
90                        E::OnWindowClose => {
91                            if &handle == &evt_ui.window {
92                                BasicApp::say_goodbye(&evt_ui);
93                            }
94                        }
95                        _ => {}
96                    }
97                }
98            };
99
100            *ui.default_handler.borrow_mut() = Some(nwg::full_bind_event_handler(
101                &ui.window.handle,
102                handle_events,
103            ));
104
105            // Layouts
106            nwg::GridLayout::builder()
107                .parent(&ui.window)
108                .spacing(1)
109                .child(0, 0, &ui.name_edit)
110                .child_item(nwg::GridLayoutItem::new(&ui.hello_button, 0, 1, 1, 2))
111                .build(&ui.layout)?;
112
113            return Ok(ui);
114        }
examples/message_bank.rs (line 91)
87        fn build_ui(mut data: MessageBank) -> Result<MessageBankUi, nwg::NwgError> {
88            use nwg::Event as E;
89
90            // Controls
91            nwg::Window::builder()
92                .flags(nwg::WindowFlags::MAIN_WINDOW | nwg::WindowFlags::VISIBLE)
93                .size((400, 300))
94                .position((800, 300))
95                .title("My message bank")
96                .build(&mut data.window)?;
97
98            nwg::TextInput::builder()
99                .text("Hello World!")
100                .focus(true)
101                .parent(&data.window)
102                .build(&mut data.message_content)?;
103
104            nwg::Button::builder()
105                .text("Save")
106                .parent(&data.window)
107                .build(&mut data.add_message_btn)?;
108
109            nwg::TextInput::builder()
110                .text("Title")
111                .parent(&data.window)
112                .build(&mut data.message_title)?;
113
114            // Wrap-up
115            let ui = MessageBankUi {
116                inner: Rc::new(data),
117                default_handler: Default::default(),
118            };
119
120            // Events
121            let window_handles = [&ui.window.handle];
122
123            for handle in window_handles.iter() {
124                let evt_ui = Rc::downgrade(&ui.inner);
125                let handle_events = move |evt, _evt_data, handle| {
126                    if let Some(evt_ui) = evt_ui.upgrade() {
127                        match evt {
128                            E::OnButtonClick => {
129                                if &handle == &evt_ui.add_message_btn {
130                                    MessageBank::add_message(&evt_ui);
131                                }
132                            }
133                            E::OnWindowClose => {
134                                if &handle == &evt_ui.window {
135                                    MessageBank::exit(&evt_ui);
136                                }
137                            }
138                            _ => {}
139                        }
140                    }
141                };
142
143                ui.default_handler
144                    .borrow_mut()
145                    .push(nwg::full_bind_event_handler(handle, handle_events));
146            }
147
148            // Layout
149            nwg::GridLayout::builder()
150                .parent(&ui.window)
151                .max_row(Some(6))
152                .child(0, 0, &ui.add_message_btn)
153                .child_item(nwg::GridLayoutItem::new(&ui.message_title, 1, 0, 2, 1))
154                .child_item(nwg::GridLayoutItem::new(&ui.message_content, 3, 0, 3, 1))
155                .build(&ui.layout)?;
156
157            return Ok(ui);
158        }
examples/flexbox_sub_layout.rs (line 46)
42        fn build_ui(mut data: FlexBoxApp) -> Result<FlexBoxAppUi, nwg::NwgError> {
43            use nwg::Event as E;
44
45            // Controls
46            nwg::Window::builder()
47                .size((500, 500))
48                .position((300, 300))
49                .title("Flexbox example")
50                .build(&mut data.window)?;
51
52            nwg::Button::builder()
53                .text("Btn 1")
54                .parent(&data.window)
55                .focus(true)
56                .build(&mut data.button1)?;
57
58            nwg::Button::builder()
59                .text("Btn 2")
60                .parent(&data.window)
61                .focus(true)
62                .build(&mut data.button2)?;
63
64            nwg::Button::builder()
65                .text("Btn 3")
66                .parent(&data.window)
67                .focus(true)
68                .build(&mut data.button3)?;
69
70            // Wrap-up
71            let ui = FlexBoxAppUi {
72                inner: Rc::new(data),
73                default_handler: Default::default(),
74            };
75
76            // Events
77            let evt_ui = Rc::downgrade(&ui.inner);
78            let handle_events = move |evt, _evt_data, handle| {
79                if let Some(evt_ui) = evt_ui.upgrade() {
80                    match evt {
81                        E::OnWindowClose => {
82                            if &handle == &evt_ui.window {
83                                FlexBoxApp::exit(&evt_ui);
84                            }
85                        }
86                        _ => {}
87                    }
88                }
89            };
90
91            *ui.default_handler.borrow_mut() = Some(nwg::full_bind_event_handler(
92                &ui.window.handle,
93                handle_events,
94            ));
95
96            // Layout
97            use nwg::stretch::{
98                geometry::Size,
99                style::{Dimension as D, FlexDirection},
100            };
101
102            nwg::FlexboxLayout::builder()
103                .parent(&ui.window)
104                .flex_direction(FlexDirection::Column)
105                .child(&ui.button2)
106                .child_size(Size {
107                    width: D::Auto,
108                    height: D::Points(200.0),
109                })
110                .child(&ui.button3)
111                .child_flex_grow(2.0)
112                .child_size(Size {
113                    width: D::Auto,
114                    height: D::Auto,
115                })
116                .build_partial(&ui.layout2)?;
117
118            nwg::FlexboxLayout::builder()
119                .parent(&ui.window)
120                .flex_direction(FlexDirection::Row)
121                .child(&ui.button1)
122                .child_flex_grow(2.0)
123                .child_size(Size {
124                    width: D::Auto,
125                    height: D::Auto,
126                })
127                .child_layout(&ui.layout2)
128                .child_size(Size {
129                    width: D::Points(300.0),
130                    height: D::Auto,
131                })
132                .build(&ui.layout)?;
133
134            return Ok(ui);
135        }
Additional examples can be found in:
Source

pub fn maximize(&self)

Maximize the window

Source

pub fn minimize(&self)

Minimize the window

Source

pub fn restore(&self)

Restore a minimized/maximized window

Source

pub fn invalidate(&self)

Force the window to refraw iteself and all its children

Source

pub fn close(&self)

Close the window as if the user clicked the X button.

Source

pub fn icon(&self) -> Option<Icon>

Return the icon of the window

Source

pub fn set_icon(&self, icon: Option<&Icon>)

Set the icon in the window

  • icon: The new icon. If None, the icon is removed
Source

pub fn focus(&self) -> bool

Return true if the control currently has the keyboard focus

Source

pub fn set_focus(&self)

Set the keyboard focus on the button

Source

pub fn enabled(&self) -> bool

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

Source

pub fn set_enabled(&self, v: bool)

Enable or disable the control

Source

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

Source

pub fn set_visible(&self, v: bool)

Show or hide the control to the user

Source

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

Return the size of the button in the parent window

Source

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

Set the size of the button in the parent window

Source

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

Return the position of the button in the parent window

Source

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

Set the position of the button in the parent window

Source

pub fn text(&self) -> String

Return window title

Source

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

Set the window title

Source

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

Winapi class name used during control creation

Source

pub fn flags(&self) -> u32

Source

pub fn forced_flags(&self) -> u32

Winapi flags required by the control

Trait Implementations§

Source§

impl Default for Window

Source§

fn default() -> Window

Returns the “default value” for a type. Read more
Source§

impl Drop for Window

Source§

fn drop(&mut self)

Executes the destructor for this type. Read more
Source§

impl From<&Window> for ControlHandle

Source§

fn from(control: &Window) -> Self

Converts to this type from the input type.
Source§

impl From<&mut Window> for ControlHandle

Source§

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

Converts to this type from the input type.
Source§

impl PartialEq<ControlHandle> for Window

Source§

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

Tests for self and other values to be equal, and is used by ==.
1.0.0 · Source§

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

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

impl PartialEq<Window> for ControlHandle

Source§

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

Tests for self and other values to be equal, and is used by ==.
1.0.0 · Source§

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

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

impl PartialEq for Window

Source§

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

Tests for self and other values to be equal, and is used by ==.
1.0.0 · Source§

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

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

impl Eq for Window

Source§

impl StructuralPartialEq for Window

Auto Trait Implementations§

§

impl Freeze for Window

§

impl RefUnwindSafe for Window

§

impl !Send for Window

§

impl !Sync for Window

§

impl Unpin for Window

§

impl UnwindSafe for Window

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.