use std::{
collections::HashMap,
sync::{LazyLock, Mutex},
};
use windows::Win32::{
Foundation::{HWND, LPARAM, LRESULT, POINT, WPARAM},
Graphics::Gdi::ScreenToClient,
UI::{
Input::KeyboardAndMouse::{
GetKeyState, TME_LEAVE, TME_NONCLIENT, TRACKMOUSEEVENT, TRACKMOUSEEVENT_FLAGS, TrackMouseEvent, VK_CONTROL,
VK_LBUTTON, VK_MBUTTON, VK_RBUTTON, VK_SHIFT, VK_XBUTTON1, VK_XBUTTON2,
},
WindowsAndMessaging::{
CallWindowProcW, DefWindowProcW, GWLP_WNDPROC, GetCursorPos, GetWindowLongPtrW, HTCLIENT, HTCLOSE, HTMAXBUTTON,
HTMINBUTTON, SetWindowLongPtrW, WM_LBUTTONDOWN, WM_LBUTTONUP, WM_MBUTTONDOWN, WM_MBUTTONUP, WM_MOUSEMOVE,
WM_NCDESTROY, WM_NCHITTEST, WM_NCLBUTTONDBLCLK, WM_NCLBUTTONDOWN, WM_NCLBUTTONUP, WM_NCMBUTTONDBLCLK,
WM_NCMBUTTONDOWN, WM_NCMBUTTONUP, WM_NCMOUSELEAVE, WM_NCMOUSEMOVE, WM_NCRBUTTONDBLCLK, WM_NCRBUTTONDOWN,
WM_NCRBUTTONUP, WM_NCXBUTTONDBLCLK, WM_NCXBUTTONDOWN, WM_NCXBUTTONUP, WM_RBUTTONDOWN, WM_RBUTTONUP, WM_SETCURSOR,
WM_XBUTTONDOWN, WM_XBUTTONUP, WNDPROC, WindowFromPoint,
},
},
};
use super::window::Window;
use crate::node::WindowControl;
const WM_MOUSELEAVE: u32 = 0x02A3;
struct Laid {
original: isize,
window: Window,
over_control: bool,
}
static LAID: LazyLock<Mutex<HashMap<isize, Laid>>> = LazyLock::new(|| Mutex::new(HashMap::new()));
pub(crate) fn lay_over(hwnd: isize, window: Window) {
let mut laid = LAID.lock().unwrap();
if laid.contains_key(&hwnd) {
return;
}
let handle = HWND(hwnd as *mut _);
let original = unsafe {
let original = GetWindowLongPtrW(handle, GWLP_WNDPROC);
SetWindowLongPtrW(handle, GWLP_WNDPROC, procedure as usize as isize);
original
};
laid.insert(
hwnd,
Laid {
original,
window,
over_control: false,
},
);
}
fn hit_code(control: WindowControl) -> u32 {
match control {
WindowControl::Minimize => HTMINBUTTON,
WindowControl::Maximize => HTMAXBUTTON,
WindowControl::Close => HTCLOSE,
}
}
fn is_control_code(code: usize) -> bool {
[HTMINBUTTON, HTMAXBUTTON, HTCLOSE].contains(&(code as u32))
}
fn point(lparam: LPARAM) -> POINT {
POINT {
x: (lparam.0 & 0xffff) as u16 as i16 as i32,
y: ((lparam.0 >> 16) & 0xffff) as u16 as i16 as i32,
}
}
fn point_lparam(at: POINT) -> LPARAM {
let x = at.x as i16 as u16 as u32;
let y = at.y as i16 as u16 as u32;
LPARAM(((y << 16) | x) as i32 as isize)
}
fn client_button_message(message: u32) -> Option<u32> {
Some(match message {
WM_NCLBUTTONDOWN | WM_NCLBUTTONDBLCLK => WM_LBUTTONDOWN,
WM_NCLBUTTONUP => WM_LBUTTONUP,
WM_NCRBUTTONDOWN | WM_NCRBUTTONDBLCLK => WM_RBUTTONDOWN,
WM_NCRBUTTONUP => WM_RBUTTONUP,
WM_NCMBUTTONDOWN | WM_NCMBUTTONDBLCLK => WM_MBUTTONDOWN,
WM_NCMBUTTONUP => WM_MBUTTONUP,
WM_NCXBUTTONDOWN | WM_NCXBUTTONDBLCLK => WM_XBUTTONDOWN,
WM_NCXBUTTONUP => WM_XBUTTONUP,
_ => return None,
})
}
fn message_hit_code(message: u32, wparam: WPARAM) -> usize {
match message {
WM_NCXBUTTONDOWN | WM_NCXBUTTONUP | WM_NCXBUTTONDBLCLK => wparam.0 & 0xffff,
_ => wparam.0,
}
}
fn client_wparam(message: u32, wparam: WPARAM, keys: usize) -> WPARAM {
match message {
WM_NCXBUTTONDOWN | WM_NCXBUTTONUP | WM_NCXBUTTONDBLCLK => WPARAM((wparam.0 & !0xffff) | keys),
_ => WPARAM(keys),
}
}
fn held_keys() -> usize {
const MK: [(u16, usize); 7] = [
(VK_LBUTTON.0, 0x01),
(VK_RBUTTON.0, 0x02),
(VK_SHIFT.0, 0x04),
(VK_CONTROL.0, 0x08),
(VK_MBUTTON.0, 0x10),
(VK_XBUTTON1.0, 0x20),
(VK_XBUTTON2.0, 0x40),
];
MK.iter()
.filter(|(key, _)| unsafe { GetKeyState(i32::from(*key)) } < 0)
.fold(0, |keys, (_, flag)| keys | flag)
}
fn to_client(hwnd: HWND, mut at: POINT) -> Option<POINT> {
unsafe { ScreenToClient(hwnd, &mut at) }.as_bool().then_some(at)
}
fn control_at(hwnd: HWND, window: &Window, at: POINT) -> Option<WindowControl> {
let at = to_client(hwnd, at)?;
window.control_at(at.x as f32, at.y as f32)
}
fn cursor() -> Option<POINT> {
let mut at = POINT::default();
unsafe { GetCursorPos(&mut at) }.ok().map(|()| at)
}
fn cursor_on_window(hwnd: HWND) -> Option<POINT> {
let at = cursor()?;
(unsafe { WindowFromPoint(at) } == hwnd).then_some(at)
}
fn track_leave(hwnd: HWND, flags: TRACKMOUSEEVENT_FLAGS) {
let mut track = TRACKMOUSEEVENT {
cbSize: std::mem::size_of::<TRACKMOUSEEVENT>() as u32,
dwFlags: flags,
hwndTrack: hwnd,
dwHoverTime: 0,
};
let _ = unsafe { TrackMouseEvent(&mut track) };
}
fn set_over_control(hwnd: HWND, over: bool) -> bool {
LAID
.lock()
.ok()
.and_then(|mut laid| {
laid
.get_mut(&(hwnd.0 as isize))
.map(|laid| std::mem::replace(&mut laid.over_control, over))
})
.unwrap_or(false)
}
unsafe extern "system" fn procedure(hwnd: HWND, message: u32, wparam: WPARAM, lparam: LPARAM) -> LRESULT {
let Some((original, window)) = LAID.lock().ok().and_then(|laid| {
laid
.get(&(hwnd.0 as isize))
.map(|laid| (laid.original, laid.window.clone()))
}) else {
return unsafe { DefWindowProcW(hwnd, message, wparam, lparam) };
};
let original: WNDPROC = unsafe { std::mem::transmute::<isize, WNDPROC>(original) };
let call =
|message: u32, wparam: WPARAM, lparam: LPARAM| unsafe { CallWindowProcW(original, hwnd, message, wparam, lparam) };
let over_control = |message: u32| {
is_control_code(message_hit_code(message, wparam)) && control_at(hwnd, &window, point(lparam)).is_some()
};
let client_point = || to_client(hwnd, point(lparam)).map(point_lparam);
match message {
WM_NCHITTEST => {
let hit = call(message, wparam, lparam);
if hit.0 == HTCLIENT as isize
&& let Some(control) = control_at(hwnd, &window, point(lparam))
{
return LRESULT(hit_code(control) as isize);
}
hit
}
WM_NCMOUSEMOVE if over_control(message) => {
let Some(at) = client_point() else {
return call(message, wparam, lparam);
};
set_over_control(hwnd, true);
call(WM_MOUSEMOVE, WPARAM(held_keys()), at);
track_leave(hwnd, TME_LEAVE | TME_NONCLIENT);
LRESULT(0)
}
WM_NCLBUTTONDOWN | WM_NCLBUTTONUP | WM_NCLBUTTONDBLCLK | WM_NCRBUTTONDOWN | WM_NCRBUTTONUP | WM_NCRBUTTONDBLCLK
| WM_NCMBUTTONDOWN | WM_NCMBUTTONUP | WM_NCMBUTTONDBLCLK | WM_NCXBUTTONDOWN | WM_NCXBUTTONUP
| WM_NCXBUTTONDBLCLK
if over_control(message) =>
{
let (Some(at), Some(client)) = (client_point(), client_button_message(message)) else {
return call(message, wparam, lparam);
};
let keys = held_keys();
set_over_control(hwnd, true);
call(WM_MOUSEMOVE, WPARAM(keys), at);
track_leave(hwnd, TME_LEAVE | TME_NONCLIENT);
call(client, client_wparam(message, wparam, keys), at);
LRESULT(isize::from(matches!(client, WM_XBUTTONDOWN | WM_XBUTTONUP)))
}
WM_MOUSEMOVE => {
let result = call(message, wparam, lparam);
if set_over_control(hwnd, false) {
track_leave(hwnd, TME_LEAVE);
}
result
}
WM_LBUTTONUP | WM_RBUTTONUP | WM_MBUTTONUP | WM_XBUTTONUP => {
let result = call(message, wparam, lparam);
if cursor_on_window(hwnd).is_some_and(|at| control_at(hwnd, &window, at).is_some()) {
set_over_control(hwnd, true);
track_leave(hwnd, TME_LEAVE | TME_NONCLIENT);
}
result
}
WM_MOUSELEAVE if cursor_on_window(hwnd).is_some_and(|at| control_at(hwnd, &window, at).is_some()) => LRESULT(0),
WM_NCMOUSELEAVE => {
if set_over_control(hwnd, false) {
if cursor_on_window(hwnd).is_some() {
track_leave(hwnd, TME_LEAVE);
} else {
call(WM_MOUSELEAVE, WPARAM(0), LPARAM(0));
}
}
call(message, wparam, lparam)
}
WM_SETCURSOR
if is_control_code(lparam.0 as usize & 0xffff)
&& wparam.0 == hwnd.0 as usize
&& cursor().is_some_and(|at| control_at(hwnd, &window, at).is_some()) =>
{
call(message, wparam, LPARAM((lparam.0 & !0xffff) | HTCLIENT as isize))
}
WM_NCDESTROY => {
if let Ok(mut laid) = LAID.lock() {
laid.remove(&(hwnd.0 as isize));
}
unsafe {
SetWindowLongPtrW(
hwnd,
GWLP_WNDPROC,
original.map_or(0, |procedure| procedure as usize as isize),
);
}
call(message, wparam, lparam)
}
_ => call(message, wparam, lparam),
}
}
#[cfg(test)]
mod tests;