Any support is greatly appreciated.

Installation

To use NWG in your project add it to cargo.toml:

[dependencies]
native-windows-gui = "1.0.12"
native-windows-derive = "1.0.3" # Optional. Only if the derive macro is used.

And then, in main.rs or lib.rs :

extern crate nativewindowsgui as nwg;
extern crate nativewindowsderive as nwd;  // Optional. Only if the derive macro is used.

Rust 2018 aliasing

You can skip the extern crate define in your source code by adding the following code in Cargo.toml Note that procedural macros still require an extern crate definition, so this wont work with native-windows-derive

[dependencies]
nwg = {version = "^1.0.12", package = "native-windows-gui"}

Trying it out

See it for yourself. NWG has plenty of examples and a fully interactive test suite. The only thing you need to do is:

git clone git@github.com:gabdube/native-windows-gui.git
cd native-windows-gui/native-windows-gui # Running the tests from the workspace screws up the features
cargo test everything --features "all"  # For the test suite cargo run --example basic cargo run --example calculator cargo run --example message_bank cargo run --example imagedecoderd --features "extern-canvas" cargo run --example partials --features "listbox frame combobox" cargo run --example system_tray --features "tray-notification message-window menu cursor" cargo run --example dialogmultithreadingd --features "notice" cargo run --example imagedecoderd --features "image-decoder file-dialog" cargo run --example monthnamed --features "winnls textbox" cargo run --example splashscreend --features "image-decoder" cargo run --example dropfilesd --features "textbox"
cd examples/opengl_canvas cargo run
The closest thing to a real application in the examples
cd ../examples/sync-draw
cargo run
Requires the console to be run as Admin because of the embed resource
cd ../examples/embed_resources
cargo run

Cross-compiling from Ubuntu

Requirement: MinGW compiler

sudo apt install gcc-mingw-w64-x86-64

Requirement: Rust support

rustup target add x86_64-pc-windows-gnu

Compiling and running basic example:

cargo build --release --target=x86_64-pc-windows-gnu cargo build --release --target=x86_64-pc-windows-gnu --example basic wine target/x86_64-pc-windows-gnu/release/examples/basic.exe

Project structure

This is the main project git. It is separated in multiple sections

• native-windows-gui

• native-windows-derive

• docs/native-windows-docs read it online

• showcase

Supported features

• The WHOLE winapi control library (reference)

• Menus and menu bar
• Image and font resource

• Localization support

• Tooltip
• System tray notification
• Cursor handling
• A full clipboard wrapper
• Partial templates support

• Dynamic controls support

• Multithreaded application support

• Simple layout configurations

• Drag and drop

• The most common dialog boxes

• A canvas that can be used by external rendering APIs
• High-DPI aware
• Support for accessibility functions

• Support for low level system message capture (HWND, MSG, WPARAM, LPARAM)
• Cross compiling and testing from Linux to Windows with Wine and mingw.

Performance

This was measured on a Intel(R) Core(TM) i7-3770 CPU @ 3.40GHz, 3401 Mhz, 4 Core(s), 8 Logical Processor(s)

In release mode, the basic example weighs 163kb on disk and takes 900kb in memory. Launch time is instantaneous.

The interactive test suite (with every feature and 100s of tests) weighs 931 kb on disk and takes 8MB in memory. Launch time is still instantaneous.

Initial build time takes around 22 seconds for a basic application. This is mainly due to winapi-rs initial compile time. Subsequent compile time takes around 0.7 seconds.

Development

The development of this library is considered "done". By that, I mean that there won't be any change to the API. Issues can be raised if a bug is found or if some area in the documentation is unclear. If I overlooked a very important feature, it will most likely be added.

License

NWG uses the MIT license

Code example

With native windows derive

#![windows_subsystem = "windows"]
/*!
    A very simple application that shows your name in a message box.
    Unlike basic_d, this example uses layout to position the controls in the window
*/
extern crate nativewindowsgui as nwg; extern crate nativewindowsderive as nwd;
use nwd::NwgUi; use nwg::NativeUi;
#[derive(Default, NwgUi)] pub struct BasicApp {     #[nwg_control(size: (300, 115), position: (300, 300), title: "Basic example", flags: "WINDOW|VISIBLE")]     #[nwgevents( OnWindowClose: [BasicApp::saygoodbye] )]     window: nwg::Window,
#[nwg_layout(parent: window, spacing: 1)]     grid: nwg::GridLayout,
#[nwg_control(text: "Heisenberg", focus: true)]     #[nwglayoutitem(layout: grid, row: 0, col: 0)]     name_edit: nwg::TextInput,
#[nwg_control(text: "Say my name")]     #[nwglayoutitem(layout: grid, col: 0, row: 1, row_span: 2)]     #[nwgevents( OnButtonClick: [BasicApp::sayhello] )]     hello_button: nwg::Button }
impl BasicApp {
fn say_hello(&self) {         nwg::modalinfomessage(&self.window, "Hello", &format!("Hello {}", self.name_edit.text()));     }          fn say_goodbye(&self) {         nwg::modalinfomessage(&self.window, "Goodbye", &format!("Goodbye {}", self.name_edit.text()));         nwg::stopthreaddispatch();     }
}
fn main() {     nwg::init().expect("Failed to init Native Windows GUI");     nwg::Font::setglobalfamily("Segoe UI").expect("Failed to set default font");     let app = BasicApp::buildui(Default::default()).expect("Failed to build UI");     nwg::dispatchthreadevents(); }

