Skip to content

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.md
index 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 out
method), the Windows-only `apps/solidcraft/src/native_crash.rs` (the exception filter that
records 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 3D
mice, so no other device is sent anything).
- **Errors are `Result<T, E>`** through the crate's error type and `?`. An unfinished feature
diff --git a/apps/solidcraft/Cargo.toml b/apps/solidcraft/Cargo.toml
index 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.rs
index 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.rs
index 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);