From 56f09f3993ce99d7e6dfd4af6379a600d4b184d9 Mon Sep 17 00:00:00 2001 From: HiroKenEz <59478073+HiroKenEz@users.noreply.github.com> Date: Mon, 26 Oct 2026 10:43:53 +0000 Subject: [PATCH] Frame rate readout stays beside a right-side pane, not under it (#6755) (#6767) * claim: #6755 * Frame rate readout stays beside a right-side pane, not under it (#6755) The readout and its details sat in the viewport's bottom-right corner even under the floating Assistant. They now move just left of any pane over that corner and come back when it closes. Co-Authored-By: Claude Opus 5.5 --------- Co-authored-by: Claude Opus 5.5 --- crates/ui-egui/src/frame_rate.rs | 60 +++++++++++++++---- crates/ui-egui/src/viewport_overlays_tests.rs | 50 ++++++++++++++++ 2 files changed, 100 insertions(+), 10 deletions(-) diff --git a/crates/ui-egui/src/frame_rate.rs b/crates/ui-egui/src/frame_rate.rs index c3507ef37..7d59e257b 100644 --- a/crates/ui-egui/src/frame_rate.rs +++ b/crates/ui-egui/src/frame_rate.rs @@ -138,11 +138,29 @@ fn budget_colour(t: &Tokens, ms: f32) -> Color32 { } } -/// Records this frame and paints the readout in the view's bottom-right corner, with the details -/// above it when they are on. The readout asks for no frames of its own, so it shows how often the -/// view is really drawn and leaves an idle window idle (a readout that redrew every frame kept the -/// GPU busy on an untouched window); the details show the frames the view drew. Once the frames -/// stop, one more frame a little over [`IDLE_AFTER`] later shows the view idle. +/// The readout's distance from the view's edges and from the panes beside it. +const MARGIN: f32 = 12.0; + +/// `readout` moved left until none of the `panes` covering the view overlaps it, `MARGIN` clear +/// of the leftmost of them; it stops at the view's left edge. +fn beside_panes(mut readout: Rect, view: Rect, panes: &[Rect]) -> Rect { + for _ in 0..panes.len().min(32) { + let Some(pane) = panes.iter().find(|p| p.is_finite() && p.is_positive() && p.intersects(readout)) else { break }; + let left = (pane.left() - MARGIN - readout.width()).max(view.left() + MARGIN); + if left >= readout.left() { + break; + } + readout = readout.translate(vec2(left - readout.left(), 0.0)); + } + readout +} + +/// Records this frame and paints the readout in the view's bottom-right corner, left of a pane over +/// that corner, with the details above it when they are on. The readout asks for no frames of its +/// own, so it shows how often the view is really drawn and leaves an idle window idle (a readout +/// that redrew every frame kept the GPU busy on an untouched window); the details show the frames +/// the view drew. Once the frames stop, one more frame a little over [`IDLE_AFTER`] later shows the +/// view idle. pub(crate) fn paint(app: &mut SolveApp, ui: &egui::Ui, painter: &egui::Painter, rect: Rect) { if !app.preferences.show_frame_rate { app.frame_rate = FrameRate::default(); @@ -164,7 +182,9 @@ pub(crate) fn paint(app: &mut SolveApp, ui: &egui::Ui, painter: &egui::Painter, let font = FontId::monospace(t.font_body); let galley = painter.layout_no_wrap(text, font.clone(), t.text); let size = galley.size() + vec2(16.0, 8.0); - let mut r = Rect::from_min_size(pos2(rect.right() - 12.0 - size.x, rect.bottom() - 12.0 - size.y), size); + let r = Rect::from_min_size(pos2(rect.right() - MARGIN - size.x, rect.bottom() - MARGIN - size.y), size); + // Just left of a pane over the view's right side (the Assistant, a dialog), not under it (#6755). + let mut r = beside_panes(r, rect, &crate::shell::covered_rects(app)); // Above the navigation bar where a narrow view brings the two together. if let Some(nav) = app.viewport.layout.as_ref().map(|l| l.navigation) && r.intersects(nav.expand(4.0)) @@ -184,18 +204,18 @@ pub(crate) fn paint(app: &mut SolveApp, ui: &egui::Ui, painter: &egui::Painter, } } -/// The details above the readout `below`: the frame-time graph with the triangles over it, the -/// histogram and what the GPU drew. +/// The details above the readout `below`, flush with its right edge: the frame-time graph with the +/// triangles over it, the histogram and what the GPU drew. fn details(app: &SolveApp, painter: &egui::Painter, view: Rect, below: Rect, drawn: crate::gpu::DrawStats, font: &FontId) { let t = Tokens::get(); let (pad, row, label_h, graph_h, hist_h) = (8.0, 16.0, 12.0, 56.0, 40.0); let lines = 7.0 + 0.8; // seven rows and the adapter's name - let w = 300.0_f32.min(view.width() - 24.0); + let w = 300.0_f32.min(below.right() - view.left() - MARGIN); let h = pad * 2.0 + row + label_h + graph_h + 6.0 + hist_h + row + lines * row; if w < 160.0 || h > view.height() - below.height() - 30.0 { return; } - let panel = Rect::from_min_size(pos2(view.right() - 12.0 - w, below.top() - 6.0 - h), vec2(w, h)); + let panel = Rect::from_min_size(pos2(below.right() - w, below.top() - 6.0 - h), vec2(w, h)); painter.rect(panel, t.radius_sm, t.dialog_bg, t.control_border_stroke(t.border), egui::StrokeKind::Inside); crate::scenario::publish_handle("viewport:frame_details", panel.center()); let inner = panel.shrink(pad); @@ -414,6 +434,26 @@ mod tests { assert!(handle_at("viewport:frame_details").is_none()); } + /// Panes over the readout push it left, a pane-free corner keeps it, and hostile or + /// view-wide panes never push it out of the view (#6755). + #[test] + fn the_readout_moves_left_of_the_panes_over_it() { + use egui::{Rect, pos2}; + let view = Rect::from_min_max(pos2(0.0, 0.0), pos2(1000.0, 600.0)); + let readout = Rect::from_min_max(pos2(850.0, 560.0), pos2(988.0, 588.0)); + assert_eq!(super::beside_panes(readout, view, &[]), readout); + let top = Rect::from_min_max(pos2(700.0, 0.0), pos2(1000.0, 100.0)); + assert_eq!(super::beside_panes(readout, view, &[top]), readout, "a pane above leaves it in the corner"); + let chat = Rect::from_min_max(pos2(600.0, 40.0), pos2(992.0, 593.0)); + let dialog = Rect::from_min_max(pos2(380.0, 500.0), pos2(590.0, 580.0)); + let moved = super::beside_panes(readout, view, &[chat, dialog]); + assert_eq!((moved.right(), moved.size()), (dialog.left() - 12.0, readout.size()), "left of both"); + let nan = Rect::from_min_max(pos2(f32::NAN, 0.0), pos2(1000.0, 600.0)); + assert_eq!(super::beside_panes(readout, view, &[nan]), readout); + let everything = view.expand(10.0); + assert_eq!(super::beside_panes(readout, view, &[everything]).left(), 12.0, "stops at the view's left edge"); + } + #[test] fn counts_are_grouped_by_thousands() { assert_eq!(grouped(0), "0"); diff --git a/crates/ui-egui/src/viewport_overlays_tests.rs b/crates/ui-egui/src/viewport_overlays_tests.rs index 64ca91f29..2b3f604a8 100644 --- a/crates/ui-egui/src/viewport_overlays_tests.rs +++ b/crates/ui-egui/src/viewport_overlays_tests.rs @@ -557,3 +557,53 @@ fn left_history_sidebar_leaves_bottom_readouts_at_the_bottom() { assert!((readout.bottom() - (viewport.bottom() - 12.0)).abs() < 0.01, "{name}: {readout:?} in {viewport:?}"); } } + +/// The frame-rate readout and its details sit just left of a pane over the view's bottom-right +/// corner (the Assistant), follow it as it opens, changes width and closes, and stay in the +/// visible view; with the pane on the left they keep the corner (#6755). +#[test] +fn frame_rate_readout_stays_beside_a_right_pane() { + use crate::scenario::{handle_at, rect_of}; + for mode in [LayoutMode::Floating, LayoutMode::Docked] { + let mut h = Harness::new(); + h.app.home.open = false; + h.call("ui.set", json!({"layout": mode})); + h.app.preferences.show_frame_rate = true; + h.app.preferences.frame_rate_details = true; + h.app.preferences.agent_chat_side = "right".into(); + h.frames(3); + let in_corner = |h: &Harness| { + let viewport = h.app.viewport.layout.as_ref().unwrap().viewport; + let readout = rect_of("viewport:frame_rate").expect("the readout is drawn"); + assert!((readout.right() - (viewport.right() - 12.0)).abs() < 0.01, "{mode:?}: {readout:?} in {viewport:?}"); + }; + in_corner(&h); + // The Assistant's narrowest, a middle and its widest width. + for width in [280.0, 480.0, 760.0] { + h.call("ui.agent_chat", json!({"open": true, "picker": false, "side": "right", "width": width})); + h.frames(3); + let viewport = h.app.viewport.layout.as_ref().unwrap().viewport; + let pane = rect_of("agent_chat:panel").expect("the Assistant is drawn"); + let readout = rect_of("viewport:frame_rate").expect("the readout is drawn"); + assert!(viewport.contains_rect(readout), "{mode:?}, {width}: {readout:?} outside {viewport:?}"); + assert!(readout.right() <= pane.left() - 12.0 + 0.01, "{mode:?}, {width}: {readout:?} under {pane:?}"); + if mode == LayoutMode::Floating { + assert!((readout.right() - (pane.left() - 12.0)).abs() < 0.01, "{width}: {readout:?} not just left of {pane:?}"); + } + for covered in crate::shell::covered_rects(&h.app) { + assert!(!readout.intersects(covered), "{mode:?}, {width}: {readout:?} under {covered:?}"); + } + let details = handle_at("viewport:frame_details").expect("the details are drawn"); + assert!(viewport.contains(details) && details.x < pane.left(), "{mode:?}, {width}: details at {details:?}, pane {pane:?}"); + } + h.call("ui.agent_chat", json!({"open": false})); + h.frames(3); + assert!(rect_of("agent_chat:panel").is_none()); + in_corner(&h); + // On the left the pane leaves the corner free. + h.call("ui.agent_chat", json!({"open": true, "side": "left"})); + h.frames(3); + assert!(rect_of("agent_chat:panel").is_some()); + in_corner(&h); + } +}