Native Windows GUI

https://docs.rs/native-windows-gui
Admin
Native Windows GUI is a lightweight Rust library that provides bindings and abstractions for...
Tokens:712,968
Snippets:6,024
Trust Score:9.7
Update:3 months ago
Show doc for...
Tokens:
Raw
### Building a System Tray Menu Item

Source: https://docs.rs/native-windows-gui/latest/native_windows_gui/struct.MenuItemBuilder.html

This example demonstrates how to build a system tray menu item with specific text. It's part of a larger system tray UI setup.

```rust
            nwg::MenuItem::builder()
                .text("Hello")
                .parent(&data.tray_menu)
                .build(&mut data.tray_item1)?;
```

--------------------------------

### Timer Builder and Usage

Source: https://docs.rs/native-windows-gui/latest/src/native_windows_gui/controls/timer.rs.html

This example demonstrates how to build and use a Timer control. It sets the parent window, interval, and initial stopped state, then shows how to start and stop the timer.

```APIDOC
## Timer Builder and Usage

### Description

This example demonstrates how to build and use a Timer control. It sets the parent window, interval, and initial stopped state, then shows how to start and stop the timer.

### Builder Parameters:

* `parent`: **Required.** The timer parent container. Should be a top level window.
* `interval`: The timer tick interval in milliseconds.
* `stopped`: If the timer should start right away. By default timers start "stopped(true)". Be sure to include `stopped(false)` in your builder if you want the timer to start instantly.

### Control Events:

* `OnTimerTick`: When the timer ticks

### Method

```rust
use native_windows_gui as nwg

fn build_and_use_timer(parent: &nwg::Window) {
    let mut timer = Default::default();
    nwg::Timer::builder()
        .parent(parent)
        .interval(100)
        .stopped(false) // Start the timer immediately
        .build(&mut timer);

    // To stop the timer later:
    // timer.stop();

    // To start the timer if it was stopped:
    // timer.start();
}
```

### Methods:

* **`valid()`**: Checks if the timer is still usable. Returns `true` if the timer is valid and its parent window has not been destroyed, `false` otherwise.
* **`interval()`**: Returns the current interval of the timer in milliseconds.
* **`set_interval(i: u32)`**: Sets the interval of the timer in milliseconds.
* **`stop()`**: Stops the timer. Panics if the timer is not bound or if the parent window is destroyed.
* **`start()`**: Starts the timer. If the timer is already running, this restarts it. Panics if the timer is not bound or if the parent window is destroyed.
```

--------------------------------

### Build a MessageWindow

Source: https://docs.rs/native-windows-gui/latest/native_windows_gui/struct.MessageWindowBuilder.html

This example demonstrates how to build a MessageWindow as part of a larger UI setup, specifically within a system tray application. It shows the creation of the MessageWindow before other controls like TrayNotification and Menus are configured.

```rust
nwg::MessageWindow::builder()
    .build(&mut data.window)?;
```

--------------------------------

### Full UI Example with Flexbox Layouts

Source: https://docs.rs/native-windows-gui/latest/native_windows_gui/struct.FlexboxLayoutBuilder.html

This example demonstrates setting up a native Windows GUI application using NWG, including creating windows, buttons, and configuring nested Flexbox layouts. It shows how to build both partial and complete layouts and attach them to the UI.

```rust
fn build_ui(mut data: FlexBoxApp) -> Result<FlexBoxAppUi, nwg::NwgError> {
            use nwg::Event as E;
            
            // Controls
            nwg::Window::builder()
                .size((500, 500))
                .position((300, 300))
                .title("Flexbox example")
                .build(&mut data.window)?;

            nwg::Button::builder()
                .text("Btn 1")
                .parent(&data.window)
                .focus(true)
                .build(&mut data.button1)?;

            nwg::Button::builder()
                .text("Btn 2")
                .parent(&data.window)
                .focus(true)
                .build(&mut data.button2)?;

            nwg::Button::builder()
                .text("Btn 3")
                .parent(&data.window)
                .focus(true)
                .build(&mut data.button3)?;

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

            // Events
            let evt_ui = Rc::downgrade(&ui.inner);
            let handle_events = move |evt, _evt_data, handle| {
                if let Some(evt_ui) = evt_ui.upgrade() {
                    match evt {
                        E::OnWindowClose => 
                            if &handle == &evt_ui.window {
                                FlexBoxApp::exit(&evt_ui);
                            },
                        _ => {}
                    }
                }
            };

           *ui.default_handler.borrow_mut() = Some(nwg::full_bind_event_handler(&ui.window.handle, handle_events));


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

            nwg::FlexboxLayout::builder()
                .parent(&ui.window)
                .flex_direction(FlexDirection::Column)
                .child(&ui.button2)
                    .child_size(Size { width: D::Auto, height: D::Points(200.0) })
                .child(&ui.button3)
                    .child_flex_grow(2.0)
                    .child_size(Size { width: D::Auto, height: D::Auto })
                .build_partial(&ui.layout2)?;
                
            nwg::FlexboxLayout::builder()
                .parent(&ui.window)
                .flex_direction(FlexDirection::Row)
                .child(&ui.button1)
                    .child_flex_grow(2.0)
                    .child_size(Size { width: D::Auto, height: D::Auto })
                .child_layout(&ui.layout2)
                    .child_size(Size { width: D::Points(300.0), height: D::Auto })
                .build(&ui.layout);

            
            return Ok(ui);
        }
```

