From f25a8e6abc5a6bc03fe0f44bdbef34fdeb4f4fd6 Mon Sep 17 00:00:00 2001 From: Dahak Builds Date: Sun, 1 Nov 2026 09:10:54 +0000 Subject: [PATCH] Fix tooltip delay bypass on sequential menu hovers (#10481) (#10482) * claim: #10481 * Restart tooltip delay per menu row and place tips beside the drop-down (#10481) * Format --------- Co-authored-by: Dahak Builds --- crates/ui-egui/src/toolbar.rs | 150 ++++++++++++++++++++++++++++++++-- 1 file changed, 141 insertions(+), 9 deletions(-) diff --git a/crates/ui-egui/src/toolbar.rs b/crates/ui-egui/src/toolbar.rs index 5f437829d..07ba04b0e 100644 --- a/crates/ui-egui/src/toolbar.rs +++ b/crates/ui-egui/src/toolbar.rs @@ -2297,6 +2297,126 @@ fn dropdown_width(app: &SolveApp, ui: &egui::Ui, cmds: &[&'static solidcraft_eng .fold(200.0, f32::max) } +/// True once the pointer has rested on this drop-down row long enough for its tip. egui's +/// shared tooltip grace time lets every row after the first show its tip the moment the +/// pointer reaches it; timing each row's own hover restarts the delay for each newly hovered +/// row instead (#10481). +fn dropdown_tip_ready(ui: &egui::Ui, resp: &egui::Response) -> bool { + let ctx = ui.ctx(); + let key = resp.id.with("sc_dropdown_tip"); + if !resp.hovered() { + ctx.data_mut(|d| d.remove::<(f64, u64)>(key)); + return false; + } + let pass = ctx.cumulative_pass_nr(); + let now = ctx.input(|i| i.time); + let (mut began, seen) = ctx.data(|d| d.get_temp::<(f64, u64)>(key)).unwrap_or((now, 0)); + // A drop-down that closed and opened again under the pointer starts the delay afresh. + if seen + 1 < pass { + began = now; + } + ctx.data_mut(|d| d.insert_temp(key, (began, pass))); + let delay = f64::from(ui.style().interaction.tooltip_delay); + if now - began < delay { + ctx.request_repaint_after_secs((delay - (now - began)) as f32); + return false; + } + true +} + +/// Show `add` as `resp`'s tip beside the drop-down rather than under the pointer: to the +/// right of the menu, or to its left when the right has no room, so the tip never covers +/// the menu's rows (#10481). Returns the tip's rect when it was shown. +fn dropdown_tip(ui: &egui::Ui, menu: Rect, resp: &egui::Response, add: impl FnOnce(&mut egui::Ui)) -> Option { + if !dropdown_tip_ready(ui, resp) { + return None; + } + let ctx = ui.ctx(); + let tip_id = resp.id.with("sc_dropdown_tip_area"); + // Last pass's size; the first pass assumes the tip fits on the right. + let size = ctx.read_response(tip_id).map(|r| r.rect.size()).unwrap_or(egui::Vec2::ZERO); + let screen = ctx.content_rect(); + let gap = 6.0; + let x = if menu.right() + gap + size.x <= screen.right() { menu.right() + gap } else { (menu.left() - gap - size.x).max(screen.left()) }; + let y = resp.rect.top().min((screen.bottom() - size.y).max(screen.top())); + let area = Container::new(ctx, Surface::Popup) + .area(tip_id) + .order(egui::Order::Tooltip) + .interactable(false) + .fixed_pos(pos2(x, y)) + .show(ctx, |ui| Container::new(ctx, Surface::Popup).show_frame(ui, Container::menu_frame(), ui.max_rect(), add)); + Some(area.inner.response.rect) +} + +#[cfg(test)] +mod dropdown_tip_tests { + use super::*; + use egui::{Event, RawInput}; + + /// One pass of a fake two-row drop-down at `menu`; returns the tips shown this pass. + fn tip_pass(ctx: &egui::Context, menu: Rect, time: f64, at: egui::Pos2) -> Vec<(usize, Rect)> { + let raw = RawInput { events: vec![Event::PointerMoved(at)], time: Some(time), ..Default::default() }; + let mut shown: Vec<(usize, Rect)> = Vec::new(); + crate::test_support::frame(ctx, raw, |ui| { + let ctx = ui.ctx(); + egui::Area::new(egui::Id::new("test_dropdown")).fixed_pos(menu.min).show(ctx, |ui| { + for row in 0..2 { + let rect = Rect::from_min_size(menu.min + vec2(0.0, row as f32 * 32.0), vec2(menu.width(), 32.0)); + let resp = ui.interact(rect, egui::Id::new(("test_row", row)), Sense::hover()); + let tip = if row == 0 { + dropdown_tip(ui, menu, &resp, |ui| { + ui.label("first row"); + }) + } else { + dropdown_tip(ui, menu, &resp, |ui| { + ui.label("second row"); + }) + }; + if let Some(rect) = tip { + shown.push((row, rect)); + } + } + }); + }); + shown + } + + /// egui registers hover a pass or two after the pointer arrives (measured), while leaving + /// a row drops hover the same pass. Timings below keep a margin around that lag. + #[test] + fn each_newly_hovered_row_waits_the_full_tip_delay() { + let ctx = crate::fonts::test_context(); + let menu = Rect::from_min_size(pos2(20.0, 20.0), vec2(220.0, 64.0)); + let a = menu.min + vec2(10.0, 16.0); + let b = menu.min + vec2(10.0, 48.0); + let mut tips = Vec::new(); + for (time, at, expect) in [ + (0.0, a, None), + (0.1, a, None), + (0.3, a, None), // hover registers around here; the first row's delay starts + (0.5, a, None), // still inside the delay + (0.9, a, Some(0)), + (1.0, b, None), // the first row lost hover the moment the pointer left it + (1.2, b, None), // the second row must not inherit the open tip's grace (#10481) + (1.4, b, None), // its own delay cannot have elapsed yet, whenever hover registered + (2.2, b, Some(1)), // after its own full delay, with margin for late registration + ] { + let got = tip_pass(&ctx, menu, time, at); + match expect { + Some(row) => { + assert_eq!(got.len(), 1, "exactly row {row}'s tip at t={time}, got {got:?}"); + assert_eq!(got[0].0, row, "wrong row's tip at t={time}"); + let tip = got[0].1; + assert!(tip.min.x >= menu.max.x, "the tip sits beside the menu, never over its rows: {tip:?} vs {menu:?}"); + tips.push((row, tip)); + } + None => assert!(got.is_empty(), "no tip expected at t={time}, got {got:?}"), + } + } + assert_eq!(tips.len(), 2, "both rows showed a tip after their own delay"); + } +} + /// One command row of a panel drop-down: icon, label and shortcut, with the hover background /// under the pointer or keyboard focus (like every menu). /// `revealed` is the pulse strength when the command search points this row out (#7287). @@ -2363,19 +2483,31 @@ fn dropdown_row( crate::scenario::publish_handle(&format!("dropdown_pin:{}", c.id), pr.center()); } let tip = if pinned { "Remove from Toolbar" } else { "Pin to Toolbar" }; - if pin.on_hover_text(tip).clicked() { + // The drop-down's rect from the last pass: tips sit beside it, never over its rows (#10481). + let menu = egui::containers::AreaState::load(ui.ctx(), ui.layer_id().id).map(|state| state.rect()).unwrap_or(rect); + if pin.clicked() { return RowAction::TogglePin; } + dropdown_tip(ui, menu, &pin, |ui| { + ui.label(crate::i18n::tr_label(tip)); + }); // A disabled row says why; a documented command also shows its help (#2758). let reason = info.disabled_reason.as_deref().filter(|_| !info.enabled).map(|reason| app.tr_label(reason)); - let resp = if let Some(hint) = persistent_hint(app, c, info.enabled) { - resp.on_hover_text(hint) - } else { - match crate::command_help::row_tip(c.id, &label, Some(shortcut.as_str()).filter(|k| !k.is_empty()), reason) { - Some(tip) => crate::command_help::tooltip(resp, c.id, tip), - None => resp, - } - }; + if let Some(hint) = persistent_hint(app, c, info.enabled) { + dropdown_tip(ui, menu, &resp, move |ui| { + ui.label(hint); + }); + } else if let Some(tip) = crate::command_help::row_tip(c.id, &label, Some(shortcut.as_str()).filter(|k| !k.is_empty()), reason) { + let help = crate::command_help::help(c.id); + dropdown_tip(ui, menu, &resp, move |ui| { + ui.set_max_width(300.0); + ui.label(tip); + if let Some(help) = help { + ui.add_space(2.0); + ui.label(egui::RichText::new(help).weak()); + } + }); + } if resp.secondary_clicked() { return RowAction::Menu(resp.interact_pointer_pos().unwrap_or(rect.left_bottom())); }