Barebone example. Suitable if you only need a simple static UI

#![windows_subsystem = "windows"]
/**
    A very simple application that show your name in a message box.
This demo shows how to use NWG without the NativeUi trait boilerplate.     Note that this way of doing things is alot less extensible and cannot make use of native windows derive.
See basic for the NativeUi version and basic_d for the derive version */ extern crate nativewindowsgui as nwg; use std::rc::Rc;
fn main() {     nwg::init().expect("Failed to init Native Windows GUI");     nwg::Font::setglobalfamily("Segoe UI").expect("Failed to set default font");
let mut window = Default::default();     let mut name_edit = Default::default();     let mut hello_button = Default::default();     let layout = Default::default();
nwg::Window::builder()         .size((300, 115))         .position((300, 300))         .title("Basic example")         .build(&mut window)         .unwrap();
nwg::TextInput::builder()         .text("Heisenberg")         .focus(true)         .parent(&window)         .build(&mut name_edit)         .unwrap();
nwg::Button::builder()         .text("Say my name")         .parent(&window)         .build(&mut hello_button)         .unwrap();
nwg::GridLayout::builder()         .parent(&window)         .spacing(1)         .child(0, 0, &name_edit)         .childitem(nwg::GridLayoutItem::new(&hellobutton, 0, 1, 1, 2))         .build(&layout)         .unwrap();
let window = Rc::new(window);     let events_window = window.clone();
let handler = nwg::fullbindeventhandler(&window.handle, move |evt, evt_data, handle| {         use nwg::Event as E;
match evt {             E::OnWindowClose =>                  if &handle == &events_window as &nwg::Window {                     nwg::modalinfomessage(&eventswindow.handle, "Goodbye", &format!("Goodbye {}", nameedit.text()));                     nwg::stopthreaddispatch();                 },             E::OnButtonClick =>                  if &handle == &hello_button {                     nwg::modalinfomessage(&eventswindow.handle, "Hello", &format!("Hello {}", nameedit.text()));                 },             _ => {}         }     });
nwg::dispatchthreadevents();     nwg::unbindeventhandler(&handler); }

With the NativeUi boilerplate

#![windows_subsystem = "windows"]
/*!
    A very simple application that shows your name in a message box.
    Uses layouts to position the controls in the window
*/
extern crate nativewindowsgui as nwg; use nwg::NativeUi;
#[derive(Default)] pub struct BasicApp {     window: nwg::Window,     layout: nwg::GridLayout,     name_edit: nwg::TextInput,     hello_button: nwg::Button }
impl BasicApp {
fn say_hello(&self) {         nwg::modalinfomessage(&self.window, "Hello", &format!("Hello {}", self.name_edit.text()));     }          fn say_goodbye(&self) {         nwg::modalinfomessage(&self.window, "Goodbye", &format!("Goodbye {}", self.name_edit.text()));         nwg::stopthreaddispatch();     }
}
// // ALL of this stuff is handled by native-windows-derive // mod basicappui {     use nativewindowsgui as nwg;     use super::*;     use std::rc::Rc;     use std::cell::RefCell;     use std::ops::Deref;
pub struct BasicAppUi {         inner: Rc<BasicApp>,         default_handler: RefCell<Option<nwg::EventHandler>>     }
impl nwg::NativeUi<BasicAppUi> for BasicApp {         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 handleevents = 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.defaulthandler.borrowmut() = Some(nwg::fullbindeventhandler(&ui.window.handle, handleevents));
// Layouts            nwg::GridLayout::builder()             .parent(&ui.window)             .spacing(1)             .child(0, 0, &ui.name_edit)             .childitem(nwg::GridLayoutItem::new(&ui.hellobutton, 0, 1, 1, 2))             .build(&ui.layout)?;
return Ok(ui);         }     }
impl Drop for BasicAppUi {         /// To make sure that everything is freed without issues, the default handler must be unbound.         fn drop(&mut self) {             let handler = self.default_handler.borrow();             if handler.is_some() {                 nwg::unbindeventhandler(handler.as_ref().unwrap());             }         }     }
impl Deref for BasicAppUi {         type Target = BasicApp;
fn deref(&self) -> &BasicApp {             &self.inner         }     } }
fn main() {     nwg::init().expect("Failed to init Native Windows GUI");     nwg::Font::setglobalfamily("Segoe UI").expect("Failed to set default font");     let ui = BasicApp::buildui(Default::default()).expect("Failed to build UI");     nwg::dispatchthreadevents(); }

Attributions

For the icons used in the test suite (and only there):

• love.ico is made by Smashicons from www.flaticon.com
• popcorn.bmp is made by Freepik from www.flaticon.com
• ball.bmp is made by Freepik from www.flaticon.com
• cat.jpg is made by Freepik from www.flaticon.com
• weirdcat.png is made by Freepik from www.flaticon.com
• list0.png, list1.png, list2.png, list3.png are made by Smashicons from www.flaticon.com
• ice.cur is made by nrox653 from rw-designer