--------------------------------

### Build System Tray Notification

Source: https://docs.rs/native-windows-gui/latest/native_windows_gui/struct.TrayNotificationBuilder.html

This example demonstrates how to build a system tray notification with an icon and a tooltip. It is part of a larger system tray UI setup.

```rust
            nwg::TrayNotification::builder()
                .parent(&data.window)
                .icon(Some(&data.icon))
                .tip(Some("Hello"))
                .build(&mut data.tray)?;
```

--------------------------------

### Example Usage: Building a ComboBox

Source: https://docs.rs/native-windows-gui/latest/src/native_windows_gui/controls/combo_box.rs.html

A practical example demonstrating how to create and populate a ComboBox control.

```APIDOC
```rust
use native_windows_gui as nwg;

fn build_combobox(combo: &mut nwg::ComboBox<&'static str>, window: &nwg::Window) {
    let data = vec!["one", "two"];
    
    nwg::ComboBox::builder()
        .size((200, 300))
        .collection(data)
        .selected_index(Some(0))
        .parent(window)
        .build(combo);
}
```
```

--------------------------------

### Build RichLabel Example

Source: https://docs.rs/native-windows-gui/latest/native_windows_gui/struct.RichLabel.html

Demonstrates how to build and configure a RichLabel instance using its builder pattern. This example sets the text, font, and parent for the label.

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

--------------------------------

### Locale Initialization and Usage Example

Source: https://docs.rs/native-windows-gui/latest/native_windows_gui/struct.Locale.html

Demonstrates how to create Locale instances from string names, retrieve the user's locale, get a list of all supported locales, and access display names.

```rust
use native_windows_gui as nwg;

let fr_locale = nwg::Locale::from_str("fr");
let en_us_locale = nwg::Locale::from_str("en-US");
let user_locale = nwg::Locale::user();
let locales: Vec<String> = nwg::Locale::all();

user_locale.display_name();
```

--------------------------------

### Build a Label

Source: https://docs.rs/native-windows-gui/latest/native_windows_gui/struct.Label.html

Example of how to build and configure a Label with text, font, and parent.

```rust
use native_windows_gui 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);
}
```

--------------------------------

### Build CheckBox Example

Source: https://docs.rs/native-windows-gui/latest/native_windows_gui/struct.CheckBox.html

Example of how to build and configure a CheckBox control using its builder.

```rust
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);
}
```

--------------------------------

### Menu Builder Example

Source: https://docs.rs/native-windows-gui/latest/native_windows_gui/struct.Menu.html

Demonstrates how to build and configure a Menu using the Menu::builder().

```APIDOC
## Menu::builder()

### Description
Builds a new Menu with specified properties.

### Method
`Menu::builder()`

### Parameters
#### Builder Parameters:
- **text** (string) - The text of the menu item.
- **disabled** (boolean) - If the menu item can be selected by the user.
- **popup** (boolean) - If the menu is a context menu.
- **parent** (ControlHandle or None) - The parent of the menu. Can be a top-level window, another menu, or None.

### Request Example
```rust
use native_windows_gui as nwg;

fn menu(menu: &mut nwg::Menu, window: &nwg::Window) -> Result<(), nwg::NwgError> {
    nwg::Menu::builder()
        .text("&Hello")
        .disabled(false)
        .parent(window)
        .build(menu)
}
```

### Control Events:
- **OnMenuOpen**: Sent when a drop-down menu or submenu is about to become active.
- **OnMenuHover**: When the user hovers over the menu item.
- **OnMenuEnter**: When the user enters the menu's modal loop.
- **OnMenuExit**: When the menu is closed (exits the modal loop).
```

--------------------------------

### Dispatch Thread Events in System Tray Example

Source: https://docs.rs/native-windows-gui/latest/native_windows_gui/fn.dispatch_thread_events.html

This example shows how to dispatch thread events after initializing the GUI and building a system tray UI. It's a common pattern for applications with a system tray icon.

```rust
fn main() {
    nwg::init().expect("Failed to init Native Windows GUI");
    let _ui = SystemTray::build_ui(Default::default()).expect("Failed to build UI");
    nwg::dispatch_thread_events();
}
```

--------------------------------

### Building a ScrollBar

Source: https://docs.rs/native-windows-gui/latest/native_windows_gui/struct.ScrollBar.html

Example of how to build and configure a ScrollBar control.

```APIDOC
```rust
use native_windows_gui as nwg;

fn build_scrollbar(button: &mut nwg::ScrollBar, window: &nwg::Window) {
    nwg::ScrollBar::builder()
        .range(Some(0..100))
        .pos(Some(10))
        .parent(window)
        .build(button);
}
```
```

--------------------------------

### Get Pixel Format GUID

Source: https://docs.rs/native-windows-gui/latest/src/native_windows_gui/resources/image_decoder.rs.html

Retrieves the pixel format of the bitmap source as a GUID. This can be matched against known GUIDs to determine the exact pixel format.

```Rust
pub fn pixel_format(&self) -> WICPixelFormatGUID {
        let mut fmt = unsafe { mem::zeroed() };
        unsafe { (&*self.frame).GetPixelFormat(&mut fmt) };
        fmt
    }
```

