* claim: #8546 * Ribbon: pressed state for commands that stay on (#8546)
This commit is contained in:
@@ -0,0 +1,34 @@
|
||||
{
|
||||
"en": {
|
||||
"prefs.persistent_ribbon_pressed": "Highlight active ribbon commands",
|
||||
"prefs.persistent_ribbon_pressed_help": "Highlight ribbon commands while their effects are on. Turn off to keep the previous neutral appearance and command help."
|
||||
},
|
||||
"ar": {
|
||||
"prefs.persistent_ribbon_pressed": "تمييز أوامر الشريط النشطة",
|
||||
"prefs.persistent_ribbon_pressed_help": "تمييز أوامر الشريط أثناء تفعيل تأثيراتها. أوقف هذا الخيار للاحتفاظ بالمظهر المحايد السابق ومساعدة الأوامر."
|
||||
},
|
||||
"de": {
|
||||
"prefs.persistent_ribbon_pressed": "Aktive Menübandbefehle hervorheben",
|
||||
"prefs.persistent_ribbon_pressed_help": "Hebt Befehle im Menüband hervor, solange ihre Effekte eingeschaltet sind. Deaktivieren Sie diese Option, um die bisherige neutrale Darstellung und Befehlshilfe beizubehalten."
|
||||
},
|
||||
"he": {
|
||||
"prefs.persistent_ribbon_pressed": "הדגשת פקודות פעילות ברצועת הכלים",
|
||||
"prefs.persistent_ribbon_pressed_help": "הדגשת פקודות ברצועת הכלים כל עוד ההשפעות שלהן פעילות. כבו אפשרות זו כדי לשמור על המראה הניטרלי הקודם ועל עזרת הפקודות."
|
||||
},
|
||||
"ja": {
|
||||
"prefs.persistent_ribbon_pressed": "有効なリボンコマンドを強調表示",
|
||||
"prefs.persistent_ribbon_pressed_help": "効果が有効な間、リボンのコマンドを強調表示します。無効にすると、従来の中立的な表示とコマンドのヘルプを保持します。"
|
||||
},
|
||||
"ko": {
|
||||
"prefs.persistent_ribbon_pressed": "활성 리본 명령 강조 표시",
|
||||
"prefs.persistent_ribbon_pressed_help": "효과가 켜져 있는 동안 리본 명령을 강조 표시합니다. 끄면 이전의 중립적인 모양과 명령 도움말을 유지합니다."
|
||||
},
|
||||
"vi": {
|
||||
"prefs.persistent_ribbon_pressed": "Tô sáng lệnh đang bật trên dải băng",
|
||||
"prefs.persistent_ribbon_pressed_help": "Tô sáng các lệnh trên dải băng khi hiệu ứng của chúng đang bật. Tắt tùy chọn này để giữ giao diện trung tính và trợ giúp lệnh như trước."
|
||||
},
|
||||
"zh": {
|
||||
"prefs.persistent_ribbon_pressed": "突出显示已启用的功能区命令",
|
||||
"prefs.persistent_ribbon_pressed_help": "在效果启用时突出显示相应的功能区命令。关闭此选项可保留原来的中性外观和命令帮助。"
|
||||
}
|
||||
}
|
||||
@@ -1060,6 +1060,8 @@ preference_settings! {
|
||||
navigation_bar: crate::navigation_bar::NavigationBar = Default::default(), PAGE_INTERFACE;
|
||||
/// Show command names beneath ribbon icons, independently of workspace layout.
|
||||
ribbon_labels: bool = true, PAGE_INTERFACE;
|
||||
/// Show engine-derived persistent selection in the ribbon; off retains neutral buttons.
|
||||
persistent_ribbon_pressed: bool = true, PAGE_INTERFACE => check_id("prefs.persistent_ribbon_pressed");
|
||||
/// Keep the SKETCH tab in the ribbon, right after MODEL, while no sketch is open; its drawing
|
||||
/// tools then start a sketch first (#7904).
|
||||
sketch_tab_always: bool = false, PAGE_INTERFACE => check_id("prefs.sketch_tab_always");
|
||||
@@ -4954,6 +4956,7 @@ mod tests {
|
||||
("ui_font", json!("test font"), PAGE_INTERFACE),
|
||||
("layout", json!("compact"), PAGE_INTERFACE),
|
||||
("ribbon_labels", json!(false), PAGE_INTERFACE),
|
||||
("persistent_ribbon_pressed", json!(false), PAGE_INTERFACE),
|
||||
("sketch_tab_always", json!(true), PAGE_INTERFACE),
|
||||
("ribbon_reveal", json!(true), PAGE_INTERFACE),
|
||||
("dialog_buttons", json!("top"), PAGE_INTERFACE),
|
||||
@@ -6117,6 +6120,42 @@ mod tests {
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn history_preferences_widget_click_reveals_scrolled_content_and_keeps_folds_closed() {
|
||||
let steps: serde_json::Value = serde_json::from_str(include_str!("../tests/scenarios/history_sketches_under_feature.json")).unwrap();
|
||||
let steps = steps.as_array().unwrap();
|
||||
let transition = steps.iter().position(|step| step["params"]["history_sketches"] == "under_feature").unwrap();
|
||||
let mut h = crate::scenario::Harness::new();
|
||||
for step in steps.iter().take(transition) {
|
||||
h.step(step).unwrap();
|
||||
}
|
||||
h.call("ui.prefs", json!({"open":"Interface"}));
|
||||
let at = h.widget("Under their feature").unwrap();
|
||||
let page = crate::scenario::rect_of("prefs:page_body").unwrap();
|
||||
assert!(!page.contains(egui::pos2(at[0] as f32, at[1] as f32)), "the real control begins scrolled out of view");
|
||||
assert_eq!(h.app.preferences.history_sketches, HistorySketches::InOrder);
|
||||
h.step(&json!({"widget":"Under their feature", "near":"Sketches"})).unwrap();
|
||||
assert_eq!(h.app.preferences.history_sketches, HistorySketches::UnderFeature);
|
||||
let at = h.widget("Under their feature").unwrap();
|
||||
assert!(crate::scenario::rect_of("prefs:page_body").unwrap().contains(egui::pos2(at[0] as f32, at[1] as f32)));
|
||||
assert!(h.app.tree.expanded.is_empty(), "revealing a preference does not open history folds");
|
||||
let page_before = crate::scenario::rect_of("prefs:page_body");
|
||||
h.step(&json!({"widget":"Apply"})).unwrap();
|
||||
assert!(h.app.prefs_window.open);
|
||||
assert_eq!(crate::scenario::rect_of("prefs:page_body"), page_before);
|
||||
h.step(&json!({"widget":"OK"})).unwrap();
|
||||
h.step(&steps[transition + 1]).unwrap();
|
||||
assert!(!h.app.prefs_window.open);
|
||||
for step in steps.iter().skip(transition + 2) {
|
||||
h.step(step).unwrap();
|
||||
}
|
||||
h.call("ui.prefs", json!({"open":"Interface"}));
|
||||
h.step(&json!({"widget":"Navigation"})).unwrap();
|
||||
assert_eq!(h.app.prefs_window.section, PAGE_NAVIGATION, "sidebar navigation remains a real click");
|
||||
h.step(&json!({"widget":"Cancel"})).unwrap();
|
||||
assert!(!h.app.prefs_window.open);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn history_sketches_defaults_in_order_and_follows_preferences_transactions() {
|
||||
let old: Prefs = serde_json::from_value(json!({"timeline_left": true})).unwrap();
|
||||
@@ -6265,6 +6304,38 @@ mod tests {
|
||||
assert_eq!(app.session.undo.len(), undo);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn persistent_ribbon_pressed_preference_checkbox_control_persists_cancels_and_resets() {
|
||||
assert!(Prefs::default().persistent_ribbon_pressed);
|
||||
assert!(lenient(&json!({"theme":"light"})).persistent_ribbon_pressed);
|
||||
assert!(lenient(&json!({"persistent_ribbon_pressed":"no"})).persistent_ribbon_pressed);
|
||||
let mut h = crate::scenario::Harness::new();
|
||||
let design = h.app.session.doc.to_json();
|
||||
let revision = h.app.session.revision;
|
||||
h.call("ui.prefs", json!({"open":"Interface"}));
|
||||
super::reveal_preference(&mut h, "prefs:persistent_ribbon_pressed");
|
||||
let checkbox = crate::scenario::handle_at("prefs:persistent_ribbon_pressed").unwrap();
|
||||
h.call("ui.click", json!({"x":checkbox.x,"y":checkbox.y}));
|
||||
assert!(!h.app.preferences.persistent_ribbon_pressed);
|
||||
assert_eq!(h.call("ui.prefs", json!({}))["result"]["persistent_ribbon_pressed"], false);
|
||||
let mut restored = SolveApp::new(Default::default(), Default::default());
|
||||
restored.load_prefs(&h.app.prefs());
|
||||
assert!(!restored.preferences.persistent_ribbon_pressed);
|
||||
h.call("ui.prefs", json!({"button":"cancel"}));
|
||||
assert!(h.app.preferences.persistent_ribbon_pressed);
|
||||
h.call("ui.prefs", json!({"open":"Interface","persistent_ribbon_pressed":false,"button":"apply"}));
|
||||
h.call("ui.prefs", json!({"button":"defaults"}));
|
||||
assert!(h.app.preferences.persistent_ribbon_pressed);
|
||||
h.call("ui.prefs", json!({"button":"cancel"}));
|
||||
assert!(!h.app.preferences.persistent_ribbon_pressed);
|
||||
for malformed in [json!("false"), json!(null), json!(0), json!([])] {
|
||||
assert!(super::set(&mut h.app, &json!({"persistent_ribbon_pressed":malformed})).is_err());
|
||||
assert!(!h.app.preferences.persistent_ribbon_pressed);
|
||||
}
|
||||
assert_eq!(h.app.session.revision, revision);
|
||||
assert_eq!(h.app.session.doc.to_json(), design);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn single_surface_analysis_preference_checkbox_persists_cancels_and_resets() {
|
||||
assert!(Prefs::default().single_surface_analysis);
|
||||
|
||||
@@ -94,6 +94,10 @@ pub(super) fn interface(app: &mut SolveApp, ui: &mut egui::Ui, t: &Tokens) {
|
||||
app.preferences.ribbon_labels = selected == 0;
|
||||
}
|
||||
});
|
||||
ui_kit::row(ui, "", |ui| {
|
||||
let check = setting::persistent_ribbon_pressed(app, ui).on_hover_text(app.tr("prefs.persistent_ribbon_pressed_help"));
|
||||
crate::scenario::publish_target("prefs:persistent_ribbon_pressed", check.rect);
|
||||
});
|
||||
// The SKETCH tab outside a sketch too (#7904).
|
||||
ui_kit::row(ui, "", |ui| {
|
||||
let check = setting::sketch_tab_always(app, ui).on_hover_text(app.tr("prefs.sketch_tab_always_note"));
|
||||
|
||||
@@ -355,6 +355,34 @@ impl Harness {
|
||||
})
|
||||
}
|
||||
|
||||
/// Accessibility bounds include scrolled-out page content. Reveal that content with
|
||||
/// wheel input before using its coordinates; window actions and navigation stay put.
|
||||
fn reveal_widget(&mut self, text: &str, near: Option<&str>) -> Result<[f64; 2], String> {
|
||||
let find = |h: &Self| match near {
|
||||
Some(label) => h.widget_near(text, label),
|
||||
None => h.widget(text),
|
||||
};
|
||||
for _ in 0..32 {
|
||||
let point = find(self).ok_or_else(|| format!("no widget `{text}` on screen"))?;
|
||||
let at = egui::pos2(point[0] as f32, point[1] as f32);
|
||||
let page = self.app.prefs_window.open.then(|| rect_of("prefs:page_body")).flatten();
|
||||
let chrome = ["prefs:ok", "prefs:apply", "prefs:cancel", "prefs:search"].iter().any(|key| handle_at(key) == Some(at));
|
||||
let Some(page) = page.filter(|page| !chrome && page.x_range().contains(at.x)) else { return Ok(point) };
|
||||
if page.contains(at) {
|
||||
return Ok(point);
|
||||
}
|
||||
self.call("ui.scroll", json!({"x":page.center().x,"y":page.center().y,"delta":if at.y < page.top() {100} else {-100}}));
|
||||
// Follow the wheel's actual smoothing, rather than clicking its moving content.
|
||||
for _ in 0..120 {
|
||||
if self.ctx.input(|input| !input.is_scrolling()) {
|
||||
break;
|
||||
}
|
||||
self.frame();
|
||||
}
|
||||
}
|
||||
Err(format!("widget `{text}` could not be revealed in its page"))
|
||||
}
|
||||
|
||||
/// Centres of the visible widgets whose label or value is `text`, last drawn first.
|
||||
fn widgets(&self, text: &str) -> Vec<[f64; 2]> {
|
||||
let Some(tree) = self.output.accesskit_update.as_ref() else { return Vec::new() };
|
||||
@@ -457,12 +485,10 @@ impl Harness {
|
||||
self.call("ui.click", p)
|
||||
} else if let Some(text) = s.get("widget").and_then(Value::as_str) {
|
||||
// A dialog field, choice or button, found by its text.
|
||||
let found = match s.get("near").and_then(Value::as_str) {
|
||||
Some(near) => self.widget_near(text, near),
|
||||
None => self.widget(text),
|
||||
};
|
||||
let [x, y] = found.ok_or_else(|| format!("no widget `{text}` on screen"))?;
|
||||
let near = s.get("near").and_then(Value::as_str);
|
||||
let [x, y] = self.reveal_widget(text, near)?;
|
||||
self.call("ui.move", json!({"x": x, "y": y}));
|
||||
let [x, y] = self.reveal_widget(text, near)?;
|
||||
self.call("ui.click", json!({"x": x, "y": y}))
|
||||
} else if let Some(at) = s.get("hold") {
|
||||
// Press and hold still (Select Other): `frames` with the button down (default 40,
|
||||
|
||||
+551
-19
@@ -986,11 +986,117 @@ fn ribbon_label_lines(painter: &egui::Painter, label: &str, width: f32) -> Vec<S
|
||||
lines
|
||||
}
|
||||
|
||||
/// Commands opt into persistent presentation; the engine status list remains the only truth.
|
||||
const PERSISTENT_COMMANDS: &[&str] =
|
||||
&["inspect.accessibility", "inspect.continuity", "inspect.curvature_map", "inspect.draft", "inspect.environment_map", "inspect.zebra"];
|
||||
|
||||
fn persistent_command(id: &str) -> bool {
|
||||
PERSISTENT_COMMANDS.contains(&id)
|
||||
}
|
||||
|
||||
fn persistent_pressed(app: &SolveApp, id: &str) -> bool {
|
||||
app.preferences.persistent_ribbon_pressed && persistent_command(id) && app.session.status_items().iter().any(|item| item.command == id)
|
||||
}
|
||||
|
||||
fn persistent_button_name(app: &SolveApp, command: &solidcraft_engine::CommandSpec) -> String {
|
||||
let info = crate::render_workspace::interactive_command_info(app, command);
|
||||
let label = crate::workspace::ribbon_button_label(command);
|
||||
app.tr_label(if label == command.label { info.label } else { label }).to_string()
|
||||
}
|
||||
|
||||
fn persistent_hint(app: &SolveApp, command: &solidcraft_engine::CommandSpec, enabled: bool) -> Option<String> {
|
||||
(enabled && persistent_pressed(app, command.id)).then(|| {
|
||||
let name = persistent_button_name(app, command);
|
||||
crate::i18n::Locale::for_language(&app.preferences.language).format("ui.viewport_status_clear_hint", &[("name", &name)])
|
||||
})
|
||||
}
|
||||
|
||||
/// Paint slots retain original z-order, while their presentation is resolved after every
|
||||
/// command interaction in this ribbon pass. These records never survive the current frame.
|
||||
struct PersistentRibbonPaint {
|
||||
command: &'static solidcraft_engine::CommandSpec,
|
||||
response: egui::Response,
|
||||
rect: Rect,
|
||||
background: egui::layers::ShapeIdx,
|
||||
label_slot: egui::layers::ShapeIdx,
|
||||
neutral: egui::Shape,
|
||||
label: Option<String>,
|
||||
enabled: bool,
|
||||
disabled: Option<String>,
|
||||
}
|
||||
|
||||
fn paint_persistent_ribbon(app: &SolveApp, ui: &egui::Ui, paints: Vec<PersistentRibbonPaint>, tab: &str) {
|
||||
let t = Tokens::get();
|
||||
let items = app.session.status_items();
|
||||
let mut count = 0;
|
||||
for paint in paints {
|
||||
let selected = app.preferences.persistent_ribbon_pressed && items.iter().any(|item| item.command == paint.command.id);
|
||||
let ink = if !paint.enabled {
|
||||
t.text_dim
|
||||
} else if selected {
|
||||
t.selected_ink
|
||||
} else {
|
||||
t.text
|
||||
};
|
||||
// Resolve the genuine live tool after dispatch too: a click may have ended it.
|
||||
// The compatibility presentation keeps its original transient recipe.
|
||||
let neutral = if app.preferences.persistent_ribbon_pressed && app.tool.as_ref().is_some_and(|tool| tool.cmd == paint.command.id) {
|
||||
let accent = crate::theme::TabAccent::for_tab(&t, tab);
|
||||
egui::Shape::Rect(egui::epaint::RectShape::new(
|
||||
paint.rect,
|
||||
t.radius_sm,
|
||||
accent.soft,
|
||||
Stroke::new(1.0, accent.color),
|
||||
egui::StrokeKind::Inside,
|
||||
))
|
||||
} else {
|
||||
paint.neutral
|
||||
};
|
||||
let background = if selected {
|
||||
count += 1;
|
||||
crate::scenario::publish_target(&format!("ribbon:pressed:{}", paint.command.id), paint.rect);
|
||||
ui_kit::persistent_button_shape(ui, &paint.response, paint.rect)
|
||||
} else if paint.response.has_focus() && app.preferences.persistent_ribbon_pressed {
|
||||
egui::Shape::Vec(vec![neutral, ui_kit::native_button_focus(ui, &paint.response, paint.rect)])
|
||||
} else {
|
||||
neutral
|
||||
};
|
||||
ui.painter().set(paint.background, background);
|
||||
if paint.response.has_focus() {
|
||||
crate::scenario::publish_target(&format!("ribbon:focus:{}", paint.command.id), paint.rect);
|
||||
}
|
||||
if let Some(label) = paint.label {
|
||||
let galley = ribbon_button_galley_weight(ui.painter(), &label, paint.rect.width() - BUTTON_LABEL_PADDING, ink, selected);
|
||||
ui.painter()
|
||||
.set(paint.label_slot, egui::Shape::galley(pos2(paint.rect.center().x, ribbon_label_top(paint.rect, galley.size().y)), galley, ink));
|
||||
}
|
||||
paint.response.widget_info(|| {
|
||||
if app.preferences.persistent_ribbon_pressed {
|
||||
egui::WidgetInfo::selected(egui::WidgetType::Button, paint.enabled, selected, persistent_button_name(app, paint.command))
|
||||
} else {
|
||||
let info = crate::render_workspace::interactive_command_info(app, paint.command);
|
||||
egui::WidgetInfo::labeled(egui::WidgetType::Button, paint.enabled, app.tr_label(info.label))
|
||||
}
|
||||
});
|
||||
let _ = ribbon_tooltip(app, paint.response, paint.command, paint.disabled.as_deref());
|
||||
}
|
||||
crate::scenario::publish_count("ribbon:pressed", count as f64);
|
||||
}
|
||||
|
||||
fn ribbon_button_galley(painter: &egui::Painter, label: &str, width: f32, color: Color32) -> std::sync::Arc<egui::Galley> {
|
||||
ribbon_button_galley_weight(painter, label, width, color, false)
|
||||
}
|
||||
|
||||
fn ribbon_button_galley_weight(painter: &egui::Painter, label: &str, width: f32, color: Color32, selected: bool) -> std::sync::Arc<egui::Galley> {
|
||||
let lines = ribbon_button_lines(painter, label, width);
|
||||
// Explicit newlines only: egui must never split an oversized word.
|
||||
let size = crate::theme::Tokens::get().font_body;
|
||||
let mut job = egui::text::LayoutJob::simple(lines.join("\n"), FontId::proportional(size), color, f32::INFINITY);
|
||||
let mut job = egui::text::LayoutJob::simple(
|
||||
lines.join("\n"),
|
||||
if selected { crate::fonts::semibold(size) } else { FontId::proportional(size) },
|
||||
color,
|
||||
f32::INFINITY,
|
||||
);
|
||||
job.halign = egui::Align::Center;
|
||||
// Two lines sit closer than the font's own spacing, so they fit in the button under its
|
||||
// icon (#8391).
|
||||
@@ -1347,6 +1453,7 @@ pub fn toolbar(app: &mut SolveApp, ui: &mut egui::Ui) {
|
||||
if reveal.is_some() {
|
||||
ui.ctx().request_repaint();
|
||||
}
|
||||
let mut persistent_paints = Vec::new();
|
||||
let mut px = ribbon_left;
|
||||
let top = r.top() + TAB_ROW_HEIGHT;
|
||||
let mut drop: Option<(&'static str, &'static str, Option<&'static str>)> = None;
|
||||
@@ -1533,17 +1640,30 @@ pub fn toolbar(app: &mut SolveApp, ui: &mut egui::Ui) {
|
||||
if resp.secondary_clicked() {
|
||||
menu = Some((resp.interact_pointer_pos().unwrap_or(br.left_bottom()), c.id));
|
||||
}
|
||||
let persistent = persistent_command(selected.id);
|
||||
let background_slot = painter.add(egui::Shape::Noop);
|
||||
let accent = crate::theme::TabAccent::for_tab(&t, &tab);
|
||||
let family_open = family.is_some_and(|f| egui::Popup::is_id_open(ui.ctx(), ui.id().with(("family", f.label)).with("popup")));
|
||||
if !finish
|
||||
let neutral = if !finish
|
||||
&& (resp.is_pointer_button_down_on()
|
||||
|| running.as_deref() == Some(selected.id)
|
||||
|| (running.as_deref() == Some(selected.id) && !(persistent && app.preferences.persistent_ribbon_pressed))
|
||||
|| family_open
|
||||
|| (selected.id == "view.shots_strip" && app.preferences.render_shots_strip))
|
||||
{
|
||||
painter.rect(whole, t.radius_sm, accent.soft, Stroke::new(1.0, accent.color), egui::StrokeKind::Inside);
|
||||
egui::Shape::Rect(egui::epaint::RectShape::new(
|
||||
whole,
|
||||
t.radius_sm,
|
||||
accent.soft,
|
||||
Stroke::new(1.0, accent.color),
|
||||
egui::StrokeKind::Inside,
|
||||
))
|
||||
} else if resp.hovered() && info.enabled {
|
||||
painter.rect_filled(whole, t.radius_sm, t.hover);
|
||||
egui::Shape::rect_filled(whole, t.radius_sm, t.hover)
|
||||
} else {
|
||||
egui::Shape::Noop
|
||||
};
|
||||
if !persistent {
|
||||
painter.set(background_slot, neutral.clone());
|
||||
}
|
||||
let revealed = reveal.as_ref().filter(|r| r.id == c.id || r.id == selected.id || family.is_some_and(|f| f.commands.contains(&r.id)));
|
||||
if revealed.is_some() {
|
||||
@@ -1561,12 +1681,34 @@ pub fn toolbar(app: &mut SolveApp, ui: &mut egui::Ui) {
|
||||
Rect::from_center_size(pos2(br.center().x, whole.top() + if labels { 16.0 } else { button_height / 2.0 }), vec2(side, side));
|
||||
icons::paint_icon(&painter, icon_rect, icon, if info.enabled { 1.0 } else { 0.35 });
|
||||
let tr_label = app.tr_label(info.label).to_string();
|
||||
resp.widget_info(|| egui::WidgetInfo::labeled(egui::WidgetType::Button, ui.is_enabled() && info.enabled, &tr_label));
|
||||
if ribbon_tooltip(app, resp, selected, info.disabled_reason.as_deref()).clicked() && info.enabled {
|
||||
if !persistent {
|
||||
resp.widget_info(|| egui::WidgetInfo::labeled(egui::WidgetType::Button, ui.is_enabled() && info.enabled, &tr_label));
|
||||
}
|
||||
let clicked = resp.clicked();
|
||||
if !persistent {
|
||||
let _ = ribbon_tooltip(app, resp.clone(), selected, info.disabled_reason.as_deref());
|
||||
}
|
||||
if clicked && info.enabled {
|
||||
if persistent && app.preferences.persistent_ribbon_pressed {
|
||||
resp.request_focus();
|
||||
}
|
||||
let id = selected.id;
|
||||
app.start_pinned(id, Some(whole));
|
||||
}
|
||||
if let Some(f) = family {
|
||||
if persistent {
|
||||
let label = persistent_button_name(app, selected);
|
||||
persistent_paints.push(PersistentRibbonPaint {
|
||||
command: selected,
|
||||
response: resp,
|
||||
rect: whole,
|
||||
background: background_slot,
|
||||
label_slot: painter.add(egui::Shape::Noop),
|
||||
neutral,
|
||||
label: labels.then_some(label),
|
||||
enabled: ui.is_enabled() && info.enabled,
|
||||
disabled: info.disabled_reason.clone(),
|
||||
});
|
||||
} else if let Some(f) = family {
|
||||
let ar = if labels {
|
||||
Rect::from_min_max(pos2(whole.left(), whole.top() + 30.0), pos2(whole.right(), whole.top() + 48.0))
|
||||
} else {
|
||||
@@ -1854,14 +1996,18 @@ pub fn toolbar(app: &mut SolveApp, ui: &mut egui::Ui) {
|
||||
}
|
||||
for c in cmds {
|
||||
let info = crate::render_workspace::interactive_command_info(app, c);
|
||||
let response = crate::ui_kit::command_menu_button(
|
||||
ui,
|
||||
c.id,
|
||||
info.label,
|
||||
info.icon,
|
||||
&crate::keymap::display_for(app, c.id).unwrap_or_default(),
|
||||
info.enabled,
|
||||
);
|
||||
let shortcut = crate::keymap::display_for(app, c.id).unwrap_or_default();
|
||||
let response = if persistent_command(c.id) && app.preferences.persistent_ribbon_pressed {
|
||||
let mut item = ui_kit::MenuItem::new(c.id, info.label, info.icon);
|
||||
item.shortcut = &shortcut;
|
||||
item.enabled = info.enabled;
|
||||
item.checked = Some(persistent_pressed(app, c.id));
|
||||
item.show(ui)
|
||||
} else {
|
||||
ui_kit::command_menu_button(ui, c.id, info.label, info.icon, &shortcut, info.enabled)
|
||||
};
|
||||
let response =
|
||||
if let Some(hint) = persistent_hint(app, c, info.enabled) { response.on_hover_text(hint) } else { response };
|
||||
crate::scenario::publish_handle(&format!("toolbar:{}", c.id), response.rect.center());
|
||||
if response.clicked() {
|
||||
app.start_at(c.id, Some(response.rect));
|
||||
@@ -1876,6 +2022,10 @@ pub fn toolbar(app: &mut SolveApp, ui: &mut egui::Ui) {
|
||||
});
|
||||
}
|
||||
|
||||
// Resolve persistent paint only after large buttons, dropdowns and overflow have
|
||||
// dispatched their actions. No already-painted old analysis can survive replacement.
|
||||
paint_persistent_ribbon(app, ui, persistent_paints, &tab);
|
||||
|
||||
// Dragging a command: its icon follows the pointer; a toolbar button dragged off the
|
||||
// toolbar (or into the open drop-down) shows it will be removed.
|
||||
let pointer = ui.input(|i| i.pointer.latest_pos());
|
||||
@@ -1959,6 +2109,9 @@ const CONSTRAINT_GRID_WIDTH: f32 = 82.0;
|
||||
/// Registry parameter syntax is not a user-facing description. Reuse existing catalog prose
|
||||
/// where present; other commands intentionally show only their name and registered shortcut.
|
||||
fn ribbon_tooltip(app: &SolveApp, response: egui::Response, command: &solidcraft_engine::CommandSpec, disabled: Option<&str>) -> egui::Response {
|
||||
if let Some(hint) = persistent_hint(app, command, disabled.is_none() && response.enabled() && command.info(&app.session).enabled) {
|
||||
return response.on_hover_text(hint);
|
||||
}
|
||||
response.on_hover_ui(|ui| {
|
||||
let t = Tokens::get();
|
||||
let name = app.tr_label(crate::render_workspace::interactive_command_info(app, command).label);
|
||||
@@ -2133,6 +2286,9 @@ fn dropdown_row(
|
||||
let hot = info.enabled && (pointer_on || resp.has_focus());
|
||||
let mut row = crate::ui_kit::MenuItem::new(c.id, &label, info.icon);
|
||||
row.enabled = info.enabled;
|
||||
if persistent_command(c.id) && app.preferences.persistent_ribbon_pressed {
|
||||
row.checked = Some(persistent_pressed(app, c.id));
|
||||
}
|
||||
if c.id == "view.shots_strip" {
|
||||
row.checked = Some(app.preferences.render_shots_strip);
|
||||
}
|
||||
@@ -2165,9 +2321,13 @@ fn dropdown_row(
|
||||
}
|
||||
// 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 = 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,
|
||||
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 resp.secondary_clicked() {
|
||||
return RowAction::Menu(resp.interact_pointer_pos().unwrap_or(rect.left_bottom()));
|
||||
@@ -4167,3 +4327,375 @@ mod sketch_return_tab_tests {
|
||||
assert_eq!(h.app.ui.tab, "MODEL", "{start}: falls back to MODEL");
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod persistent_ribbon_tests {
|
||||
use super::*;
|
||||
use crate::scenario::{self, Harness};
|
||||
|
||||
fn harness() -> Harness {
|
||||
let mut h = Harness::new();
|
||||
h.app.home.open = false;
|
||||
h.call("ui.resize", json!({"width":2400,"height":1000}));
|
||||
h.app.session.execute("solid.box", &json!({"length":10,"width":10,"height":10})).unwrap();
|
||||
h.app.ui.tab = "INSPECT".into();
|
||||
for id in PERSISTENT_COMMANDS {
|
||||
crate::toolbar_custom::pin(&mut h.app, "INSPECT", id).unwrap();
|
||||
}
|
||||
h.frames(3);
|
||||
h
|
||||
}
|
||||
|
||||
fn shapes(shape: &egui::Shape, out: &mut Vec<egui::Shape>) {
|
||||
match shape {
|
||||
egui::Shape::Vec(v) => {
|
||||
for s in v {
|
||||
shapes(s, out);
|
||||
}
|
||||
}
|
||||
s => out.push(s.clone()),
|
||||
}
|
||||
}
|
||||
|
||||
fn button_shapes(h: &Harness, id: &str) -> Vec<egui::Shape> {
|
||||
let r = scenario::rect_of(&format!("button:{id}")).unwrap();
|
||||
let mut all = Vec::new();
|
||||
for s in &h.shapes {
|
||||
shapes(&s.shape, &mut all);
|
||||
}
|
||||
all.into_iter().filter(|s| r.intersects(s.visual_bounding_rect())).collect()
|
||||
}
|
||||
|
||||
fn assert_paint(h: &Harness, id: &str, selected: bool) {
|
||||
assert_presentation(h, id, selected, true);
|
||||
}
|
||||
|
||||
fn assert_presentation(h: &Harness, id: &str, selected: bool, check_fill: bool) {
|
||||
let r = scenario::rect_of(&format!("button:{id}")).unwrap();
|
||||
let t = Tokens::get();
|
||||
let shapes = button_shapes(h, id);
|
||||
if check_fill {
|
||||
assert_eq!(
|
||||
shapes.iter().any(|s| matches!(s, egui::Shape::Rect(s) if s.rect == r && s.fill == t.selected_bg)),
|
||||
selected,
|
||||
"{id} selected fill"
|
||||
);
|
||||
}
|
||||
assert_eq!(shapes.iter().any(|s| matches!(s, egui::Shape::LineSegment { points, stroke } if stroke.width == 2.0 && stroke.color == t.accent && points[0].y == r.bottom() - t.space_4)), selected, "{id} underline");
|
||||
if h.app.preferences.ribbon_labels {
|
||||
let text = shapes
|
||||
.iter()
|
||||
.find_map(|s| match s {
|
||||
egui::Shape::Text(s) if r.contains(s.pos) => Some(s),
|
||||
_ => None,
|
||||
})
|
||||
.unwrap_or_else(|| panic!("missing {id} label"));
|
||||
let font = &text.galley.job.sections[0].format.font_id;
|
||||
assert_eq!(*font, if selected { crate::fonts::semibold(t.font_body) } else { FontId::proportional(t.font_body) });
|
||||
assert_eq!(text.galley.job.sections[0].format.color, if selected { t.selected_ink } else { t.text });
|
||||
}
|
||||
}
|
||||
|
||||
fn tap(h: &mut Harness, id: &str) {
|
||||
let at = scenario::handle_at(&format!("button:{id}")).unwrap();
|
||||
let before = h.app.session.status_items();
|
||||
h.frame_with(crate::test_support::pointer(at, true));
|
||||
assert_eq!(h.app.session.status_items(), before, "pointer-down is not a persistent activation");
|
||||
for command in PERSISTENT_COMMANDS {
|
||||
// Existing pointer-down paint is transient and may use the same palette fill.
|
||||
// The underline, actual weight and published identities distinguish persistence.
|
||||
assert_presentation(h, command, before.iter().any(|item| item.command == *command), *command != id);
|
||||
assert_eq!(scenario::handle_at(&format!("ribbon:pressed:{command}")).is_some(), before.iter().any(|item| item.command == *command));
|
||||
}
|
||||
h.frame_with(crate::test_support::pointer(at, false));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn persistent_pressed_and_search_pulse_keep_independent_effect_and_paint_authority() {
|
||||
let mut h = harness();
|
||||
for enabled in [true, false] {
|
||||
h.call("ui.prefs", json!({"persistent_ribbon_pressed":enabled,"ribbon_reveal":true}));
|
||||
h.app.sbox.reveal = Some(crate::shortcut_box::Reveal {
|
||||
id: "inspect.zebra",
|
||||
since: h.ctx.input(|input| input.time) - crate::shortcut_box::REVEAL_PULSE / 4.0,
|
||||
preview: false,
|
||||
back: "INSPECT".into(),
|
||||
});
|
||||
h.frame();
|
||||
let zebra = scenario::rect_of("button:inspect.zebra").unwrap();
|
||||
assert_eq!(scenario::rect_of("ribbon:reveal"), Some(zebra));
|
||||
assert!(h.app.session.status_items().is_empty(), "a search pulse does not activate an effect");
|
||||
assert_presentation(&h, "inspect.zebra", false, false);
|
||||
h.app.session.execute("inspect.zebra", &json!({})).unwrap();
|
||||
h.frame();
|
||||
assert_presentation(&h, "inspect.zebra", enabled, enabled);
|
||||
let accent = crate::theme::TabAccent::for_tab(&Tokens::get(), "INSPECT");
|
||||
assert!(button_shapes(&h, "inspect.zebra").iter().any(|shape| matches!(shape, egui::Shape::Rect(rect) if rect.rect == zebra && rect.stroke.width == 2.0 && rect.stroke.color == accent.color.gamma_multiply(h.app.sbox.reveal.as_ref().unwrap().strength(h.ctx.input(|input| input.time), h.ctx.global_style().animation_time > 0.0)))), "the upstream pulse remains painted above the selected background");
|
||||
for (id, active) in [("inspect.draft", true), ("inspect.draft", false)] {
|
||||
let at = scenario::handle_at(&format!("button:{id}")).unwrap();
|
||||
h.frame_with(crate::test_support::pointer(at, true));
|
||||
h.frame_with(crate::test_support::pointer(at, false));
|
||||
assert_presentation(&h, "inspect.zebra", false, false);
|
||||
assert_eq!(h.app.session.status_items().iter().any(|item| item.command == id), active);
|
||||
assert_paint(&h, id, active && enabled);
|
||||
assert_eq!(scenario::rect_of("ribbon:reveal"), Some(zebra));
|
||||
}
|
||||
assert!(h.app.session.status_items().is_empty());
|
||||
h.app.sbox.reveal = None;
|
||||
h.frame();
|
||||
assert!(scenario::rect_of("ribbon:reveal").is_none());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn persistent_commands_derive_all_six_programmatic_effects_and_clear_without_residue() {
|
||||
let mut h = harness();
|
||||
for id in PERSISTENT_COMMANDS {
|
||||
assert!(!persistent_pressed(&h.app, id));
|
||||
h.app.session.execute(id, &json!({})).unwrap();
|
||||
h.frame(); // Exactly the first output following the engine mutation.
|
||||
assert_eq!(h.app.session.status_items().iter().map(|s| s.command.as_str()).collect::<Vec<_>>(), [*id]);
|
||||
for c in PERSISTENT_COMMANDS {
|
||||
assert_paint(&h, c, c == id);
|
||||
}
|
||||
let before = h.app.session.status_items();
|
||||
let revision = h.app.session.revision;
|
||||
h.frame();
|
||||
assert_eq!(h.app.session.status_items(), before);
|
||||
assert_eq!(h.app.session.revision, revision);
|
||||
h.app.session.execute(id, &json!({"clear":true})).unwrap();
|
||||
h.frame();
|
||||
assert_paint(&h, id, false);
|
||||
}
|
||||
for id in ["inspect.minimum_radius", "solid.extrude", "inspect.section"] {
|
||||
assert!(!persistent_command(id));
|
||||
}
|
||||
h.app.session.execute("inspect.zebra", &json!({})).unwrap();
|
||||
let before = h.app.session.status_items();
|
||||
assert!(h.app.session.execute("inspect.draft", &json!({"pull":[0,0,0]})).is_err());
|
||||
h.frame();
|
||||
assert_eq!(h.app.session.status_items(), before);
|
||||
assert_paint(&h, "inspect.zebra", true);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn persistent_replacement_and_toggle_are_correct_in_the_click_release_frame_both_directions() {
|
||||
for labels in [true, false] {
|
||||
let mut h = harness();
|
||||
h.app.preferences.ribbon_labels = labels;
|
||||
crate::toolbar_custom::reorder(&mut h.app, "INSPECT", "inspect.draft", "SURFACE QUALITY", Some("inspect.zebra"));
|
||||
h.frames(2);
|
||||
for id in ["inspect.zebra", "inspect.draft", "inspect.zebra", "inspect.continuity", "inspect.environment_map"] {
|
||||
tap(&mut h, id); // No settling frame after release.
|
||||
assert_eq!(h.app.session.status_items().iter().map(|s| s.command.as_str()).collect::<Vec<_>>(), [id]);
|
||||
for c in PERSISTENT_COMMANDS {
|
||||
assert_paint(&h, c, *c == id);
|
||||
}
|
||||
let c = solidcraft_engine::find_command(id).unwrap();
|
||||
assert_eq!(
|
||||
persistent_hint(&h.app, c, true),
|
||||
Some(format!("Turn off {} · Esc", h.app.tr_label(crate::workspace::ribbon_button_label(c))))
|
||||
);
|
||||
}
|
||||
tap(&mut h, "inspect.environment_map");
|
||||
assert!(h.app.session.status_items().is_empty());
|
||||
assert_paint(&h, "inspect.environment_map", false);
|
||||
tap(&mut h, "inspect.continuity");
|
||||
tap(&mut h, "inspect.continuity");
|
||||
assert!(h.app.session.status_items().is_empty());
|
||||
assert_paint(&h, "inspect.continuity", false);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn persistent_presentation_preference_preserves_old_help_and_legacy_two_effects() {
|
||||
let mut h = harness();
|
||||
h.call("ui.prefs", json!({"single_surface_analysis":false}));
|
||||
h.app.session.execute("inspect.zebra", &json!({})).unwrap();
|
||||
h.app.session.execute("inspect.continuity", &json!({})).unwrap();
|
||||
h.frame();
|
||||
assert_eq!(h.app.session.status_items().len(), 2);
|
||||
assert_paint(&h, "inspect.zebra", true);
|
||||
assert_paint(&h, "inspect.continuity", true);
|
||||
let before = h.app.session.status_items();
|
||||
h.app.preferences.persistent_ribbon_pressed = false;
|
||||
h.frame();
|
||||
for id in PERSISTENT_COMMANDS {
|
||||
assert_paint(&h, id, false);
|
||||
}
|
||||
assert_eq!(h.app.session.status_items(), before);
|
||||
let label = h.app.tr_label(solidcraft_engine::find_command("inspect.zebra").unwrap().info(&h.app.session).label);
|
||||
let old_node = h
|
||||
.output
|
||||
.accesskit_update
|
||||
.as_ref()
|
||||
.and_then(|tree| tree.nodes.iter().find(|(_, n)| n.label() == Some(label)))
|
||||
.map(|(_, n)| n)
|
||||
.expect("old neutral accessible button label");
|
||||
assert_eq!(old_node.toggled(), None, "the old presentation makes no false inactive-effect announcement");
|
||||
assert!(persistent_hint(&h.app, solidcraft_engine::find_command("inspect.zebra").unwrap(), true).is_none());
|
||||
h.app.preferences.persistent_ribbon_pressed = true;
|
||||
h.frame();
|
||||
assert_paint(&h, "inspect.zebra", true);
|
||||
assert_paint(&h, "inspect.continuity", true);
|
||||
h.app.last_command = Some(("inspect.draft".into(), "Draft".into()));
|
||||
h.frame();
|
||||
assert_paint(&h, "inspect.draft", false);
|
||||
assert!(persistent_hint(&h.app, solidcraft_engine::find_command("inspect.zebra").unwrap(), false).is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn persistent_selected_shapes_and_real_semibold_survive_every_colour_vision_mode() {
|
||||
let mut h = harness();
|
||||
h.app.session.execute("inspect.zebra", &json!({})).unwrap();
|
||||
for dark in [false, true] {
|
||||
for vision in ["off", "protan", "deutan", "tritan"] {
|
||||
h.call("ui.prefs", json!({"theme":if dark { "dark" } else { "light" },"color_vision":vision}));
|
||||
h.frame();
|
||||
assert_paint(&h, "inspect.zebra", true);
|
||||
assert_paint(&h, "inspect.curvature_map", false);
|
||||
}
|
||||
}
|
||||
let painter = h.ctx.layer_painter(egui::LayerId::background());
|
||||
let plain = ribbon_button_galley_weight(&painter, "Zebra", 150.0, Tokens::get().text, false);
|
||||
let heavy = ribbon_button_galley_weight(&painter, "Zebra", 150.0, Tokens::get().text, true);
|
||||
assert!((plain.size().x - heavy.size().x).abs() > 0.1, "actual 600-weight face has different glyph metrics");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn persistent_keyboard_focus_uses_native_response_and_clears_with_space() {
|
||||
let mut h = harness();
|
||||
h.app.session.execute("inspect.zebra", &json!({})).unwrap();
|
||||
h.frame();
|
||||
let at = scenario::handle_at("button:inspect.zebra").unwrap();
|
||||
// A pointer press establishes the real existing response's keyboard focus.
|
||||
h.frame_with(crate::test_support::pointer(at, true));
|
||||
h.frame_with(crate::test_support::pointer(at, false));
|
||||
let id = h.ctx.memory(|m| m.focused()).expect("native ribbon response is focusable");
|
||||
assert!(h.app.session.status_items().is_empty());
|
||||
h.ctx.memory_mut(|m| m.request_focus(id));
|
||||
h.frame_with(crate::test_support::key(egui::Key::Space));
|
||||
assert_eq!(h.app.session.status_items().len(), 1);
|
||||
assert_paint(&h, "inspect.zebra", true);
|
||||
assert!(scenario::rect_of("ribbon:focus:inspect.zebra").is_some());
|
||||
let node = h
|
||||
.output
|
||||
.accesskit_update
|
||||
.as_ref()
|
||||
.and_then(|tree| tree.nodes.iter().find(|(_, n)| n.label() == Some("Zebra")))
|
||||
.map(|(_, n)| n)
|
||||
.expect("accessible native Zebra button");
|
||||
assert_eq!(node.role(), egui::accesskit::Role::Button);
|
||||
assert_eq!(node.toggled(), Some(egui::accesskit::Toggled::True));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn persistent_tooltip_is_the_exact_translated_visible_label_and_old_help_is_reachable() {
|
||||
let mut h = harness();
|
||||
h.app.session.execute("inspect.zebra", &json!({})).unwrap();
|
||||
for language in ["en", "de", "ja"] {
|
||||
h.call("ui.prefs", json!({"language":language}));
|
||||
let command = solidcraft_engine::find_command("inspect.zebra").unwrap();
|
||||
let name = h.app.tr_label(crate::workspace::ribbon_button_label(command));
|
||||
let expected = crate::i18n::Locale::for_language(language).format("ui.viewport_status_clear_hint", &[("name", name)]);
|
||||
assert_eq!(persistent_hint(&h.app, command, true), Some(expected.clone()));
|
||||
let at = scenario::handle_at("button:inspect.zebra").unwrap();
|
||||
h.frame_with(vec![egui::Event::PointerMoved(at)]);
|
||||
h.frames(100);
|
||||
let mut all = Vec::new();
|
||||
for shape in &h.shapes {
|
||||
shapes(&shape.shape, &mut all);
|
||||
}
|
||||
assert!(all.iter().any(|s| matches!(s, egui::Shape::Text(t) if t.galley.text() == expected)), "actual tooltip {expected}");
|
||||
}
|
||||
h.app.preferences.persistent_ribbon_pressed = false;
|
||||
h.frame_with(vec![egui::Event::PointerMoved(egui::Pos2::ZERO)]);
|
||||
h.frame_with(vec![egui::Event::PointerMoved(scenario::handle_at("button:inspect.zebra").unwrap())]);
|
||||
h.frames(100);
|
||||
assert!(persistent_hint(&h.app, solidcraft_engine::find_command("inspect.zebra").unwrap(), true).is_none());
|
||||
assert_paint(&h, "inspect.zebra", false);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn persistent_dropdown_clear_keeps_native_pin_and_command_routes() {
|
||||
let mut h = harness();
|
||||
h.app.session.execute("inspect.environment_map", &json!({})).unwrap();
|
||||
h.frame();
|
||||
h.step(&json!({"click":{"handle":"panel:INSPECT:SURFACE QUALITY"}})).unwrap();
|
||||
assert!(scenario::handle_at("dropdown:inspect.environment_map").is_some());
|
||||
h.step(&json!({"click":{"handle":"dropdown:inspect.environment_map"}})).unwrap();
|
||||
assert!(h.app.session.status_items().is_empty());
|
||||
assert_paint(&h, "inspect.environment_map", false);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn persistent_registration_preserves_live_continuity_tool_without_a_status_item() {
|
||||
let mut h = harness();
|
||||
h.app.start("inspect.continuity");
|
||||
assert_eq!(h.app.tool.as_ref().map(|tool| tool.cmd), Some("inspect.continuity"));
|
||||
h.app.session.execute("inspect.continuity", &json!({"clear":true})).unwrap();
|
||||
h.frame();
|
||||
assert!(h.app.session.status_items().is_empty());
|
||||
assert_eq!(scenario::count_of("ribbon:pressed"), Some(0.0));
|
||||
assert_presentation(&h, "inspect.continuity", false, false);
|
||||
let r = scenario::rect_of("button:inspect.continuity").unwrap();
|
||||
let accent = crate::theme::TabAccent::for_tab(&Tokens::get(), "INSPECT");
|
||||
assert!(
|
||||
button_shapes(&h, "inspect.continuity")
|
||||
.iter()
|
||||
.any(|s| matches!(s, egui::Shape::Rect(s) if s.rect == r && s.fill == accent.soft && s.stroke.color == accent.color)),
|
||||
"the real live tool retains its transient indication"
|
||||
);
|
||||
h.app.session.execute("inspect.continuity", &json!({})).unwrap();
|
||||
h.frame();
|
||||
assert_paint(&h, "inspect.continuity", true);
|
||||
// A dialog's last-command fallback must not invent an analysis tool.
|
||||
h.app.tool = None;
|
||||
h.app.start("solid.box");
|
||||
assert!(h.app.dialog.is_some());
|
||||
h.app.ui.tab = "INSPECT".into();
|
||||
h.app.last_command = Some(("inspect.zebra".into(), "Zebra".into()));
|
||||
h.frame();
|
||||
assert_paint(&h, "inspect.zebra", false);
|
||||
let r = scenario::rect_of("button:inspect.zebra").unwrap();
|
||||
assert!(
|
||||
!button_shapes(&h, "inspect.zebra")
|
||||
.iter()
|
||||
.any(|s| matches!(s, egui::Shape::Rect(s) if s.rect == r && s.fill == accent.soft && s.stroke.color == accent.color)),
|
||||
"last_command is not a live analysis tool"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn persistent_click_clear_and_replacement_remove_old_tool_paint_in_the_release_frame() {
|
||||
fn no_tool_paint(h: &Harness) {
|
||||
let r = scenario::rect_of("button:inspect.continuity").unwrap();
|
||||
let accent = crate::theme::TabAccent::for_tab(&Tokens::get(), "INSPECT");
|
||||
assert!(
|
||||
!button_shapes(h, "inspect.continuity")
|
||||
.iter()
|
||||
.any(|s| matches!(s, egui::Shape::Rect(s) if s.rect == r && s.fill == accent.soft && s.stroke.color == accent.color)),
|
||||
"no captured old live-tool fill/border after dispatch"
|
||||
);
|
||||
assert!(scenario::handle_at("ribbon:pressed:inspect.continuity").is_none());
|
||||
assert_paint(h, "inspect.continuity", false);
|
||||
}
|
||||
for labels in [true, false] {
|
||||
let mut h = harness();
|
||||
h.app.preferences.ribbon_labels = labels;
|
||||
crate::toolbar_custom::reorder(&mut h.app, "INSPECT", "inspect.continuity", "SURFACE QUALITY", Some("inspect.environment_map"));
|
||||
h.frames(2);
|
||||
tap(&mut h, "inspect.continuity");
|
||||
assert!(h.app.tool.is_some());
|
||||
tap(&mut h, "inspect.continuity");
|
||||
assert!(h.app.tool.is_none() && h.app.session.status_items().is_empty());
|
||||
no_tool_paint(&h);
|
||||
tap(&mut h, "inspect.continuity");
|
||||
tap(&mut h, "inspect.environment_map");
|
||||
assert!(h.app.tool.is_none());
|
||||
assert_eq!(h.app.session.status_items()[0].command, "inspect.environment_map");
|
||||
no_tool_paint(&h);
|
||||
assert_paint(&h, "inspect.environment_map", true);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -443,6 +443,37 @@ pub enum Button {
|
||||
SmallSelected,
|
||||
}
|
||||
|
||||
/// Selected palette shared by SmallSelected and opt-in persistent native buttons.
|
||||
fn selected_button_palette(t: &Tokens) -> (egui::Color32, egui::Color32) {
|
||||
(t.selected_bg, t.selected_ink)
|
||||
}
|
||||
|
||||
/// Persistent counterpart of SmallSelected at a caller's native rectangle. This opt-in recipe
|
||||
/// leaves existing SmallSelected controls unchanged. Tokens: selected_bg/ink, form_primary,
|
||||
/// accent, radius_sm, space_8. The underline is two logical pixels; focus uses native visuals.
|
||||
pub(crate) fn persistent_button_shape(ui: &Ui, response: &Response, rect: egui::Rect) -> egui::Shape {
|
||||
let t = Tokens::get();
|
||||
let (fill, _) = selected_button_palette(&t);
|
||||
let mut shapes = vec![
|
||||
egui::Shape::rect_filled(rect, t.radius_sm, fill),
|
||||
egui::Shape::rect_stroke(rect, t.radius_sm, egui::Stroke::new(1.0, t.form_primary), egui::StrokeKind::Inside),
|
||||
];
|
||||
let inset = t.space_8.min(rect.width() / 4.0);
|
||||
let y = rect.bottom() - t.space_4;
|
||||
shapes
|
||||
.push(egui::Shape::line_segment([egui::pos2(rect.left() + inset, y), egui::pos2(rect.right() - inset, y)], egui::Stroke::new(2.0, t.accent)));
|
||||
if response.has_focus() {
|
||||
shapes.push(native_button_focus(ui, response, rect));
|
||||
}
|
||||
egui::Shape::Vec(shapes)
|
||||
}
|
||||
|
||||
/// The same standard focused-button outline used by native egui buttons, without resizing.
|
||||
pub(crate) fn native_button_focus(ui: &Ui, response: &Response, rect: egui::Rect) -> egui::Shape {
|
||||
let visuals = ui.style().interact(response);
|
||||
egui::Shape::rect_stroke(rect, Tokens::get().radius_sm, visuals.bg_stroke, egui::StrokeKind::Inside)
|
||||
}
|
||||
|
||||
fn button_widget(label: egui::WidgetText, options: Button) -> egui::Button<'static> {
|
||||
let t = Tokens::get();
|
||||
if t.borders.bevel.is_some() && !matches!(options, Button::Ghost) {
|
||||
@@ -457,7 +488,8 @@ fn button_widget(label: egui::WidgetText, options: Button) -> egui::Button<'stat
|
||||
}
|
||||
Button::Ghost => egui::Button::new(label).frame(false),
|
||||
Button::SmallSelected => {
|
||||
egui::Button::new(label.color(t.selected_ink)).small().fill(t.selected_bg).stroke(egui::Stroke::new(1.0, t.form_primary))
|
||||
let (fill, ink) = selected_button_palette(&t);
|
||||
egui::Button::new(label.color(ink)).small().fill(fill).stroke(egui::Stroke::new(1.0, t.form_primary))
|
||||
}
|
||||
_ => egui::Button::new(label),
|
||||
}
|
||||
|
||||
@@ -263,3 +263,57 @@ fn one_bit_primary_actions_keep_inverted_labels_and_legacy_fills() {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn persistent_native_selected_recipe_is_opt_in_and_preserves_small_selected_controls() {
|
||||
fn flatten(shape: &egui::Shape, out: &mut Vec<egui::Shape>) {
|
||||
match shape {
|
||||
egui::Shape::Vec(shapes) => {
|
||||
for s in shapes {
|
||||
flatten(s, out);
|
||||
}
|
||||
}
|
||||
s => out.push(s.clone()),
|
||||
}
|
||||
}
|
||||
let mut themes: Vec<_> = [false, true]
|
||||
.into_iter()
|
||||
.flat_map(|dark| crate::theme::ColorVision::ALL.into_iter().map(move |vision| crate::theme::Tokens::themed(dark, vision)))
|
||||
.collect();
|
||||
themes.extend(crate::theme_files::builtin().iter().map(crate::theme_files::resolve).filter(|t| t.borders.bevel.is_some()));
|
||||
assert!(themes.iter().any(|t| t.borders.bevel.is_some()), "include a real bevel theme");
|
||||
for t in themes {
|
||||
let _theme = crate::theme::scoped_tokens(t);
|
||||
let ctx = crate::fonts::test_context();
|
||||
let mut selected = egui::Shape::Noop;
|
||||
let mut native = egui::Rect::NOTHING;
|
||||
let mut output = ctx.run_ui(egui::RawInput::default(), |ui| {
|
||||
let response = button(ui, "Existing selected", Button::SmallSelected);
|
||||
native = response.rect;
|
||||
selected = persistent_button_shape(ui, &response, response.rect);
|
||||
});
|
||||
output.textures_delta.clear();
|
||||
let mut shapes = Vec::new();
|
||||
flatten(&selected, &mut shapes);
|
||||
assert!(shapes.iter().any(|s| matches!(s, egui::Shape::Rect(r) if r.rect == native && r.fill == t.selected_bg)));
|
||||
assert!(shapes.iter().any(|s| matches!(s, egui::Shape::LineSegment { stroke, .. } if stroke.width == 2.0 && stroke.color == t.accent)));
|
||||
// Existing SmallSelected keeps its old fill (including the bevel policy), regular
|
||||
// label family and no persistent underline. Merely asking for the opt-in shape
|
||||
// cannot alter that widget or its native geometry.
|
||||
let mut old = Vec::new();
|
||||
for shape in output.shapes {
|
||||
flatten(&shape.shape, &mut old);
|
||||
}
|
||||
let fill = if t.borders.bevel.is_some() { t.control_fill } else { t.selected_bg };
|
||||
assert!(old.iter().any(|s| matches!(s, egui::Shape::Rect(r) if r.rect == native && r.fill == fill)));
|
||||
assert!(!old.iter().any(|s| matches!(s, egui::Shape::LineSegment { stroke, .. } if stroke.width == 2.0 && stroke.color == t.accent)));
|
||||
let text = old
|
||||
.iter()
|
||||
.find_map(|s| match s {
|
||||
egui::Shape::Text(s) if s.galley.text() == "Existing selected" => Some(s),
|
||||
_ => None,
|
||||
})
|
||||
.unwrap();
|
||||
assert_eq!(text.galley.job.sections[0].format.font_id.family, egui::FontFamily::Proportional);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1415,6 +1415,21 @@ const ELEMENTS: &[Element] = &[
|
||||
element!("wide_primary_button", |ui, _| {
|
||||
wide_primary_button(ui, "Finish Sketch");
|
||||
}),
|
||||
element!("persistent_button_shape", "gallery:persistent_button", Some("gallery:persistent_button"), |ui, _| {
|
||||
let t = Tokens::get();
|
||||
let (rect, response) = ui.allocate_exact_size(vec2(t.form_button_height * 3.0, t.form_button_height * 2.0), egui::Sense::click());
|
||||
ui.painter().add(persistent_button_shape(ui, &response, rect));
|
||||
ui.painter().text(rect.center(), egui::Align2::CENTER_CENTER, "Selected", crate::fonts::semibold(t.font_label), t.selected_ink);
|
||||
scenario::publish_target("gallery:persistent_button", rect);
|
||||
}),
|
||||
element!("native_button_focus", "gallery:native_button_focus", Some("gallery:native_button_focus"), |ui, _| {
|
||||
let t = Tokens::get();
|
||||
let (rect, response) = ui.allocate_exact_size(vec2(t.form_button_height * 3.0, t.form_button_height), egui::Sense::click());
|
||||
response.request_focus();
|
||||
ui.painter().rect_filled(rect, t.radius_sm, t.control_fill);
|
||||
ui.painter().add(native_button_focus(ui, &response, rect));
|
||||
scenario::publish_target("gallery:native_button_focus", rect);
|
||||
}),
|
||||
element!("button", "dialog:row:Gallery", Some("dialog:button:Gallery:Add"), |ui, _| {
|
||||
row(ui, "Gallery", |ui| {
|
||||
button(ui, "Add", Button::Normal);
|
||||
|
||||
Reference in New Issue
Block a user