diff --git a/assets/locales/pending/persistent-ribbon-pressed.json b/assets/locales/pending/persistent-ribbon-pressed.json new file mode 100644 index 000000000..03e38be90 --- /dev/null +++ b/assets/locales/pending/persistent-ribbon-pressed.json @@ -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": "在效果启用时突出显示相应的功能区命令。关闭此选项可保留原来的中性外观和命令帮助。" + } +} diff --git a/crates/ui-egui/src/prefs.rs b/crates/ui-egui/src/prefs.rs index 1c597511e..91846a3d5 100644 --- a/crates/ui-egui/src/prefs.rs +++ b/crates/ui-egui/src/prefs.rs @@ -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); diff --git a/crates/ui-egui/src/prefs/interface.rs b/crates/ui-egui/src/prefs/interface.rs index 6a98c12f3..c46a48c25 100644 --- a/crates/ui-egui/src/prefs/interface.rs +++ b/crates/ui-egui/src/prefs/interface.rs @@ -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")); diff --git a/crates/ui-egui/src/scenario.rs b/crates/ui-egui/src/scenario.rs index 16f9897a9..ada0605f4 100644 --- a/crates/ui-egui/src/scenario.rs +++ b/crates/ui-egui/src/scenario.rs @@ -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, diff --git a/crates/ui-egui/src/toolbar.rs b/crates/ui-egui/src/toolbar.rs index e39d502e7..eadcd07be 100644 --- a/crates/ui-egui/src/toolbar.rs +++ b/crates/ui-egui/src/toolbar.rs @@ -986,11 +986,117 @@ fn ribbon_label_lines(painter: &egui::Painter, label: &str, width: f32) -> Vec 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 { + (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, + enabled: bool, + disabled: Option, +} + +fn paint_persistent_ribbon(app: &SolveApp, ui: &egui::Ui, paints: Vec, 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 { + 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 { 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) { + 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 { + 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::>(), [*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::>(), [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); + } + } +} diff --git a/crates/ui-egui/src/ui_kit/actions.rs b/crates/ui-egui/src/ui_kit/actions.rs index df3a4bf4f..898d94c1f 100644 --- a/crates/ui-egui/src/ui_kit/actions.rs +++ b/crates/ui-egui/src/ui_kit/actions.rs @@ -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), } diff --git a/crates/ui-egui/src/ui_kit/actions_tests.rs b/crates/ui-egui/src/ui_kit/actions_tests.rs index 9fb9f2bb1..e3c60a8a7 100644 --- a/crates/ui-egui/src/ui_kit/actions_tests.rs +++ b/crates/ui-egui/src/ui_kit/actions_tests.rs @@ -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) { + 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); + } +} diff --git a/crates/ui-egui/src/ui_kit/gallery.rs b/crates/ui-egui/src/ui_kit/gallery.rs index cec9f2f07..9d29ec8d2 100644 --- a/crates/ui-egui/src/ui_kit/gallery.rs +++ b/crates/ui-egui/src/ui_kit/gallery.rs @@ -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);