|
|
|
|
@ -0,0 +1,319 @@
|
|
|
|
|
//! Implements a Windows-specific custom window frame (no titlebar, but native boarder, shadows and resize).
|
|
|
|
|
//! Look and feel should be similar to a standard window.
|
|
|
|
|
//!
|
|
|
|
|
//! Implementation notes:
|
|
|
|
|
//! - Windows that don't use standard decorations don't get native resize handles or shadows by default.
|
|
|
|
|
//! - We implement resize handles (outside the main window) by creating an invisible "helper" window that
|
|
|
|
|
//! is a little larger than the main window and positioned on top of it. The helper window does hit-testing
|
|
|
|
|
//! and triggers native resize operations on the main window when the user clicks and drags a resize area.
|
|
|
|
|
//! - The helper window is a invisible window that never activates, so it doesn't steal focus from the main window.
|
|
|
|
|
//! - The main window needs to update the helper window's position and size whenever it moves or resizes.
|
|
|
|
|
|
|
|
|
|
use std::sync::OnceLock;
|
|
|
|
|
use wgpu::rwh::{HasWindowHandle, RawWindowHandle};
|
|
|
|
|
use windows::Win32::Foundation::*;
|
|
|
|
|
use windows::Win32::Graphics::{Dwm::*, Gdi::HBRUSH};
|
|
|
|
|
use windows::Win32::System::LibraryLoader::GetModuleHandleW;
|
|
|
|
|
use windows::Win32::UI::Controls::MARGINS;
|
|
|
|
|
use windows::Win32::UI::WindowsAndMessaging::*;
|
|
|
|
|
use windows::core::PCWSTR;
|
|
|
|
|
use winit::window::Window;
|
|
|
|
|
|
|
|
|
|
pub(super) struct WindowsNativeWindowHandle {
|
|
|
|
|
inner: WindowsNativeWindowHandleInner,
|
|
|
|
|
}
|
|
|
|
|
impl WindowsNativeWindowHandle {
|
|
|
|
|
pub(super) fn new(window: &Window) -> Self {
|
|
|
|
|
let inner = WindowsNativeWindowHandleInner::new(window);
|
|
|
|
|
WindowsNativeWindowHandle { inner }
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
impl Drop for WindowsNativeWindowHandle {
|
|
|
|
|
fn drop(&mut self) {
|
|
|
|
|
self.inner.destroy();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[derive(Clone)]
|
|
|
|
|
struct WindowsNativeWindowHandleInner {
|
|
|
|
|
main: HWND,
|
|
|
|
|
helper: HWND,
|
|
|
|
|
prev_window_message_handler: isize,
|
|
|
|
|
}
|
|
|
|
|
impl WindowsNativeWindowHandleInner {
|
|
|
|
|
fn new(window: &Window) -> WindowsNativeWindowHandleInner {
|
|
|
|
|
// Extract Win32 HWND from winit.
|
|
|
|
|
let hwnd = match window.window_handle().expect("No window handle").as_raw() {
|
|
|
|
|
RawWindowHandle::Win32(h) => HWND(h.hwnd.get() as *mut std::ffi::c_void),
|
|
|
|
|
_ => panic!("Not a Win32 window"),
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
// Register the invisible helper (resize ring) window class.
|
|
|
|
|
unsafe { ensure_helper_class() };
|
|
|
|
|
|
|
|
|
|
// Create the helper as a popup tool window that never activates.
|
|
|
|
|
// WS_EX_NOACTIVATE keeps focus on the main window; WS_EX_TOOLWINDOW hides it from Alt+Tab.
|
|
|
|
|
// https://learn.microsoft.com/windows/win32/winmsg/extended-window-styles
|
|
|
|
|
let ex = WS_EX_NOACTIVATE | WS_EX_TOOLWINDOW;
|
|
|
|
|
let style = WS_POPUP;
|
|
|
|
|
let helper = unsafe {
|
|
|
|
|
CreateWindowExW(
|
|
|
|
|
ex,
|
|
|
|
|
PCWSTR(HELPER_CLASS_NAME.encode_utf16().collect::<Vec<_>>().as_ptr()),
|
|
|
|
|
PCWSTR::null(),
|
|
|
|
|
style,
|
|
|
|
|
0,
|
|
|
|
|
0,
|
|
|
|
|
0,
|
|
|
|
|
0,
|
|
|
|
|
None,
|
|
|
|
|
None,
|
|
|
|
|
HINSTANCE(std::ptr::null_mut()),
|
|
|
|
|
// Pass the main window's HWND to WM_NCCREATE so the helper can store it.
|
|
|
|
|
Some(&hwnd as *const _ as _),
|
|
|
|
|
)
|
|
|
|
|
}
|
|
|
|
|
.expect("CreateWindowExW failed");
|
|
|
|
|
|
|
|
|
|
// Subclass the main window.
|
|
|
|
|
// https://learn.microsoft.com/windows/win32/api/winuser/nf-winuser-setwindowlongptra
|
|
|
|
|
let prev_window_message_handler = unsafe { SetWindowLongPtrW(hwnd, GWLP_WNDPROC, main_window_handle_message as isize) };
|
|
|
|
|
if prev_window_message_handler == 0 {
|
|
|
|
|
let _ = unsafe { DestroyWindow(helper) };
|
|
|
|
|
panic!("SetWindowLongPtrW failed");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
let inner = WindowsNativeWindowHandleInner {
|
|
|
|
|
main: hwnd,
|
|
|
|
|
helper,
|
|
|
|
|
prev_window_message_handler,
|
|
|
|
|
};
|
|
|
|
|
registry::insert(&inner);
|
|
|
|
|
|
|
|
|
|
// Place the helper over the main window and show it without activation.
|
|
|
|
|
unsafe { position_helper(hwnd, helper) };
|
|
|
|
|
let _ = unsafe { ShowWindow(helper, SW_SHOWNOACTIVATE) };
|
|
|
|
|
|
|
|
|
|
// DwmExtendFrameIntoClientArea is needed to keep native window frame (but no titlebar).
|
|
|
|
|
// https://learn.microsoft.com/windows/win32/api/dwmapi/nf-dwmapi-dwmextendframeintoclientarea
|
|
|
|
|
// https://learn.microsoft.com/windows/win32/api/dwmapi/ne-dwmapi-dwmwindowattribute
|
|
|
|
|
let mut boarder_size: u32 = 1;
|
|
|
|
|
let _ = unsafe { DwmGetWindowAttribute(hwnd, DWMWA_VISIBLE_FRAME_BORDER_THICKNESS, &mut boarder_size as *mut _ as *mut _, size_of::<u32>() as u32) };
|
|
|
|
|
let margins = MARGINS {
|
|
|
|
|
cxLeftWidth: 0,
|
|
|
|
|
cxRightWidth: 0,
|
|
|
|
|
cyBottomHeight: 0,
|
|
|
|
|
cyTopHeight: boarder_size as i32,
|
|
|
|
|
};
|
|
|
|
|
let _ = unsafe { DwmExtendFrameIntoClientArea(hwnd, &margins) };
|
|
|
|
|
|
|
|
|
|
// Force window update
|
|
|
|
|
let _ = unsafe { SetWindowPos(hwnd, None, 0, 0, 0, 0, SWP_FRAMECHANGED | SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER) };
|
|
|
|
|
|
|
|
|
|
inner
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn destroy(&self) {
|
|
|
|
|
registry::remove_by_main(self.main);
|
|
|
|
|
|
|
|
|
|
// Undo subclassing and destroy the helper window.
|
|
|
|
|
let _ = unsafe { SetWindowLongPtrW(self.main, GWLP_WNDPROC, self.prev_window_message_handler) };
|
|
|
|
|
if self.helper.0 != std::ptr::null_mut() {
|
|
|
|
|
let _ = unsafe { DestroyWindow(self.helper) };
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
mod registry {
|
|
|
|
|
use std::cell::RefCell;
|
|
|
|
|
use windows::Win32::Foundation::HWND;
|
|
|
|
|
|
|
|
|
|
use crate::native_window::windows::WindowsNativeWindowHandleInner;
|
|
|
|
|
|
|
|
|
|
thread_local! {
|
|
|
|
|
static STORE: RefCell<Vec<WindowsNativeWindowHandleInner>> = RefCell::new(Vec::new());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub(super) fn find_by_main(main: HWND) -> Option<WindowsNativeWindowHandleInner> {
|
|
|
|
|
STORE.with_borrow(|vec| vec.iter().find(|h| h.main == main).cloned())
|
|
|
|
|
}
|
|
|
|
|
pub(super) fn remove_by_main(main: HWND) {
|
|
|
|
|
STORE.with_borrow_mut(|vec| {
|
|
|
|
|
vec.retain(|h| h.main != main);
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
pub(super) fn insert(handle: &WindowsNativeWindowHandleInner) {
|
|
|
|
|
STORE.with_borrow_mut(|vec| {
|
|
|
|
|
vec.push(handle.clone());
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const HELPER_CLASS_NAME: &str = "Helper\0";
|
|
|
|
|
|
|
|
|
|
static HELPER_CLASS_LOCK: OnceLock<u16> = OnceLock::new();
|
|
|
|
|
unsafe fn ensure_helper_class() {
|
|
|
|
|
// Register a window class for the invisible resize helper.
|
|
|
|
|
let _ = *HELPER_CLASS_LOCK.get_or_init(|| {
|
|
|
|
|
let class_name: Vec<u16> = HELPER_CLASS_NAME.encode_utf16().collect();
|
|
|
|
|
let wc = WNDCLASSW {
|
|
|
|
|
style: CS_HREDRAW | CS_VREDRAW,
|
|
|
|
|
lpfnWndProc: Some(helper_window_handle_message),
|
|
|
|
|
hInstance: unsafe { GetModuleHandleW(None).unwrap().into() },
|
|
|
|
|
hIcon: HICON::default(),
|
|
|
|
|
hCursor: unsafe { LoadCursorW(HINSTANCE(std::ptr::null_mut()), IDC_ARROW).unwrap() },
|
|
|
|
|
// No painting; the ring is invisible.
|
|
|
|
|
hbrBackground: HBRUSH::default(),
|
|
|
|
|
lpszClassName: PCWSTR(class_name.as_ptr()),
|
|
|
|
|
..Default::default()
|
|
|
|
|
};
|
|
|
|
|
unsafe { RegisterClassW(&wc) }
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Main window message handler, called on the UI thread for every message the main window receives.
|
|
|
|
|
unsafe extern "system" fn main_window_handle_message(hwnd: HWND, msg: u32, wparam: WPARAM, lparam: LPARAM) -> LRESULT {
|
|
|
|
|
if msg == WM_NCCALCSIZE {
|
|
|
|
|
if wparam.0 != 0 {
|
|
|
|
|
// Return 0 to to tell Windows to skip the default non-client area calculation and drawing.
|
|
|
|
|
return LRESULT(0);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
let Some(handle) = registry::find_by_main(hwnd) else {
|
|
|
|
|
return unsafe { DefWindowProcW(hwnd, msg, wparam, lparam) };
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
match msg {
|
|
|
|
|
// Keep the invisible resize helper in sync with moves/resizes/visibility.
|
|
|
|
|
WM_MOVE | WM_MOVING | WM_SIZE | WM_SIZING | WM_WINDOWPOSCHANGED | WM_SHOWWINDOW => {
|
|
|
|
|
if msg == WM_SHOWWINDOW {
|
|
|
|
|
if wparam.0 == 0 {
|
|
|
|
|
let _ = unsafe { ShowWindow(handle.helper, SW_HIDE) };
|
|
|
|
|
} else {
|
|
|
|
|
let _ = unsafe { ShowWindow(handle.helper, SW_SHOWNOACTIVATE) };
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
unsafe { position_helper(hwnd, handle.helper) };
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// If the main window is destroyed, destroy the helper too.
|
|
|
|
|
// Should only be needed if windows forcefully destroys the main window.
|
|
|
|
|
WM_DESTROY => {
|
|
|
|
|
let _ = unsafe { DestroyWindow(handle.helper) };
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
_ => {}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Ensure the previous window message handler is not null.
|
|
|
|
|
assert_ne!(handle.prev_window_message_handler, 0);
|
|
|
|
|
|
|
|
|
|
// Call the previous window message handler, this is a standard subclassing pattern.
|
|
|
|
|
let prev_window_message_handler_fn_ptr: *const () = std::ptr::without_provenance(handle.prev_window_message_handler as usize);
|
|
|
|
|
let prev_window_message_handler_fn = unsafe { std::mem::transmute::<_, _>(prev_window_message_handler_fn_ptr) };
|
|
|
|
|
return unsafe { CallWindowProcW(Some(prev_window_message_handler_fn), hwnd, msg, wparam, lparam) };
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Helper window message handler, called on the UI thread for every message the helper window receives.
|
|
|
|
|
unsafe extern "system" fn helper_window_handle_message(hwnd: HWND, msg: u32, wparam: WPARAM, lparam: LPARAM) -> LRESULT {
|
|
|
|
|
match msg {
|
|
|
|
|
// Helper window creation, should be the first message that the helper window receives.
|
|
|
|
|
WM_NCCREATE => {
|
|
|
|
|
// Main window HWND is provided when creating the helper window with `CreateWindowExW`
|
|
|
|
|
// Save main window HWND in GWLP_USERDATA so we can extract it later
|
|
|
|
|
let crate_struct = lparam.0 as *const CREATESTRUCTW;
|
|
|
|
|
let create_param = unsafe { (*crate_struct).lpCreateParams as *const HWND };
|
|
|
|
|
unsafe { SetWindowLongPtrW(hwnd, GWLP_USERDATA, (*create_param).0 as isize) };
|
|
|
|
|
return LRESULT(1);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Invisible; no background erase.
|
|
|
|
|
WM_ERASEBKGND => return LRESULT(1),
|
|
|
|
|
|
|
|
|
|
// Tell windows what resize areas we are hitting, this is used to decide what cursor to show.
|
|
|
|
|
WM_NCHITTEST => {
|
|
|
|
|
let ht = unsafe { calculate_hit(hwnd, lparam) };
|
|
|
|
|
return LRESULT(ht as isize);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// This starts the system's resize loop for the main window if a resize area is hit.
|
|
|
|
|
// Helper window button down translates to SC_SIZE | WMSZ_* on the main window.
|
|
|
|
|
WM_NCLBUTTONDOWN | WM_NCRBUTTONDOWN | WM_NCMBUTTONDOWN => {
|
|
|
|
|
// Extract the main window's HWND from GWLP_USERDATA that we saved earlier.
|
|
|
|
|
let main_ptr = unsafe { GetWindowLongPtrW(hwnd, GWLP_USERDATA) } as *mut std::ffi::c_void;
|
|
|
|
|
let main = HWND(main_ptr);
|
|
|
|
|
if unsafe { IsWindow(main).as_bool() } {
|
|
|
|
|
let Some(wmsz) = (unsafe { calculate_resize_direction(hwnd, lparam) }) else {
|
|
|
|
|
return LRESULT(0);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
// Ensure that the main window can receive WM_SYSCOMMAND.
|
|
|
|
|
let _ = unsafe { SetForegroundWindow(main) };
|
|
|
|
|
|
|
|
|
|
// Start sizing on the main window in the calculated direction. (SC_SIZE + WMSZ_*)
|
|
|
|
|
let _ = unsafe { PostMessageW(main, WM_SYSCOMMAND, WPARAM((SC_SIZE + wmsz) as usize), lparam) };
|
|
|
|
|
}
|
|
|
|
|
return LRESULT(0);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Never activate the helper window, allows all inputs that don't hit the resize areas to pass through.
|
|
|
|
|
WM_MOUSEACTIVATE => return LRESULT(MA_NOACTIVATE as isize),
|
|
|
|
|
_ => {}
|
|
|
|
|
}
|
|
|
|
|
unsafe { DefWindowProcW(hwnd, msg, wparam, lparam) }
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Position the helper window to match the main window's location and size (plus the resize band size).
|
|
|
|
|
unsafe fn position_helper(main: HWND, helper: HWND) {
|
|
|
|
|
let mut r = RECT::default();
|
|
|
|
|
let _ = unsafe { GetWindowRect(main, &mut r) };
|
|
|
|
|
|
|
|
|
|
const RESIZE_BAND_SIZE: i32 = 8;
|
|
|
|
|
let x = r.left - RESIZE_BAND_SIZE;
|
|
|
|
|
let y = r.top - RESIZE_BAND_SIZE;
|
|
|
|
|
let w = (r.right - r.left) + RESIZE_BAND_SIZE * 2;
|
|
|
|
|
let h = (r.bottom - r.top) + RESIZE_BAND_SIZE * 2;
|
|
|
|
|
|
|
|
|
|
let _ = unsafe { SetWindowPos(helper, main, x, y, w, h, SWP_NOACTIVATE) };
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
unsafe fn calculate_hit(helper: HWND, lparam: LPARAM) -> u32 {
|
|
|
|
|
let x = (lparam.0 & 0xFFFF) as i16 as u32;
|
|
|
|
|
let y = ((lparam.0 >> 16) & 0xFFFF) as i16 as u32;
|
|
|
|
|
|
|
|
|
|
let mut r = RECT::default();
|
|
|
|
|
let _ = unsafe { GetWindowRect(helper, &mut r) };
|
|
|
|
|
|
|
|
|
|
const RESIZE_BAND_THICKNESS: i32 = 8;
|
|
|
|
|
let on_top = y < (r.top + RESIZE_BAND_THICKNESS) as u32;
|
|
|
|
|
let on_right = x >= (r.right - RESIZE_BAND_THICKNESS) as u32;
|
|
|
|
|
let on_bottom = y >= (r.bottom - RESIZE_BAND_THICKNESS) as u32;
|
|
|
|
|
let on_left = x < (r.left + RESIZE_BAND_THICKNESS) as u32;
|
|
|
|
|
|
|
|
|
|
match (on_top, on_right, on_bottom, on_left) {
|
|
|
|
|
(true, _, _, true) => HTTOPLEFT,
|
|
|
|
|
(true, true, _, _) => HTTOPRIGHT,
|
|
|
|
|
(_, true, true, _) => HTBOTTOMRIGHT,
|
|
|
|
|
(_, _, true, true) => HTBOTTOMLEFT,
|
|
|
|
|
(true, _, _, _) => HTTOP,
|
|
|
|
|
(_, true, _, _) => HTRIGHT,
|
|
|
|
|
(_, _, true, _) => HTBOTTOM,
|
|
|
|
|
(_, _, _, true) => HTLEFT,
|
|
|
|
|
_ => HTTRANSPARENT as u32,
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
unsafe fn calculate_resize_direction(helper: HWND, lparam: LPARAM) -> Option<u32> {
|
|
|
|
|
match unsafe { calculate_hit(helper, lparam) } {
|
|
|
|
|
HTLEFT => Some(WMSZ_LEFT),
|
|
|
|
|
HTRIGHT => Some(WMSZ_RIGHT),
|
|
|
|
|
HTTOP => Some(WMSZ_TOP),
|
|
|
|
|
HTBOTTOM => Some(WMSZ_BOTTOM),
|
|
|
|
|
HTTOPLEFT => Some(WMSZ_TOPLEFT),
|
|
|
|
|
HTTOPRIGHT => Some(WMSZ_TOPRIGHT),
|
|
|
|
|
HTBOTTOMLEFT => Some(WMSZ_BOTTOMLEFT),
|
|
|
|
|
HTBOTTOMRIGHT => Some(WMSZ_BOTTOMRIGHT),
|
|
|
|
|
_ => None,
|
|
|
|
|
}
|
|
|
|
|
}
|
Timon
GitHub