--------------------------------

### Building a System Tray with Menu Items

Source: https://docs.rs/native-windows-gui/latest/native_windows_gui/struct.MenuItem.html

This example demonstrates how to build a system tray application with various menu items. It shows the creation of icons, message windows, tray notifications, menus, and individual menu items.

```rust
60        fn build_ui(mut data: SystemTray) -> Result<SystemTrayUi, nwg::NwgError> {
61            use nwg::Event as E;
62
63            // Resources
64            nwg::Icon::builder()
65                .source_file(Some("./test_rc/cog.ico"))
66                .build(&mut data.icon)?;
67            
68            // Controls
69            nwg::MessageWindow::builder()
70                .build(&mut data.window)?;
71
72            nwg::TrayNotification::builder()
73                .parent(&data.window)
74                .icon(Some(&data.icon))
75                .tip(Some("Hello"))
76                .build(&mut data.tray)?;
77
78            nwg::Menu::builder()
79                .popup(true)
80                .parent(&data.window)
81                .build(&mut data.tray_menu)?;
82
83            nwg::MenuItem::builder()
84                .text("Hello")
85                .parent(&data.tray_menu)
86                .build(&mut data.tray_item1)?;
87
88            nwg::MenuItem::builder()
89                .text("Popup")
90                .parent(&data.tray_menu)
91                .build(&mut data.tray_item2)?;
92
93            nwg::MenuItem::builder()
94                .text("Exit")
95                .parent(&data.tray_menu)
96                .build(&mut data.tray_item3)?;
97
98            // Wrap-up
99            let ui = SystemTrayUi {
100                 inner: Rc::new(data),
101                 default_handler: Default::default(),
102             };
103
104             // Events
105             let evt_ui = Rc::downgrade(&ui.inner);
106             let handle_events = move |evt, _evt_data, handle| {
107                 if let Some(evt_ui) = evt_ui.upgrade() {
108                     match evt {
109                         E::OnContextMenu => 
110                             if &handle == &evt_ui.tray {
111                                 SystemTray::show_menu(&evt_ui);
112                             }
113                         E::OnMenuItemSelected => 
114                             if &handle == &evt_ui.tray_item1 {
115                                 SystemTray::hello1(&evt_ui);
116                             } else if &handle == &evt_ui.tray_item2 {
117                                 SystemTray::hello2(&evt_ui);
118                             } else if &handle == &evt_ui.tray_item3 {
119                                 SystemTray::exit(&evt_ui);
120                             },
121                         _ => {}
122                     }
123                 }
124             };
125
126             ui.default_handler.borrow_mut().push(
127                 nwg::full_bind_event_handler(&ui.window.handle, handle_events)
128             );
129
130             return Ok(ui);
131         }

```

--------------------------------

### Get Currency Name

Source: https://docs.rs/native-windows-gui/latest/src/native_windows_gui/winnls/locale.rs.html

Retrieves the English name of the currency associated with the current locale, for example, 'Euro'.

```rust
pub fn currency_name(&self) -> String {
        self.get_locale_info_string(0x00001007)
    }
```

--------------------------------

### Window Creation with Layout Management

Source: https://docs.rs/native-windows-gui/latest/native_windows_gui/struct.WindowBuilder.html

Shows how to create a window and then apply a GridLayout for arranging child controls. This example sets up the window's properties and then defines the layout structure.

```rust
nwg::Window::builder()
    .flags(nwg::WindowFlags::WINDOW | nwg::WindowFlags::VISIBLE)
    .size((300, 115))
    .position((300, 300))
    .title("Basic example")
    .build(&mut data.window)?
```

--------------------------------

### Get Native Currency Name

Source: https://docs.rs/native-windows-gui/latest/src/native_windows_gui/winnls/locale.rs.html

Retrieves the native name of the currency associated with the current locale, for example, 'euro'.

```rust
pub fn native_currency_name(&self) -> String {
        self.get_locale_info_string(0x00001008)
    }
```

--------------------------------

### Get RichTextBox Selection Range

Source: https://docs.rs/native-windows-gui/latest/src/native_windows_gui/controls/rich_text_box.rs.html

Retrieves the start and end positions of the currently selected text range in the rich edit control.

```rust
pub fn selection(&self) -> Range<u32> {
        use winapi::um::winuser::EM_GETSEL;

        let handle = check_hwnd(&self.handle, NOT_BOUND, BAD_HANDLE);

        let (mut out1, mut out2) = (0u32, 0u32);
        let (ptr1, ptr2) = (&mut out1 as *mut u32, &mut out2 as *mut u32);
        wh::send_message(handle, EM_GETSEL as u32, ptr1 as WPARAM, ptr2 as LPARAM);

        Range { start: out1 as u32, end: out2 as u32 }
    }
```

--------------------------------

### Building a System Tray Menu

Source: https://docs.rs/native-windows-gui/latest/native_windows_gui/struct.MenuBuilder.html

This example demonstrates how to build a system tray menu with various items, including a popup menu and exit option. It shows the usage of MenuBuilder and MenuItem builders.

