SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Windows: the taskbar button shows the mark when the first frames are slow (#6391)
Matthew Knutson05d43d35422b
diff --git a/AGENTS.md b/AGENTS.mdindex 0720afeeff..62d67958b7 100644--- a/AGENTS.md+++ b/AGENTS.md@@ -35,7 +35,8 @@ People trust SolidCraft with their designs; a crash loses their work. **This outmethod), the Windows-only `apps/solidcraft/src/native_crash.rs` (the exception filter thatrecords crashes inside native code such as graphics drivers), the Windows-only`apps/solidcraft/src/native_frame.rs` (the window procedure that answers the resize-border hit- test of the window without OS decorations) and the Windows-only+ test of the window without OS decorations, and gives its class the icon the taskbar falls back+ on) and the Windows-only`apps/solidcraft/src/space_mouse/windows_hid.rs` (asks Plug and Play which HID interfaces are 3Dmice, so no other device is sent anything).- **Errors are `Result<T, E>`** through the crate's error type and `?`. An unfinished featurediff --git a/apps/solidcraft/Cargo.toml b/apps/solidcraft/Cargo.tomlindex 01b18459ba..e789767ce0 100644--- a/apps/solidcraft/Cargo.toml+++ b/apps/solidcraft/Cargo.toml@@ -14,7 +14,7 @@ raytrace-cpu = ["solidcraft-engine/raytrace-cpu"]# The workspace lints, except unsafe_code: denied, not forbidden, so that src/open_documents.rs# (macOS file-open events), src/native_crash.rs (Windows exception filter) and src/native_frame.rs-# (Windows resize border) can allow it: none has a safe API. Keep the rest in sync with [workspace.lints].+# (Windows resize border, taskbar icon) can allow it: none has a safe API. Keep the rest in sync with [workspace.lints].[lints.rust]unsafe_code = "deny"@@ -54,7 +54,8 @@ hidapi = { version = "2.6.7", default-features = false, features = ["windows-nat# The main window's handle for src/native_frame.rs (already in the tree through eframe and winit).raw-window-handle = "0.6"# Native crash capture (src/native_crash.rs): the exception filter, the faulting module, a minidump.-# The window's resize border and DPI size (src/native_frame.rs): the window procedure, hit test, DPI.+# The window's resize border, DPI size and class icon (src/native_frame.rs): the window procedure, hit+# test, DPI, the exe's icon.# Finding 3D mice through Plug and Play without asking other devices anything (src/space_mouse/windows_hid.rs).windows-sys = { version = "0.61", features = ["Win32_Devices_DeviceAndDriverInstallation",diff --git a/apps/solidcraft/src/main.rs b/apps/solidcraft/src/main.rsindex 7b5c07fb6d..226bad6fbe 100644--- a/apps/solidcraft/src/main.rs+++ b/apps/solidcraft/src/main.rs@@ -724,10 +724,15 @@ fn main() -> eframe::Result {let mut app = SolveApp::new(Session::default(), services(cc));app.apply_off_thread = Some(solidcraft_ui_egui::dialogs::APPLY_AT_ONCE);app.custom_titlebar = CUSTOM_TITLEBAR;- // Windows: the OS hit test offers the resize border, at the window's DPI, from the- // first message (#1381).#[cfg(target_os = "windows")]{+ // Windows: the taskbar button shows the mark even when slow first frames keep the+ // taskbar waiting for the window's icon.+ if !native_frame::set_class_icon(cc) {+ eprintln!("SolidCraft window: no class icon; the taskbar may show a generic one");+ }+ // The OS hit test offers the resize border, at the window's DPI, from the first+ // message (#1381).app.native_resize_border = CUSTOM_TITLEBAR && native_frame::install(cc);if CUSTOM_TITLEBAR && !app.native_resize_border {eprintln!("SolidCraft window: no native resize border; egui edge zones instead");diff --git a/apps/solidcraft/src/native_frame.rs b/apps/solidcraft/src/native_frame.rsindex a43c1c37e5..763ee7efac 100644--- a/apps/solidcraft/src/native_frame.rs+++ b/apps/solidcraft/src/native_frame.rs@@ -15,10 +15,14 @@//! window rescales once at the crossing and stays under the pointer, instead of the OS's move//! loop and winit disagreeing about a frame the window doesn't have.//!-//! Replacing a window procedure has no safe API, hence the `unsafe_code` allowance on this-//! module (the app crate denies it; see `native_crash.rs` and `open_documents.rs` for the others).+//! Replacing a window procedure and setting a window class's icon have no safe API, hence the+//! `unsafe_code` allowance on this module (the app crate denies it; see `native_crash.rs` and+//! `open_documents.rs` for the others).//! The procedure is installed once, on the thread that owns the window, for the main window only,//! and calls the previous one (winit's) for everything it doesn't answer.+//!+//! [`set_class_icon`] gives the window's class the exe's icon, so the taskbar button shows the+//! mark even when the window is too busy to answer the taskbar's request for its icon.#![allow(unsafe_code)]use std::sync::atomic::{AtomicIsize, Ordering};@@ -27,12 +31,18 @@ use raw_window_handle::{HasWindowHandle, RawWindowHandle};use solidcraft_ui_egui::titlebar;use windows_sys::Win32::Foundation::{HWND, LPARAM, LRESULT, RECT, SIZE, WPARAM};use windows_sys::Win32::Graphics::Gdi::{GetMonitorInfoW, MONITOR_DEFAULTTONEAREST, MONITORINFO, MonitorFromWindow};+use windows_sys::Win32::System::LibraryLoader::GetModuleHandleW;use windows_sys::Win32::UI::HiDpi::{GetDpiForWindow, GetSystemMetricsForDpi};use windows_sys::Win32::UI::WindowsAndMessaging::{- CallWindowProcW, GWL_STYLE, GWLP_WNDPROC, GetClientRect, GetWindowLongPtrW, GetWindowRect, HTBOTTOM, HTBOTTOMLEFT, HTBOTTOMRIGHT, HTLEFT,- HTRIGHT, HTTOP, HTTOPLEFT, HTTOPRIGHT, IsIconic, IsZoomed, SM_CXPADDEDBORDER, SM_CXSIZEFRAME, SetWindowLongPtrW, WM_GETDPISCALEDSIZE,- WM_NCDESTROY, WM_NCHITTEST, WNDPROC, WS_THICKFRAME,+ CallWindowProcW, GCLP_HICON, GCLP_HICONSM, GWL_STYLE, GWLP_WNDPROC, GetClientRect, GetWindowLongPtrW, GetWindowRect, HTBOTTOM, HTBOTTOMLEFT,+ HTBOTTOMRIGHT, HTLEFT, HTRIGHT, HTTOP, HTTOPLEFT, HTTOPRIGHT, IMAGE_ICON, IsIconic, IsZoomed, LR_DEFAULTCOLOR, LoadImageW, SM_CXICON,+ SM_CXPADDEDBORDER, SM_CXSIZEFRAME, SM_CXSMICON, SetWindowLongPtrW, WM_GETDPISCALEDSIZE, WM_NCDESTROY, WM_NCHITTEST, WNDPROC, WS_THICKFRAME,};+// windows-sys has SetClassLongPtrW only on 64-bit targets; on 32-bit Windows it is SetClassLongW.+#[cfg(target_pointer_width = "64")]+use windows_sys::Win32::UI::WindowsAndMessaging::SetClassLongPtrW;+#[cfg(target_pointer_width = "32")]+use windows_sys::Win32::UI::WindowsAndMessaging::SetClassLongW as SetClassLongPtrW;/// The work area (the monitor without the taskbar) of the monitor nearest the window, in physical/// pixels: left, top, width, height.@@ -54,6 +64,48 @@ pub fn work_area(window: &impl HasWindowHandle) -> Option<(i32, i32, i32, i32)>Some((rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top))}+/// The exe's icon resource (`build.rs` embeds it as `1 ICON`).+const ICON_RESOURCE: usize = 1;++/// Give the main window's class the exe's icon, big and small. Call it before the window is+/// shown (eframe's app creator).+///+/// The taskbar asks a window for its icon when the window appears. eframe sets the window's+/// icon before that, while the window is still hidden, and then shows the window at the end of+/// its first frame; if that frame is slow, or startup kept the thread busy long enough for+/// Windows to mark the window as not responding, the request isn't answered in time. The taskbar then+/// takes the window class's icon and doesn't ask again. winit registers its class without one,+/// so the button showed Windows' generic icon for as long as the window was open.+/// `false` if it isn't a Win32 window or the exe's icon doesn't load; SetClassLongPtrW's own+/// failure can't be told from a class that had no icon (both return 0), so it isn't reported.+pub fn set_class_icon(window: &impl HasWindowHandle) -> bool {+ let Ok(handle) = window.window_handle() else { return false };+ let RawWindowHandle::Win32(w) = handle.as_raw() else { return false };+ let hwnd = w.hwnd.get() as HWND;+ // SAFETY: a plain query on the live main window.+ let dpi = unsafe { GetDpiForWindow(hwnd) };+ let (Some(big), Some(small)) = (exe_icon(SM_CXICON, dpi), exe_icon(SM_CXSMICON, dpi)) else { return false };+ // SAFETY: `hwnd` is the live main window and both icons are valid handles. The class keeps+ // them for the rest of the process, so they are never destroyed. `as _`: on 32-bit Windows+ // this is SetClassLongW (see the imports), which takes an i32.+ unsafe {+ SetClassLongPtrW(hwnd, GCLP_HICON, big as _);+ SetClassLongPtrW(hwnd, GCLP_HICONSM, small as _);+ }+ true+}++/// The exe's icon at the size of system metric `metric` (`SM_CXICON`, `SM_CXSMICON`) at `dpi`.+fn exe_icon(metric: i32, dpi: u32) -> Option<windows_sys::Win32::Foundation::HANDLE> {+ // SAFETY: GetModuleHandleW(null) is this exe, loaded for the life of the process; the name+ // is an integer resource id (MAKEINTRESOURCE), which LoadImageW accepts in place of a string.+ let icon = unsafe {+ let size = GetSystemMetricsForDpi(metric, dpi);+ LoadImageW(GetModuleHandleW(std::ptr::null()), std::ptr::without_provenance(ICON_RESOURCE), IMAGE_ICON, size, size, LR_DEFAULTCOLOR)+ };+ (!icon.is_null()).then_some(icon)+}+/// The window procedure ours replaced (winit's), as an address; 0 before [`install`].static PREVIOUS: AtomicIsize = AtomicIsize::new(0);