Merge PR #6878: Windows: maximized window lets an auto-hidden taskbar show (#4845)

apps/photocraft/src/window_frame.rs

@@ -20,6 +20,11 @@
 //! the work area plus its own frame, clear of the taskbar. winit pins the client area to the work
 //! area either way (`WM_NCCALCSIZE`), so the app's pixels do not move.
 //!
+//! An auto-hidden taskbar reserves no work area, so that trim leaves the maximize covering the
+//! whole monitor, and the shell, taking it for a full-screen app, no longer reveals the taskbar
+//! when the pointer reaches its edge (#4845). On each edge with an auto-hidden taskbar the guard
+//! instead stops the window one pixel short of the monitor, as other custom-frame apps do.
+//!
 //! The Windows calls go through safe `winsafe` wrappers; the workspace forbids `unsafe`, and
 //! winsafe can't wrap a raw handle without it, so the window is found by its handle instead.
 
@@ -29,7 +34,20 @@ pub use platform::service;
 mod platform {
     use eframe::wgpu::rwh::{HasWindowHandle, RawWindowHandle};
     use photocraft_ui_egui::WindowFrameFn;
-    use winsafe::{HWND, HwndPlace, POINT, SIZE, co};
+    use winsafe::prelude::Handle;
+    use winsafe::{AtomStr, HWND, HwndPlace, POINT, SIZE, co};
+
+    /// A rect in desktop coordinates: `(left, top, right, bottom)`, right and bottom exclusive.
+    type Rect = (i32, i32, i32, i32);
+
+    /// A monitor edge.
+    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
+    enum Edge {
+        Left,
+        Top,
+        Right,
+        Bottom,
+    }
 
     /// A guard that keeps the window borderless each frame, or `None` when the app uses the
     /// system title bar (the window is decorated) or its handle can't be found.
@@ -99,8 +117,11 @@ mod platform {
             return;
         };
         let (m, w) = (mi.rcMonitor, mi.rcWork);
-        let Some((left, top, right, bottom)) =
-            clamped_rect((r.left, r.top, r.right, r.bottom), (m.left, m.top, m.right, m.bottom), (w.left, w.top, w.right, w.bottom))
+        let (rect, monitor, work) = ((r.left, r.top, r.right, r.bottom), (m.left, m.top, m.right, m.bottom), (w.left, w.top, w.right, w.bottom));
+        // The taskbars (a couple of `FindWindowEx` calls) are only looked up while the window
+        // covers the whole monitor, which a trimmed maximize no longer does.
+        let Some((left, top, right, bottom)) = clamped_rect(rect, monitor, work)
+            .or_else(|| covers(rect, monitor).then(|| short_of_autohide_taskbars(rect, monitor, work, &taskbar_edges(monitor))).flatten())
         else {
             return;
         };
@@ -153,6 +174,69 @@ mod platform {
         (corrected != rect).then_some(corrected)
     }
 
+    /// Whether `rect` reaches every edge of `monitor`: what the shell takes for a full-screen app.
+    fn covers(rect: Rect, monitor: Rect) -> bool {
+        rect.0 <= monitor.0 && rect.1 <= monitor.1 && rect.2 >= monitor.2 && rect.3 >= monitor.3
+    }
+
+    /// The edges of `monitor` that have a taskbar (the primary `Shell_TrayWnd` or a secondary
+    /// monitor's `Shell_SecondaryTrayWnd`), shown or hidden.
+    fn taskbar_edges(monitor: Rect) -> Vec<Edge> {
+        let mut edges = Vec::new();
+        for class in ["Shell_TrayWnd", "Shell_SecondaryTrayWnd"] {
+            let mut after: Option<HWND> = None;
+            // One taskbar per monitor; the bound only guards against a misbehaving shell.
+            for _ in 0..64 {
+                let Ok(Some(tray)) = HWND::NULL.FindWindowEx(after.as_ref(), AtomStr::from_str(class), None) else {
+                    break;
+                };
+                if let Ok(r) = tray.GetWindowRect() {
+                    edges.extend(taskbar_edge((r.left, r.top, r.right, r.bottom), monitor));
+                }
+                after = Some(tray);
+            }
+        }
+        edges
+    }
+
+    /// The edge of `monitor` a taskbar with rect `taskbar` sits on: the one nearest its centre,
+    /// or `None` when it is on another monitor. An auto-hidden taskbar is parked mostly past its
+    /// edge with a sliver left on screen, so its centre may lie outside the monitor.
+    fn taskbar_edge(taskbar: Rect, monitor: Rect) -> Option<Edge> {
+        let (tl, tt, tr, tb) = (i64::from(taskbar.0), i64::from(taskbar.1), i64::from(taskbar.2), i64::from(taskbar.3));
+        let (ml, mt, mr, mb) = (i64::from(monitor.0), i64::from(monitor.1), i64::from(monitor.2), i64::from(monitor.3));
+        if tl >= tr || tt >= tb || ml >= mr || mt >= mb || tr <= ml || tl >= mr || tb <= mt || tt >= mb {
+            return None;
+        }
+        // Doubled centre and distances, so nothing rounds.
+        let (cx, cy) = (tl + tr, tt + tb);
+        [(Edge::Left, cx - 2 * ml), (Edge::Top, cy - 2 * mt), (Edge::Right, 2 * mr - cx), (Edge::Bottom, 2 * mb - cy)]
+            .into_iter()
+            .min_by_key(|&(_, distance)| distance)
+            .map(|(edge, _)| edge)
+    }
+
+    /// A maximize covering its monitor, trimmed to stop one pixel short of each edge where a
+    /// taskbar reserves no work area (it auto-hides), so the shell still reveals it there.
+    /// `None` when there is nothing to trim.
+    fn short_of_autohide_taskbars(rect: Rect, monitor: Rect, work: Rect, taskbars: &[Edge]) -> Option<Rect> {
+        if !covers(rect, monitor) {
+            return None;
+        }
+        let (mut l, mut t, mut r, mut b) = rect;
+        for edge in taskbars {
+            match edge {
+                Edge::Left if work.0 == monitor.0 => l = monitor.0.checked_add(1)?,
+                Edge::Top if work.1 == monitor.1 => t = monitor.1.checked_add(1)?,
+                Edge::Right if work.2 == monitor.2 => r = monitor.2.checked_sub(1)?,
+                Edge::Bottom if work.3 == monitor.3 => b = monitor.3.checked_sub(1)?,
+                _ => {}
+            }
+        }
+        let trimmed = (l, t, r, b);
+        (l < r && t < b && trimmed != rect).then_some(trimmed)
+    }
+
     /// `style` without the OS title bar and frame (`WS_CAPTION`, which already includes
     /// `WS_BORDER`). The sizing border (`WS_THICKFRAME`) stays, so edge resizing and Aero snap
     /// keep working, as they did with winit 0.27's undecorated windows.
@@ -162,7 +246,7 @@ mod platform {
 
     #[cfg(test)]
     mod tests {
-        use super::{borderless, clamped_rect};
+        use super::{Edge, borderless, clamped_rect, short_of_autohide_taskbars, taskbar_edge};
         use winsafe::co;
 
         #[test]
@@ -221,6 +305,35 @@ mod platform {
             assert_eq!(clamped_rect((-500, -8, 1428, 1088), monitor, work), None, "dragged");
             assert_eq!(clamped_rect((0, 48, 960, 1080), monitor, work), None, "half-screen");
         }
+
+        #[test]
+        fn a_maximize_leaves_a_pixel_strip_on_an_auto_hidden_taskbar_edge() {
+            // #4845: an auto-hidden taskbar reserves no work area.
+            let monitor = (0, 0, 1920, 1080);
+            let rect = (-8, -8, 1928, 1088);
+            for (edge, expected) in
+                [(Edge::Bottom, (-8, -8, 1928, 1079)), (Edge::Top, (-8, 1, 1928, 1088)), (Edge::Left, (1, -8, 1928, 1088)), (Edge::Right, (-8, -8, 1919, 1088))]
+            {
+                assert_eq!(short_of_autohide_taskbars(rect, monitor, monitor, &[edge]), Some(expected));
+                assert_eq!(short_of_autohide_taskbars(expected, monitor, monitor, &[edge]), None, "already trimmed");
+            }
+            assert_eq!(short_of_autohide_taskbars(rect, monitor, monitor, &[]), None, "no taskbar");
+            // A taskbar that reserves its work area is the clamp's job.
+            assert_eq!(short_of_autohide_taskbars(rect, monitor, (0, 0, 1920, 1032), &[Edge::Bottom]), None);
+            assert_eq!(short_of_autohide_taskbars((0, 0, 960, 1080), monitor, monitor, &[Edge::Bottom]), None, "half-screen");
+        }
+
+        #[test]
+        fn a_taskbar_sits_on_the_monitor_edge_nearest_its_centre() {
+            let monitor = (0, 0, 1920, 1080);
+            assert_eq!(taskbar_edge((0, 1032, 1920, 1080), monitor), Some(Edge::Bottom), "shown");
+            assert_eq!(taskbar_edge((0, 1078, 1920, 1126), monitor), Some(Edge::Bottom), "auto-hidden");
+            assert_eq!(taskbar_edge((0, -46, 1920, 2), monitor), Some(Edge::Top));
+            assert_eq!(taskbar_edge((-60, 0, 2, 1080), monitor), Some(Edge::Left));
+            assert_eq!(taskbar_edge((1918, 0, 1980, 1080), monitor), Some(Edge::Right));
+            assert_eq!(taskbar_edge((1920, 1032, 3840, 1080), monitor), None, "other monitor");
+            assert!(taskbar_edge((i32::MIN, i32::MIN, i32::MAX, i32::MAX), monitor).is_some(), "no overflow");
+        }
     }
 }