```rust
60        fn build_ui(mut data: SystemTray) -> Result<SystemTrayUi, nwg::NwgError> {
61            use nwg::Event as E;
62
63            // Resources
64            nwg::Icon::builder()
65                .source_file(Some("./test_rc/cog.ico"))
66                .build(&mut data.icon)?;
67            
68            // Controls
69            nwg::MessageWindow::builder()
70                .build(&mut data.window)?;
71
72            nwg::TrayNotification::builder()
73                .parent(&data.window)
74                .icon(Some(&data.icon))
75                .tip(Some("Hello"))
76                .build(&mut data.tray)?;
77
78            nwg::Menu::builder()
79                .popup(true)
80                .parent(&data.window)
81                .build(&mut data.tray_menu)?;
82
83            nwg::MenuItem::builder()
84                .text("Hello")
85                .parent(&data.tray_menu)
86                .build(&mut data.tray_item1)?;
87
88            nwg::MenuItem::builder()
89                .text("Popup")
90                .parent(&data.tray_menu)
91                .build(&mut data.tray_item2)?;
92
93            nwg::MenuItem::builder()
94                .text("Exit")
95                .parent(&data.tray_menu)
96                .build(&mut data.tray_item3)?;
97
98            // Wrap-up
99            let ui = SystemTrayUi {
100                inner: Rc::new(data),
101                default_handler: Default::default(),
102            };
103
104            // Events
105            let evt_ui = Rc::downgrade(&ui.inner);
106            let handle_events = move |evt, _evt_data, handle| {
107                if let Some(evt_ui) = evt_ui.upgrade() {
108                    match evt {
109                        E::OnContextMenu => 
110                            if &handle == &evt_ui.tray {
111                                SystemTray::show_menu(&evt_ui);
112                            }
113                        E::OnMenuItemSelected => 
114                            if &handle == &evt_ui.tray_item1 {
115                                SystemTray::hello1(&evt_ui);
116                            } else if &handle == &evt_ui.tray_item2 {
117                                SystemTray::hello2(&evt_ui);
118                            } else if &handle == &evt_ui.tray_item3 {
119                                SystemTray::exit(&evt_ui);
120                            },
121                        _ => {}
122                    }
123                }
124            };
125
126            ui.default_handler.borrow_mut().push(
127                nwg::full_bind_event_handler(&ui.window.handle, handle_events)
128            );
129
130            return Ok(ui);
131        }
```

--------------------------------

### Get Selection Range

Source: https://docs.rs/native-windows-gui/latest/src/native_windows_gui/controls/text_input.rs.html

Retrieves the start and end indices of the currently selected range of characters in the text input. This method avoids allocating a string.

```Rust
pub fn selection(&self) -> Range<u32> {
        use winapi::um::winuser::EM_GETSEL;

        let handle = check_hwnd(&self.handle, NOT_BOUND, BAD_HANDLE);

        let mut start = 0u32;
        let mut end = 0u32;
        let ptr1 = &mut start as *mut u32;
        let ptr2 = &mut end as *mut u32;
        wh::send_message(handle, EM_GETSEL as UINT, ptr1 as WPARAM, ptr2 as LPARAM);

        start..end
    }
```

--------------------------------

### Basic Window Creation and Event Handling

Source: https://docs.rs/native-windows-gui/latest/native_windows_gui/struct.Window.html

Demonstrates the creation of a basic window with a text input and a button, including setting up event handlers for button clicks and window close events. Requires importing nwg::Event.

```rust
fn build_ui(mut data: BasicApp) -> Result<BasicAppUi, nwg::NwgError> {
            use nwg::Event as E;
            
            // Controls
            nwg::Window::builder()
                .flags(nwg::WindowFlags::WINDOW | nwg::WindowFlags::VISIBLE)
                .size((300, 135))
                .position((300, 300))
                .title("Basic example")
                .build(&mut data.window)?;

            nwg::TextInput::builder()
                .size((280, 35))
                .position((10, 10))
                .text("Heisenberg")
                .parent(&data.window)
                .focus(true)
                .build(&mut data.name_edit)?;

            nwg::Button::builder()
                .size((280, 70))
                .position((10, 50))
                .text("Say my name")
                .parent(&data.window)
                .build(&mut data.hello_button)?;

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

            // Events
            let evt_ui = Rc::downgrade(&ui.inner);
            let handle_events = move |evt, _evt_data, handle| {
                if let Some(ui) = evt_ui.upgrade() {
                    match evt {
                        E::OnButtonClick => 
                            if &handle == &ui.hello_button {
                                BasicApp::say_hello(&ui);
                            },
                        E::OnWindowClose => 
                            if &handle == &ui.window {
                                BasicApp::say_goodbye(&ui);
                            },
                        _ => {}
                    }
                }
            };

           *ui.default_handler.borrow_mut() = Some(nwg::full_bind_event_handler(&ui.window.handle, handle_events));

            return Ok(ui);
        }
```

--------------------------------

### Basic Window Creation and Event Handling

Source: https://docs.rs/native-windows-gui/latest/native_windows_gui/struct.Window.html

Illustrates the fundamental steps to create a basic window, set its properties, and attach event handlers for closing and button clicks. This example shows the core structure for a simple GUI application.

