How do you envision WM_USER being used? about winsafe HOT 1 CLOSED

Defining new WM constant can be done just like any other constant:

pub const MAKE_TOAST: co::WM = unsafe { co::WM::from_raw(co::WM::USER.raw() + 20) };

However, this is just the tip of the iceberg.

One of the greatest challenges while writing WinSafe's GUI module was how to deal with type-safe messages, since they have to be:

• sent;
• received;
• contain data;
• extensible.

So, in order to properly declare a custom message, you must fulfill the bullets above. As an example, imagine that MAKE_TOAST message, whose data is simply how many toasts you should make. It could be implemented like this:

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

pub const MAKE_TOAST: co::WM = unsafe { co::WM::from_raw(co::WM::USER.raw() + 20) };

struct MakeToast {
	how_many: u32,
}

unsafe impl MsgSend for MakeToast {
	type RetType = ();

	fn convert_ret(&self, _: isize) -> Self::RetType {
		()
	}

	fn as_generic_wm(&mut self) -> msg::WndMsg {
		msg::WndMsg {
			msg_id: MAKE_TOAST,
			wparam: self.how_many as _,
			lparam: 0,
		}
	}
}

unsafe impl MsgSendRecv for MakeToast {
	fn from_generic_wm(p: msg::WndMsg) -> Self {
		Self {
			how_many: p.wparam as _,
		}
	}
}

First, you define the struct with the data it contains, then you implement MsgSend, so you message can be sent through SendMessage. And finally you implement MsgSendRecv, so your message can also be received in an on().wm(...) handler.

Now sending becomes trivial:

self.wnd.hwnd().SendMessage(
	MakeToast {
		how_many: 3,
	},
);

And when receiving, you must manually cast the generic parameters to the specialized struct:

self.wnd.on().wm(MAKE_TOAST, move |p| {
	let p = MakeToast::from_generic_wm(p);
	println!("Make {}", p.how_many);
	Ok(None)
});

In fact, you made me realize that there is no clear documentation like this in the docs. This example is now here.

from winsafe.