Struct WindowMain

pub struct WindowMain(/* private fields */);

Available on crate feature gui only.

An user main window, which can handle events. Usually, this is the first window of your application, launched directly from the main function. Can be programmatically created or load a dialog resource from a .res file.

Examples

Basic structure of a program with a main window, created programmatically:

use winsafe::{self as w, co, gui, prelude::*};

fn main() {
    if let Err(err) = Main::create_and_run() {
        w::HWND::NULL
            .MessageBox(&err.to_string(), "Uncaught error", co::MB::ICONERROR)
            .unwrap();
    }
}

#[derive(Clone)]
struct Main {
    wnd: gui::WindowMain,
}

impl Main {
    #[must_use]
    fn create_and_run() -> w::AnyResult<i32> {
        let wnd = gui::WindowMain::new(gui::WindowMainOpts {
            title: "Main window".to_owned(),
            ..Default::default()
        });

        let new_self = Self { wnd };
        new_self.events();

        new_self.wnd.run_main(None)
    }

    fn events(&self) {
        let self2 = self.clone();
        self.wnd.on().wm_create(move |_| {
            self2.wnd.hwnd().SetWindowText("Hello")?;
            Ok(0)
        });
    }
}

Implementations

impl WindowMain

pub fn new(opts: WindowMainOpts) -> Self

Instantiates a new WindowMain object, to be created internally with HWND::CreateWindowEx.

pub fn new_dlg( dlg_id: u16, icon_id: Option<u16>, accel_tbl_id: Option<u16>, ) -> Self

Instantiates a new WindowMain object, to be loaded from a dialog resource with HINSTANCE::CreateDialogParam.

pub fn run_main(&self, cmd_show: Option<SW>) -> AnyResult<i32>

Physically creates the window, then runs the main application loop. This method will block until the window is closed.

The cmd_show parameter defaults to co::SW::SHOW.

Panics

Panics if the window is already created.

Panics if the creation process fails.

pub fn close(&self)

Closes the window by posting a WM_CLOSE message. This is the safest way to close any popup window, because you’ll able to process the wm_close event, just like if the user clicked the window “X” button.

Trait Implementations

impl Clone for WindowMain

fn clone(&self) -> WindowMain

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl GuiParent for WindowMain

fn on(&self) -> &WindowEvents

Exposes methods to handle the basic window messages, plus timer and native control notifications.

fn spawn_thread<F>(&self, func: F)

where F: FnOnce() -> AnyResult<()> + Send + 'static,

This method calls std::thread::spawn, but it allows the returning of an error value. This error value will be forwarded to the original UI thread, allowing it to be caught at WindowMain::run_main.

fn run_ui_thread<F>(&self, func: F)

where F: FnOnce() -> AnyResult<()> + Send + 'static,

Runs a closure synchronously in the window’s original UI thread, allowing UI updates without the risk of a deadlock.

impl GuiWindow for WindowMain

fn hwnd(&self) -> &HWND

Returns the underlying handle for this window.

fn as_any(&self) -> &dyn Any

Converts a reference to the Any trait. This is useful when storing a collection of polymorphic controls, because Any allows downcasting.

impl Send for WindowMain