```rust
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(&events_window.handle, "Goodbye", &format!("Goodbye {}", name_edit.text()));
59                    nwg::stop_thread_dispatch();
60                },
61            E::OnButtonClick => 
62                if &handle == &hello_button {
63                    nwg::modal_info_message(&events_window.handle, "Hello", &format!("Hello {}", name_edit.text()));
64                },
65            _ => {}
66        }
67    });
68
69    nwg::dispatch_thread_events();
70    nwg::unbind_event_handler(&handler);
71}

```

--------------------------------

### Get Selected Character Range

Source: https://docs.rs/native-windows-gui/latest/src/native_windows_gui/controls/rich_label.rs.html

Retrieves the start and end indices of the currently selected text range within the control. This is useful for operations that depend on user selection.

```rust
/// Return the selected range of characters by the user in the text input
pub fn selection(&self) -> Range<usize> {
    use winapi::um::winuser::EM_GETSEL;

    let handle = check_hwnd(&self.handle, NOT_BOUND, BAD_HANDLE);

    let (mut out1, mut out2) = (0u32, 0u32);
    let (ptr1, ptr2) = (&mut out1 as *mut u32, &mut out2 as *mut u32);
    wh::send_message(handle, EM_GETSEL as u32, ptr1 as _, ptr2 as _);

    Range { start: out1 as usize, end: out2 as usize }
}
```

--------------------------------

### Building a System Tray Menu

Source: https://docs.rs/native-windows-gui/latest/native_windows_gui/struct.MenuBuilder.html

Demonstrates how to build a system tray menu with multiple items. This includes creating the menu itself, adding individual menu items with text, and associating them with a parent window.

```rust
            nwg::Menu::builder() 
                .popup(true) 
                .parent(&data.window) 
                .build(&mut data.tray_menu)?; 
 
            nwg::MenuItem::builder() 
                .text("Hello") 
                .parent(&data.tray_menu) 
                .build(&mut data.tray_item1)?; 
 
            nwg::MenuItem::builder() 
                .text("Popup") 
                .parent(&data.tray_menu) 
                .build(&mut data.tray_item2)?; 
 
            nwg::MenuItem::builder() 
                .text("Exit") 
                .parent(&data.tray_menu) 
                .build(&mut data.tray_item3)?;
```

--------------------------------

### Build and Bind Events for UI with Partials

Source: https://docs.rs/native-windows-gui/latest/native_windows_gui/trait.PartialUi.html

This example demonstrates how to build a main window, set up a partial UI component, and then bind event handlers for both the main window and the partial. It shows how to dispatch events to the partial's `process_event` method and handle specific window and button events.

```rust
fn build_ui(mut data: MainUi) -> Result<MainUiWrapper, nwg::NwgError> {
        nwg::Window::builder()
            .size((500, 200))
            .position((500, 300))
            .title("My Form")
            .build(&mut data.window)?;

        // !!! Partials controls setup !!!
        SubmitForm::build_partial(&mut data.form, Some(&data.window))?;

        let ui = MainUiWrapper {
            inner: Rc::new(data),
            default_handler: Default::default(),
        };

        // !!! Partials Event Binding !!!
        let mut window_handles = vec![&ui.window.handle];
        window_handles.append(&mut ui.form.handles());

        for handle in window_handles.iter() {
            let evt_ui = Rc::downgrade(&ui.inner);
            let handle_events = move |evt, evt_data, handle| {
                use nwg::Event as E;

                if let Some(ui) = evt_ui.upgrade() {

                    // !!! Partials Event Dispatch !!!
                    ui.form.process_event(evt, &evt_data, handle);

                    match evt {
                        E::OnButtonClick => 
                            if &handle == &ui.form.sumbit_button {
                                println!("SAVING!");
                            },
                        E::OnWindowClose => 
                            if &handle == &ui.window {
                                nwg::stop_thread_dispatch();
                            },
                        _ => {} 
                    }
                }
            };

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

        return Ok(ui);
    }
```

--------------------------------

### Build UI with Buttons and Event Handlers

Source: https://docs.rs/native-windows-gui/latest/native_windows_gui/struct.Button.html

This example demonstrates building a user interface, including windows, text inputs, and buttons. It also shows how to bind event handlers for button clicks and window close events using `nwg::full_bind_event_handler`.

```rust
nwg::Window::builder()
            .flags(nwg::WindowFlags::MAIN_WINDOW | nwg::WindowFlags::VISIBLE)
            .size((400, 300))
            .position((800, 300))
            .title("My message bank")
            .build(&mut data.window)?;

            nwg::TextInput::builder()
                .text("Hello World!")
                .focus(true)
                .parent(&data.window)
                .build(&mut data.message_content)?;

            nwg::Button::builder()
                .text("Save")
                .parent(&data.window)
                .build(&mut data.add_message_btn)?;

            nwg::TextInput::builder()
                .text("Title")
                .parent(&data.window)
                .build(&mut data.message_title)?;

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

            // Events
            let window_handles = [&ui.window.handle];

            for handle in window_handles.iter() {
                let evt_ui = Rc::downgrade(&ui.inner);
                let handle_events = move |evt, _evt_data, handle| {
                    if let Some(evt_ui) = evt_ui.upgrade() {
                        match evt {
                            E::OnButtonClick => {
                                if &handle == &evt_ui.add_message_btn { MessageBank::add_message(&evt_ui); }
                            },
                            E::OnWindowClose => {
                                if &handle == &evt_ui.window { MessageBank::exit(&evt_ui); }
                            },
                            _ => {}
                        }
                    }
                };

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

            // Layout
            nwg::GridLayout::builder()
              .parent(&ui.window)
              .max_row(Some(6))
              .child(0, 0, &ui.add_message_btn)
              .child_item(nwg::GridLayoutItem::new(&ui.message_title, 1, 0, 2, 1))
              .child_item(nwg::GridLayoutItem::new(&ui.message_content, 3, 0, 3, 1))
              .build(&ui.layout)?;
            
            return Ok(ui);
```

--------------------------------

### Get Trackbar Selection Range

Source: https://docs.rs/native-windows-gui/latest/src/native_windows_gui/controls/track_bar.rs.html

Retrieves the current selection range (start and end positions) of a trackbar. This is useful for understanding the currently selected portion of the trackbar's track.

```rust
    /// Retrieves the current selection range of the trackbar
    pub fn selection_range(&self) -> Range<usize> {
        use winapi::um::commctrl::{TBM_GETSELEND, TBM_GETSELSTART};

        let handle = check_hwnd(&self.handle, NOT_BOUND, BAD_HANDLE);
        let end = wh::send_message(handle, TBM_GETSELEND, 0, 0) as usize;
        let start = wh::send_message(handle, TBM_GETSELSTART, 0, 0) as usize;

        start..end
    }
```

--------------------------------

### Creating and centering a window in the main monitor

Source: https://docs.rs/native-windows-gui/latest/native_windows_gui/struct.Monitor.html

Demonstrates how to create a window and center it on the primary monitor using Monitor dimensions. Ensure the 'native_windows_gui' crate is imported.

```rust
use native_windows_gui as nwg;

fn create_window(width: i32, height: i32) -> nwg::Window {
    let [total_width, total_height] = [nwg::Monitor::width(), nwg::Monitor::height()];
    let mut window = nwg::Window::default();

    let x = (total_width-width)/2;
    let y = (total_height-height)/2;

    nwg::Window::builder()
        .size((width, height))
        .position((x, y))
        .build(&mut window)
        .unwrap();

    window
}
```

--------------------------------

### Get ImageData Pixel Format

Source: https://docs.rs/native-windows-gui/latest/native_windows_gui/struct.ImageData.html

Retrieves the pixel format GUID of the image data. This is useful for understanding how pixel data is structured and for determining the correct `pixel_size` when reading pixels.

```rust
pub fn pixel_format(&self) -> WICPixelFormatGUID
```

--------------------------------

### Dispatch Thread Events in Message Bank Example

Source: https://docs.rs/native-windows-gui/latest/native_windows_gui/fn.dispatch_thread_events.html

This snippet shows the use of `dispatch_thread_events` in a message bank application. It ensures that the application's event loop is started after the UI is constructed.

```rust
fn main() {
    nwg::init().expect("Failed to init Native Windows GUI");
    nwg::Font::set_global_family("Segoe UI").expect("Failed to set default font");

    let _ui = MessageBank::build_ui(Default::default()).expect("Failed to build UI");
    nwg::dispatch_thread_events();
}
```

--------------------------------

### Initialize GUI and Set Global Font

Source: https://docs.rs/native-windows-gui/latest/native_windows_gui/fn.init.html

This example demonstrates initializing the Native Windows GUI and then setting a global font family. This is useful for consistent styling across all application controls. It expects both initialization and font setting to succeed.

```rust
nwg::init().expect("Failed to init Native Windows GUI");
nwg::Font::set_global_family("Segoe UI").expect("Failed to set default font");
```

--------------------------------

### Basic Barebone Window with GridLayout

Source: https://docs.rs/native-windows-gui/latest/native_windows_gui/struct.GridLayout.html

Illustrates setting up a basic window with a text input and a button, arranged using GridLayout with custom spacing and child item positioning.

```rust
nwg::GridLayout::builder()
            .parent(&window)
            .spacing(1)
            .child(0, 0, &name_edit)
            .child_item(nwg::GridLayoutItem::new(&hello_button, 0, 1, 1, 2))
            .build(&layout)
            .unwrap();
```

--------------------------------

### Dispatch Thread Events in Basic App Example

Source: https://docs.rs/native-windows-gui/latest/native_windows_gui/fn.dispatch_thread_events.html

This snippet demonstrates dispatching thread events in a basic application setup. It includes initializing the GUI and setting a global font family before dispatching events.

```rust
fn main() {
    nwg::init().expect("Failed to init Native Windows GUI");
    nwg::Font::set_global_family("Segoe UI").expect("Failed to set default font");
    let _ui = BasicApp::build_ui(Default::default()).expect("Failed to build UI");
    nwg::dispatch_thread_events();
}
```

--------------------------------

### UI Building with native-windows-gui

Source: https://docs.rs/native-windows-gui/latest/src/calculator/calculator.rs.html

Demonstrates how to build the calculator's user interface using the `native-windows-gui` crate. It includes creating the main window, text input, and buttons, and setting their properties and parent-child relationships.

```rust
mod calculator_ui {
    use native_windows_gui as nwg;
    use super::*;
    use std::rc::Rc;
    use std::cell::RefCell;
    use std::ops::Deref;

    pub struct CalculatorUi {
        inner: Rc<Calculator>,
        default_handler: RefCell<Vec<nwg::EventHandler>>
    }

    impl nwg::NativeUi<CalculatorUi> for Calculator {
        fn build_ui(mut data: Calculator) -> Result<CalculatorUi, nwg::NwgError> {
            use nwg::Event as E;
            
            // Controls
            nwg::Window::builder()
                .size((300, 150))
                .position((300, 300))
                .title("Calculator")
                .build(&mut data.window)?;

            nwg::TextInput::builder()
                .text("")
                .align(nwg::HTextAlign::Right)
                .readonly(true)
                .parent(&data.window)
                .build(&mut data.input)?;

            nwg::Button::builder()
                .text("1")
                .parent(&data.window)
                .focus(true)
                .build(&mut data.btn1)?;
           
            nwg::Button::builder().text("2").parent(&data.window).build(&mut data.btn2)?;
            nwg::Button::builder().text("3").parent(&data.window).build(&mut data.btn3)?;
            nwg::Button::builder().text("4").parent(&data.window).build(&mut data.btn4)?;
            // ... other buttons would follow ...

            let ui = CalculatorUi {
                inner: Rc::new(data),
                default_handler: RefCell::new(Vec::new()),
            };

            // Event wiring would go here

            Ok(ui)
        }
    }
}
```

--------------------------------

### Start Timer

Source: https://docs.rs/native-windows-gui/latest/native_windows_gui/struct.Timer.html

Starts the timer. If the timer is already running, this restarts it.

```APIDOC
## pub fn start(&self)

Starts the timer. If the timer is already running, this restarts it.
```

--------------------------------

### Building a Window with nwg

Source: https://docs.rs/native-windows-gui/latest/native_windows_gui/struct.GridLayoutBuilder.html

Demonstrates how to build a basic window using nwg::Window::builder. This includes setting size, position, and title.

```rust
nwg::Window::builder()
    .size((300, 150))
    .position((300, 300))
    .title("Calculator")
    .build(&mut data.window)?;
```

--------------------------------

### Building a UI with GridLayout

Source: https://docs.rs/native-windows-gui/latest/native_windows_gui/struct.GridLayoutItem.html

Demonstrates building a basic UI with windows, text input, buttons, and arranging them using a GridLayout. It also includes event handling for button clicks and window closing.

```rust
fn build_ui(mut data: BasicApp) -> Result<BasicAppUi, nwg::NwgError> {
            use nwg::Event as E;
            
            // Controls
            nwg::Window::builder()
                .flags(nwg::WindowFlags::WINDOW | nwg::WindowFlags::VISIBLE)
                .size((300, 115))
                .position((300, 300))
                .title("Basic example")
                .build(&mut data.window)?;

            nwg::TextInput::builder()
                .text("Heisenberg")
                .parent(&data.window)
                .focus(true)
                .build(&mut data.name_edit)?;

            nwg::Button::builder()
                .text("Say my name")
                .parent(&data.window)
                .build(&mut data.hello_button)?;

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

            // Events
            let evt_ui = Rc::downgrade(&ui.inner);
            let handle_events = move |evt, _evt_data, handle| {
                if let Some(evt_ui) = evt_ui.upgrade() {
                    match evt {
                        E::OnButtonClick => 
                            if &handle == &evt_ui.hello_button {
                                BasicApp::say_hello(&evt_ui);
                            },
                        E::OnWindowClose => 
                            if &handle == &evt_ui.window {
                                BasicApp::say_goodbye(&evt_ui);
                            },
                        _ => {}
                    }
                }
            };

           *ui.default_handler.borrow_mut() = Some(nwg::full_bind_event_handler(&ui.window.handle, handle_events));

           // Layouts
           nwg::GridLayout::builder()
            .parent(&ui.window)
            .spacing(1)
            .child(0, 0, &ui.name_edit)
            .child_item(nwg::GridLayoutItem::new(&ui.hello_button, 0, 1, 1, 2))
            .build(&ui.layout)?;

            return Ok(ui);
        }
```

--------------------------------

### MenuSeparator Usage Example

Source: https://docs.rs/native-windows-gui/latest/native_windows_gui/struct.MenuSeparator.html

This example demonstrates how to create and build a MenuSeparator, attaching it to a menu.

```APIDOC
## MenuSeparator

A menu separator. Can be added between two menu item to separte them. Cannot be added to a menubar.
Requires the `menu` feature.

**Builder parameters:**
  * parent: A top level window or a menu. With a top level window, the menu item is added to the menu bar.

**Control events:**
  * OnMenuHover: When the user hovers the menu

```rust
use native_windows_gui as nwg;

fn separator(sep: &mut nwg::MenuSeparator, menu: &nwg::Menu) -> Result<(), nwg::NwgError> {
    nwg::MenuSeparator::builder()
        .parent(menu)
        .build(sep)
}
```
```

--------------------------------

### Building a Basic Window

Source: https://docs.rs/native-windows-gui/latest/native_windows_gui/struct.WindowBuilder.html

Demonstrates how to create a basic window with specified flags, size, position, and title. This is a fundamental step for any GUI application.

```rust
nwg::Window::builder()
    .flags(nwg::WindowFlags::WINDOW | nwg::WindowFlags::VISIBLE)
    .size((300, 115))
    .position((300, 300))
    .title("Basic example")
    .build(&mut data.window)?;
```

--------------------------------

### Get Progress Bar Range

Source: https://docs.rs/native-windows-gui/latest/src/native_windows_gui/controls/progress_bar.rs.html

Retrieves the minimum and maximum values (range) of the progress bar. The first call with `1` as the second argument gets the minimum, and the second call with `0` gets the maximum.

```Rust
use winapi::um::commctrl::PBM_GETRANGE;

let handle = check_hwnd(&self.handle, NOT_BOUND, BAD_HANDLE);

let low = wh::send_message(handle, PBM_GETRANGE, 1, 0) as u32;
let high = wh::send_message(handle, PBM_GETRANGE, 0, 0) as u32;

low..high
```

--------------------------------

### Build UI with Partial Controls and Event Binding

Source: https://docs.rs/native-windows-gui/latest/native_windows_gui/struct.WindowBuilder.html

This example demonstrates building a UI with partial controls and setting up event bindings. It shows how to build a main window, then build partial controls (like a form) and attach them to the window. Event handlers are bound to various control handles, including custom logic for button clicks and window close events.

```rust
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
52                    // !!! Partials Event Dispatch !!!
53                    ui.form.process_event(evt, &evt_data, handle);
54
55                    match evt {
56                        E::OnButtonClick => 
57                            if &handle == &ui.form.sumbit_button {
58                                println!("SAVING!");
59                            },
60                        E::OnWindowClose => 
61                            if &handle == &ui.window {
62                                nwg::stop_thread_dispatch();
63                            },
64                        _ => {}
65                    }
66                }
67            };
68
69            ui.default_handler.borrow_mut().push(
70                nwg::full_bind_event_handler(handle, handle_events)
71            );
72        }
73
74        return Ok(ui);
75    }
```

--------------------------------

### Example Calling a Documented Function

Source: https://docs.rs/native-windows-gui/latest/scrape-examples-help.html

This example demonstrates how to call a documented function from another crate. Rustdoc will include this snippet in the documentation of `a_func`.

```rust
// examples/ex.rs
fn main() {
  a_crate::a_func();
}
```

--------------------------------

### Building a ComboBox

Source: https://docs.rs/native-windows-gui/latest/native_windows_gui/struct.ComboBox.html

Example of how to build and configure a ComboBox with a parent window, size, collection of items, and a default selected index.

```APIDOC
```rust
use native_windows_gui as nwg;
fn build_combobox(combo: &mut nwg::ComboBox<&'static str>, window: &nwg::Window) {
    let data = vec!["one", "two"];
    
    nwg::ComboBox::builder()
        .size((200, 300))
        .collection(data)
        .selected_index(Some(0))
        .parent(window)
        .build(combo);
}
```
```

--------------------------------

### Get Window Long (32-bit)

Source: https://docs.rs/native-windows-gui/latest/src/native_windows_gui/win32/window_helper.rs.html

A platform-specific helper function to get a window's long-GDI parameter on 32-bit systems. It uses `GetWindowLongW`.

```Rust
#[inline(always)]
#[cfg(target_pointer_width = "32")]
pub fn get_window_long(handle: HWND, index: c_int) -> LONG {
    unsafe { ::winapi::um::winuser::GetWindowLongW(handle, index) }
}
```

--------------------------------

### Building a Basic Window

Source: https://docs.rs/native-windows-gui/latest/native_windows_gui/struct.WindowBuilder.html

Demonstrates the creation of a simple window with specified size, position, and title. This is a fundamental step for any GUI application.

```rust
nwg::Window::builder()
    .size((300, 115))
    .position((300, 300))
    .title("Basic example")
    .build(&mut window)
    .unwrap();
```

--------------------------------

### Get Window Long Pointer (64-bit)

Source: https://docs.rs/native-windows-gui/latest/src/native_windows_gui/win32/window_helper.rs.html

A platform-specific helper function to get a window's long-GDI parameter on 64-bit systems. It uses `GetWindowLongPtrW`.

```Rust
#[inline(always)]
#[cfg(target_pointer_width = "64")]
pub fn get_window_long(handle: HWND, index: c_int) -> LONG_PTR {
    unsafe{ ::winapi::um::winuser::GetWindowLongPtrW(handle, index) }
}
```

--------------------------------

### init

Source: https://docs.rs/native-windows-gui/latest/native_windows_gui/fn.init.html

Initializes some application wide GUI settings. This includes default styling and common controls resources.

```APIDOC
## init

### Description
Initializes some application wide GUI settings. This includes default styling and common controls resources.

### Signature
```rust
pub fn init() -> Result<(), NwgError>
```

### Returns
Returns `Ok(())` on success, or an `NwgError` if initialization fails.

### Examples
```rust
nwg::init().expect("Failed to init Native Windows GUI");
```
```

--------------------------------

### Start an AnimationTimer

Source: https://docs.rs/native-windows-gui/latest/src/native_windows_gui/controls/animation_timer.rs.html

Starts the specified timer. If the timer is already running, this action resets it, including its lifetime and tick count if applicable. Panics if the timer is not bound.

```rust
if self.handle.blank() { panic!("{}", NOT_BOUND); }
let (_, id) = self.handle.timer().expect(BAD_HANDLE);
AnimationThread::reset_timer(id);
```
Tokens:
Raw