SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Ribbon drop-downs as a grid of large icons, as an option (#4739) (#5012)
Frankf59f6698f1c4
diff --git a/assets/locales/pending/ribbon-icon-grid.json b/assets/locales/pending/ribbon-icon-grid.jsonnew file mode 100644index 0000000000..5359e258fa--- /dev/null+++ b/assets/locales/pending/ribbon-icon-grid.json@@ -0,0 +1,44 @@+{+ "en": {+ "prefs.menu_grid": "Large icons",+ "prefs.menu_list": "List",+ "prefs.menus": "Menus",+ "ui.ribbon_menus_skip_pinned": "Leave pinned commands out of the drop-down menus"+ },+ "de": {+ "prefs.menu_grid": "Große Symbole",+ "prefs.menu_list": "Liste",+ "prefs.menus": "Menüs",+ "ui.ribbon_menus_skip_pinned": "Angeheftete Befehle nicht in den Aufklappmenüs wiederholen"+ },+ "ja": {+ "prefs.menu_grid": "大きなアイコン",+ "prefs.menu_list": "リスト",+ "prefs.menus": "メニュー",+ "ui.ribbon_menus_skip_pinned": "ピン留めしたコマンドをドロップダウンメニューに表示しない"+ },+ "zh": {+ "prefs.menu_grid": "大图标",+ "prefs.menu_list": "列表",+ "prefs.menus": "菜单",+ "ui.ribbon_menus_skip_pinned": "下拉菜单中不再列出已固定的命令"+ },+ "ar": {+ "prefs.menu_grid": "أيقونات كبيرة",+ "prefs.menu_list": "قائمة",+ "prefs.menus": "القوائم",+ "ui.ribbon_menus_skip_pinned": "استبعاد الأوامر المثبتة من القوائم المنسدلة"+ },+ "he": {+ "prefs.menu_grid": "סמלים גדולים",+ "prefs.menu_list": "רשימה",+ "prefs.menus": "תפריטים",+ "ui.ribbon_menus_skip_pinned": "השמטת פקודות מוצמדות מהתפריטים הנפתחים"+ },+ "vi": {+ "prefs.menu_grid": "Biểu tượng lớn",+ "prefs.menu_list": "Danh sách",+ "prefs.menus": "Menu",+ "ui.ribbon_menus_skip_pinned": "Không lặp lại các lệnh đã ghim trong menu thả xuống"+ }+}diff --git a/crates/ui-egui/src/prefs.rs b/crates/ui-egui/src/prefs.rsindex 91846a3d53..62d7b17915 100644--- a/crates/ui-egui/src/prefs.rs+++ b/crates/ui-egui/src/prefs.rs@@ -1077,6 +1077,12 @@ preference_settings! {toast_place: crate::viewport::ToastPlace = Default::default(), PAGE_INTERFACE;/// Toolbar tabs hidden by the person. An empty list keeps every existing tab visible.hidden_toolbar_tabs: Vec<String> = Vec::new(), PAGE_INTERFACE;+ /// Show the ribbon's panel drop-downs as a grid of large icons, their names in the tooltips,+ /// instead of a list of small icons with names (#4739).+ ribbon_icon_grid: bool = false, PAGE_INTERFACE;+ /// Leave the commands the ribbon shows as buttons (pinned ones) out of its panel drop-downs,+ /// which then list only the rest (#4739).+ ribbon_menus_skip_pinned: bool = false, PAGE_INTERFACE => check_tr("ui.ribbon_menus_skip_pinned");/// Interface scale (1 = 100 %).ui_scale: f32 = 1.0, PAGE_INTERFACE, accept(0.5..=2.5);/// Interface font: an installed font family (or a font file), or empty for the built-in one@@ -4961,6 +4967,8 @@ mod tests {("ribbon_reveal", json!(true), PAGE_INTERFACE),("dialog_buttons", json!("top"), PAGE_INTERFACE),("toast_place", json!("centre"), PAGE_INTERFACE),+ ("ribbon_icon_grid", json!(true), PAGE_INTERFACE),+ ("ribbon_menus_skip_pinned", json!(true), PAGE_INTERFACE),("timeline_left", json!(true), PAGE_INTERFACE),("timeline_under_browser", json!(true), PAGE_INTERFACE),("history_sketches", json!("under_feature"), PAGE_INTERFACE),diff --git a/crates/ui-egui/src/prefs/interface.rs b/crates/ui-egui/src/prefs/interface.rsindex c46a48c256..b90208041a 100644--- a/crates/ui-egui/src/prefs/interface.rs+++ b/crates/ui-egui/src/prefs/interface.rs@@ -141,6 +141,14 @@ pub(super) fn interface(app: &mut SolveApp, ui: &mut egui::Ui, t: &Tokens) {crate::scenario::publish_handle(&format!("prefs:toast_place:{key}"), at);}}+ // The ribbon's panel drop-downs: a list, or a grid of large icons (#4739).+ ui_kit::row(ui, app.tr("prefs.menus"), |ui| {+ let mut selected = usize::from(app.preferences.ribbon_icon_grid);+ if ui_kit::segmented(ui, &mut selected, &[app.tr("prefs.menu_list"), app.tr("prefs.menu_grid")], Default::default()) {+ app.preferences.ribbon_icon_grid = selected == 1;+ }+ });+ setting::ribbon_menus_skip_pinned(app, ui);ui_kit::row(ui, app.tr("prefs.history"), |ui| {let mut selected = if app.preferences.history_in_browser {3diff --git a/crates/ui-egui/src/toolbar.rs b/crates/ui-egui/src/toolbar.rsindex eadcd07be4..07c02787d3 100644--- a/crates/ui-egui/src/toolbar.rs+++ b/crates/ui-egui/src/toolbar.rs@@ -1567,6 +1567,10 @@ pub fn toolbar(app: &mut SolveApp, ui: &mut egui::Ui) {let gallery: Vec<_> = shown.iter().copied().filter(|c| app.toolbar_custom.in_gallery(&tab, panel, c.id)).collect();let large: Vec<_> = shown.iter().copied().filter(|c| !gallery.iter().any(|g| g.id == c.id)).collect();let drawn = if collapsed { 0 } else { plan.shown.min(button_widths.len()) };+ // The commands the ribbon shows as buttons now (a narrow window shows fewer), which+ // `ribbon_menus_skip_pinned` leaves out of the drop-down.+ let on_ribbon: Vec<&str> =+ large.iter().take(drawn).map(|c| c.id).chain(gallery.iter().filter(|_| !collapsed && drawn > large.len()).map(|c| c.id)).collect();// Buttons narrower than the panel's minimum width (a one-button panel) are centred.let buttons_width = button_widths.iter().take(drawn).sum::<f32>() + drawn.saturating_sub(1) as f32 * BUTTON_GAP;let inset = if drawn == 0 { 0.0 } else { ((width - 8.0 - buttons_width) / 2.0).max(0.0).floor() };@@ -1895,6 +1899,7 @@ pub fn toolbar(app: &mut SolveApp, ui: &mut egui::Ui) {let previewed = hidden_reveal.is_some_and(|r| r.preview && !open);if open || previewed {let cmds = if collapsed || trimmed { menu_commands(&cmds, &shown) } else { cmds.clone() };+ let cmds = if app.preferences.ribbon_menus_skip_pinned { skip_on_ribbon(cmds, &on_ribbon) } else { cmds };let area = Container::new(ui.ctx(), Surface::Popup).area(popup_id).fixed_pos(lr.left_bottom())@@ -1908,15 +1913,25 @@ pub fn toolbar(app: &mut SolveApp, ui: &mut egui::Ui) {} else if cmds.is_empty() {ui.label(egui::RichText::new(crate::i18n::tr_label("Not available yet")).color(t.text_dim));}+ if sketch_create && app.preferences.ribbon_icon_grid && !cmds.is_empty() {+ let action = dropdown_grid(app, ui, &tab, &sketch_create_grouped(&cmds), &[]);+ grid_action(app, ui, action, &mut menu, &mut toggle);+ return;+ }if sketch_create {// One width for every row and the footer, as in the other panels.let row_w = dropdown_width(app, ui, &cmds);ui.set_width(row_w);sketch_create_menu(app, ui, &cmds, row_w, &mut menu, &mut toggle);- section_footer(ui);+ section_footer(ui, "ui.ribbon_pin_footer");return;}let grouped = crate::workspace::grouped_commands(&tab, panel, &cmds);+ if app.preferences.ribbon_icon_grid && !grouped.is_empty() {+ let action = dropdown_grid(app, ui, &tab, &grouped, &crate::workspace::ungrouped(&tab, panel, &cmds));+ grid_action(app, ui, action, &mut menu, &mut toggle);+ return;+ }let cmds: Vec<_> = grouped.iter().map(|(_, c)| *c).collect();let row_w = dropdown_width(app, ui, &cmds);ui.set_width(row_w);@@ -1963,7 +1978,7 @@ pub fn toolbar(app: &mut SolveApp, ui: &mut egui::Ui) {}}});- section_footer(ui);+ section_footer(ui, "ui.ribbon_pin_footer");});});popup_rect = Some(area.response.rect);@@ -2206,26 +2221,31 @@ fn reveal_tooltip(app: &SolveApp, ui: &egui::Ui, rect: Rect, command: &solidcraf}}+/// A group heading inside a panel drop-down (Edges, Faces…; Line, Rectangle…), in the list and+/// the grid: a step below the drop-down's own header (`font_caption`) and written as named, not+/// in capitals, so it reads as part of the menu rather than above it.+fn group_heading_font() -> FontId {+ crate::fonts::semibold(Tokens::get().font_micro)+}++/// A group heading's text: its name in the interface language, as written.+fn group_heading_text(label: &str) -> String {+ crate::i18n::tr_label(label).to_string()+}+fn section_heading(ui: &mut egui::Ui, label: &str, width: f32) {let t = Tokens::get();let (rect, _) = ui.allocate_exact_size(vec2(width, 24.0), Sense::hover());- ui.painter().text(- rect.left_center() + vec2(6.0, 0.0),- Align2::LEFT_CENTER,- crate::i18n::tr_label(label).to_uppercase(),- crate::fonts::semibold(crate::theme::Tokens::get().font_small),- t.text_dim,- );+ ui.painter().text(rect.left_center() + vec2(6.0, 0.0), Align2::LEFT_CENTER, group_heading_text(label), group_heading_font(), t.text_dim);}-fn section_footer(ui: &mut egui::Ui) {+/// The note under a panel drop-down on how pinning works: `message` is its catalog id.+fn section_footer(ui: &mut egui::Ui, message: &str) {ui.separator();ui.add_space(4.0);ui.add(- egui::Label::new(- egui::RichText::new(crate::i18n::tr("ui.ribbon_pin_footer")).size(crate::theme::Tokens::get().font_small).color(Tokens::get().text_dim),- )- .wrap(),+ egui::Label::new(egui::RichText::new(crate::i18n::tr(message)).size(crate::theme::Tokens::get().font_small).color(Tokens::get().text_dim))+ .wrap(),);ui.add_space(4.0);}@@ -2338,6 +2358,360 @@ fn dropdown_row(RowAction::None}+/// Take up what was done in a grid drop-down, as for a list row: start the command (and close+/// the drop-down), open its menu, or pin or unpin it.+fn grid_action(+ app: &mut SolveApp,+ ui: &egui::Ui,+ action: Option<(&'static str, RowAction)>,+ menu: &mut Option<(egui::Pos2, &'static str)>,+ toggle: &mut Option<&'static str>,+) {+ match action {+ Some((id, RowAction::Menu(at))) => *menu = Some((at, id)),+ Some((id, RowAction::TogglePin)) => *toggle = Some(id),+ Some((id, RowAction::Start(rect))) => {+ app.start_at(id, Some(rect));+ ui.ctx().data_mut(|d| d.remove::<egui::Id>(egui::Id::new("sc_panel_open")));+ }+ Some((_, RowAction::None)) | None => {}+ }+}++/// Sketch › Create in the grid: each family of variants under its own heading (Line, Rectangle,+/// Circle…), then the other tools under "More". The list keeps its family sub-menus.+fn sketch_create_grouped(cmds: &[&'static solidcraft_engine::CommandSpec]) -> Vec<(Option<&'static str>, &'static solidcraft_engine::CommandSpec)> {+ let mut out = Vec::new();+ for f in crate::sketch_families::FAMILIES {+ let mut heading = Some(f.label);+ for id in f.commands {+ if let Some(c) = cmds.iter().find(|c| c.id == *id) {+ out.push((heading.take(), *c));+ }+ }+ }+ let mut heading = Some("More");+ for c in cmds.iter().filter(|c| crate::sketch_families::family(c.id).is_none()) {+ out.push((heading.take(), *c));+ }+ out+}++/// A drop-down's commands without those the ribbon shows as buttons (`ribbon_menus_skip_pinned`),+/// unless that leaves none.+fn skip_on_ribbon(cmds: Vec<&'static solidcraft_engine::CommandSpec>, on_ribbon: &[&str]) -> Vec<&'static solidcraft_engine::CommandSpec> {+ let rest: Vec<_> = cmds.iter().copied().filter(|c| !on_ribbon.contains(&c.id)).collect();+ if rest.is_empty() { cmds } else { rest }+}++/// A grid drop-down's cell (#4739): the icon twice the size of a list row's, with room around it.+const GRID_CELL: f32 = 48.0;+const GRID_ICON: f32 = 32.0;+/// Columns a grid fills before a second row; a panel with fewer commands is as wide as it needs.+const GRID_COLUMNS: usize = 5;+/// Rows at most: a bigger menu grows to the right instead (unless the window is too narrow).+const GRID_ROWS: usize = 3;++/// The height of a group's heading in a grid drop-down.+const GRID_HEADING: f32 = 24.0;+/// Icons side by side in a group's column, when groups stand side by side.+const GROUP_COLUMNS: usize = 2;++/// Where a grid drop-down puts things, relative to its top left: each command's icon with its+/// (row, column) for the arrow keys, each group heading (where, how wide), the separators+/// between groups side by side (their x), and the whole size.+struct GridLayout {+ cells: Vec<(Rect, (usize, usize))>,+ headings: Vec<(egui::Pos2, f32, &'static str)>,+ separators: Vec<f32>,+ size: egui::Vec2,+}++/// Lay out a grid drop-down, at most [`GRID_ROWS`] high, growing to the right. A menu of two or+/// more headed groups (Sketch › Create's families, Model › Modify's Edges, Faces…) puts the+/// groups side by side, each heading over a column of its icons, [`GROUP_COLUMNS`] across (more+/// for a group too big for three rows), when that fits in `room` (wide). Any other menu, or one+/// too wide for the window, fills rows: [`GRID_COLUMNS`] across, more when that would take over+/// three rows, fewer when the window is narrower; a heading starts a new row. `loose` names the+/// commands in no group (Model › Modify's Delete): they stand apart after the groups, without a+/// heading, so they stay put when a group is left out (`ribbon_menus_skip_pinned`).+fn grid_layout(grouped: &[(Option<&'static str>, &'static solidcraft_engine::CommandSpec)], loose: &[&str], room: f32) -> GridLayout {+ let mut groups: Vec<(Option<&'static str>, Vec<usize>)> = Vec::new();+ for (i, (heading, c)) in grouped.iter().enumerate() {+ let after_a_group = groups.last().is_some_and(|(h, _)| h.is_some());+ if heading.is_some() || groups.is_empty() || (after_a_group && loose.contains(&c.id)) {+ groups.push((*heading, Vec::new()));+ }+ if let Some((_, items)) = groups.last_mut() {+ items.push(i);+ }+ }+ // A heading needs two icons' width; loose commands only as many columns as they fill.+ let group_columns = |heading: Option<&str>, n: usize| n.div_ceil(GRID_ROWS).max(if heading.is_some() { GROUP_COLUMNS } else { 1 });+ let headed = groups.iter().filter(|(h, _)| h.is_some()).count();+ let side_columns: usize = groups.iter().map(|(h, items)| group_columns(*h, items.len())).sum();+ let side_by_side = headed >= 2 && side_columns as f32 * GRID_CELL <= room;+ let mut cells = vec![(Rect::NOTHING, (0, 0)); grouped.len()];+ let mut headings = Vec::new();+ let mut separators = Vec::new();+ let cell = |x: f32, y: f32| Rect::from_min_size(pos2(x, y), vec2(GRID_CELL, GRID_CELL));+ let size = if side_by_side {+ let (mut first_column, mut rows) = (0, 0);+ for (g, (heading, items)) in groups.iter().enumerate() {+ let columns = group_columns(*heading, items.len());+ let x = first_column as f32 * GRID_CELL;+ if g > 0 {+ separators.push(x);+ }+ if let Some(h) = heading {+ headings.push((pos2(x, 0.0), columns as f32 * GRID_CELL, *h));+ }+ for (k, i) in items.iter().enumerate() {+ let (row, column) = (k / columns, k % columns);+ if let Some(slot) = cells.get_mut(*i) {+ *slot = (cell(x + column as f32 * GRID_CELL, GRID_HEADING + row as f32 * GRID_CELL), (row, first_column + column));+ }+ }+ rows = rows.max(items.len().div_ceil(columns));+ first_column += columns;+ }+ vec2(first_column as f32 * GRID_CELL, GRID_HEADING + rows as f32 * GRID_CELL)+ } else {+ let n = grouped.len();+ let fit = ((room / GRID_CELL).floor() as usize).max(1);+ let columns = n.div_ceil(GRID_ROWS).max(n.min(GRID_COLUMNS)).min(fit).max(1);+ let (mut y, mut first_row) = (0.0, 0);+ for (heading, items) in &groups {+ if let Some(h) = heading {+ headings.push((pos2(0.0, y), columns as f32 * GRID_CELL, *h));+ y += GRID_HEADING;+ }+ for (k, i) in items.iter().enumerate() {+ let (row, column) = (k / columns, k % columns);+ if let Some(slot) = cells.get_mut(*i) {+ *slot = (cell(column as f32 * GRID_CELL, y + row as f32 * GRID_CELL), (first_row + row, column));+ }+ }+ let rows = items.len().div_ceil(columns);+ y += rows as f32 * GRID_CELL;+ first_row += rows;+ }+ vec2(columns as f32 * GRID_CELL, y)+ };+ GridLayout { cells, headings, separators, size }+}++/// An arrow key in a grid drop-down.+#[derive(Clone, Copy, PartialEq, Eq, Debug)]+enum GridKey {+ Left,+ Right,+ Up,+ Down,+}++/// Where an arrow key moves the focus in a grid drop-down, as an index into `enabled` (the+/// enabled commands, as indices into `cells`): Left and Right step through them in order, Up and+/// Down to the nearest one in the row above or below, all wrapping. From none focused, Right+/// and Down go to the first, Left and Up to the last.+fn grid_step(cells: &[(usize, usize)], enabled: &[usize], at: Option<usize>, key: GridKey) -> Option<usize> {+ let n = enabled.len();+ if n == 0 {+ return None;+ }+ let Some(at) = at.filter(|at| *at < n) else {+ return Some(if matches!(key, GridKey::Right | GridKey::Down) { 0 } else { n - 1 });+ };+ let cell = |k: usize| enabled.get(k).and_then(|i| cells.get(*i)).copied();+ match key {+ GridKey::Right => Some((at + 1) % n),+ GridKey::Left => Some((at + n - 1) % n),+ GridKey::Up | GridKey::Down => {+ let (row, column) = cell(at)?;+ let rows: Vec<usize> = (0..n).filter_map(|k| cell(k).map(|c| c.0)).collect();+ let target = if key == GridKey::Down {+ rows.iter().copied().filter(|r| *r > row).min().or_else(|| rows.iter().copied().min())+ } else {+ rows.iter().copied().filter(|r| *r < row).max().or_else(|| rows.iter().copied().max())+ }?;+ (0..n)+ .filter_map(|k| cell(k).filter(|c| c.0 == target).map(|c| (k, c.1.abs_diff(column))))+ .min_by_key(|(_, distance)| *distance)+ .map(|(k, _)| k)+ }+ }+}++/// Arrow keys move the keyboard focus through a grid drop-down's enabled icons ([`grid_step`]).+fn grid_keys(app: &SolveApp, ui: &egui::Ui, cmds: &[&'static solidcraft_engine::CommandSpec], cells: &[(usize, usize)]) {+ let key = ui.input(|i| {+ [+ (egui::Key::ArrowLeft, GridKey::Left),+ (egui::Key::ArrowRight, GridKey::Right),+ (egui::Key::ArrowUp, GridKey::Up),+ (egui::Key::ArrowDown, GridKey::Down),+ ]+ .into_iter()+ .find(|(k, _)| i.key_pressed(*k))+ .map(|(_, key)| key)+ });+ let Some(key) = key else { return };+ let enabled: Vec<usize> = cmds.iter().enumerate().filter(|(_, c)| c.info(&app.session).enabled).map(|(i, _)| i).collect();+ let focused = ui.ctx().memory(|m| m.focused());+ let at = enabled.iter().position(|i| cmds.get(*i).is_some_and(|c| focused == Some(dropdown_row_id(c.id))));+ if let Some(c) = grid_step(cells, &enabled, at, key).and_then(|k| enabled.get(k)).and_then(|i| cmds.get(*i)) {+ ui.ctx().memory_mut(|m| {+ m.request_focus(dropdown_row_id(c.id));+ m.move_focus(egui::FocusDirection::None);+ });+ }+}++/// A panel drop-down drawn as a grid of large icons (the `ribbon_icon_grid` preference, #4739):+/// the same commands, headings and actions as the list, the names in the tooltips. Returns the+/// command acted on, and how.+fn dropdown_grid(+ app: &SolveApp,+ ui: &mut egui::Ui,+ tab: &str,+ grouped: &[(Option<&'static str>, &'static solidcraft_engine::CommandSpec)],+ loose: &[&str],+) -> Option<(&'static str, RowAction)> {+ // Wide enough for groups side by side, short of the window's edge.+ let room = ui.ctx().content_rect().right() - ui.cursor().left() - 24.0;+ let layout = grid_layout(grouped, loose, room);+ let width = layout.size.x.max(200.0);+ // A narrow grid sits in the middle of the drop-down's least width.+ let inset = ((width - layout.size.x) / 2.0).max(0.0);+ ui.set_width(width);+ let cmds: Vec<_> = grouped.iter().map(|(_, c)| *c).collect();+ let keys: Vec<(usize, usize)> = layout.cells.iter().map(|(_, at)| *at).collect();+ grid_keys(app, ui, &cmds, &keys);+ // Like the list, the grid scrolls when it would run past the window's bottom (#874).+ let height = (ui.ctx().content_rect().bottom() - ui.cursor().top() - 64.0).max(GRID_CELL * 2.0);+ let mut action = None;+ egui::ScrollArea::vertical().id_salt("panel_menu_grid").max_height(height).min_scrolled_height(height).show(ui, |ui| {+ let (area, _) = ui.allocate_exact_size(vec2(width, layout.size.y), Sense::hover());+ let origin = area.left_top() + vec2(inset, 0.0);+ let t = Tokens::get();+ for (at, w, heading) in &layout.headings {+ let text = group_heading_text(heading);+ let clip = ui.clip_rect().intersect(Rect::from_min_size(origin + at.to_vec2(), vec2(*w, GRID_HEADING)));+ let painter = ui.painter().with_clip_rect(clip);+ // Centred over its group's icons.+ painter.text(origin + at.to_vec2() + vec2(w / 2.0, GRID_HEADING / 2.0), Align2::CENTER_CENTER, text, group_heading_font(), t.text_dim);+ }+ // A line between groups side by side, as between the ribbon's sections.+ for x in &layout.separators {+ let x = origin.x + x;+ ui.painter().line_segment([pos2(x, origin.y + 4.0), pos2(x, origin.y + layout.size.y - 4.0)], Stroke::new(1.0, t.border));+ }+ for ((_, c), (rect, _)) in grouped.iter().zip(&layout.cells) {+ let rect = rect.translate(origin.to_vec2());+ let pinned = crate::toolbar_custom::pinned_on(app, tab, c.id).is_some();+ match dropdown_cell(app, ui, c, rect, pinned) {+ RowAction::None => {}+ done => action = Some((c.id, done)),+ }+ }+ });+ action+}++/// How long the pointer rests on a grid icon before its corner pin can be clicked (seconds).+const PIN_DELAY: f64 = 2.0;++/// Whether the corner pin of grid icon `id` takes clicks: the pointer (`on`) has rested on the+/// icon for [`PIN_DELAY`]. One icon is timed at a time; the window redraws when the pin is due.+fn pin_armed(ui: &egui::Ui, id: &'static str, on: bool) -> bool {+ let key = egui::Id::new("sc_grid_pin_hover");+ let now = ui.input(|i| i.time);+ let since = ui.ctx().data_mut(|d| {+ let rest = d.get_temp::<(&'static str, f64)>(key).filter(|(at, _)| *at == id);+ match (on, rest) {+ (true, Some((_, since))) => Some(since),+ (true, None) => {+ d.insert_temp(key, (id, now));+ Some(now)+ }+ (false, Some(_)) => {+ d.remove::<(&'static str, f64)>(key);+ None+ }+ (false, None) => None,+ }+ });+ let Some(since) = since else { return false };+ let left = PIN_DELAY - (now - since);+ if left > 0.0 {+ ui.ctx().request_repaint_after(std::time::Duration::from_secs_f64(left));+ }+ left <= 0.0+}++/// One icon of a grid drop-down: clicked, dragged onto the ribbon (to pin it) or right-clicked+/// like a list row; its tooltip is a ribbon button's (name, shortcut, help, why it is off), and a+/// pin in its corner says it is on the ribbon.+fn dropdown_cell(app: &SolveApp, ui: &mut egui::Ui, c: &'static solidcraft_engine::CommandSpec, rect: Rect, pinned: bool) -> RowAction {+ let t = Tokens::get();+ let info = c.info(&app.session);+ let sense = if info.enabled { Sense::click_and_drag() } else { Sense::drag() };+ let resp = ui.interact(rect, dropdown_row_id(c.id), sense);+ if resp.has_focus() && !ui.clip_rect().contains_rect(rect) {+ resp.scroll_to_me_animation(None, egui::style::ScrollAnimation::none());+ }+ if resp.drag_started() {+ resp.dnd_set_drag_payload(ToolbarDrag { id: c.id, from_menu: true });+ }+ // The pin in the corner, as at a list row's end. It takes clicks (above the cell) only once+ // the pointer has rested on the icon for PIN_DELAY: until then a click anywhere starts the+ // command, so a quick click near the corner never pins or unpins it by accident.+ let pr = Rect::from_min_size(pos2(rect.right() - 15.0, rect.top()), vec2(15.0, 15.0));+ let dragging = egui::DragAndDrop::has_any_payload(ui.ctx());+ let armed = pin_armed(ui, c.id, ui.rect_contains_pointer(rect) && !dragging);+ let pin = armed.then(|| ui.interact(pr, ui.id().with(("dropdown_pin", c.id)), Sense::click()));+ let pin_hovered = pin.as_ref().is_some_and(egui::Response::hovered);+ let label = app.tr_label(c.label).to_string();+ resp.widget_info(|| egui::WidgetInfo::labeled(egui::WidgetType::Button, ui.is_enabled() && info.enabled, &label));+ crate::scenario::publish_handle(&format!("toolbar:{}", c.id), rect.center());+ crate::scenario::publish_handle(&format!("dropdown:{}", c.id), rect.center());+ let pointer_on = (resp.hovered() || pin_hovered) && !dragging;+ let hot = info.enabled && (pointer_on || resp.has_focus());+ let painter = ui.painter().with_clip_rect(ui.clip_rect().intersect(rect));+ let cell = rect.shrink(2.0);+ if hot {+ painter.rect_filled(cell, t.control_radius, t.accent_soft);+ crate::scenario::publish_handle(&format!("dropdown_hot:{}", c.id), rect.center());+ }+ if resp.has_focus() {+ painter.rect_stroke(cell, t.control_radius, Stroke::new(1.0, t.accent), egui::StrokeKind::Inside);+ }+ icons::paint_icon(&painter, Rect::from_center_size(rect.center(), vec2(GRID_ICON, GRID_ICON)), c.icon, if info.enabled { 1.0 } else { 0.4 });+ // A pinned command always shows its pin, clear of the icon's own artwork; any other shows one+ // to pin it once it can be clicked.+ if pinned || armed {+ if pin_hovered {+ painter.rect_filled(pr, 3.0, t.border.gamma_multiply(0.6));+ }+ pin_icon(&painter, pr.shrink(2.5), pinned, if pinned { t.accent } else { t.text_dim });+ }+ if let Some(pin) = pin {+ crate::scenario::publish_handle(&format!("dropdown_pin:{}", c.id), pr.center());+ let tip = if pinned { "Remove from Toolbar" } else { "Pin to Toolbar" };+ if pin.on_hover_text(crate::i18n::tr_label(tip)).clicked() {+ return RowAction::TogglePin;+ }+ }+ let resp = ribbon_tooltip(app, resp, c, info.disabled_reason.as_deref());+ if resp.secondary_clicked() {+ return RowAction::Menu(resp.interact_pointer_pos().unwrap_or(rect.left_bottom()));+ }+ if resp.clicked() && info.enabled {+ return RowAction::Start(rect);+ }+ RowAction::None+}+/// Creation menus keep related variants together, including collapsed and overflow panels./// The plain rows are `width` wide, the width the menu gives its family rows.fn sketch_create_menu(@@ -3659,6 +4033,341 @@ mod dropdown_tests {assert!(menu.contains(*at), "{id} at {at:?} is cut off by the drop-down {menu:?}");}}++ /// The grid's rows: a heading starts a new one, and the arrow keys move along and between+ /// them over the enabled icons only, wrapping at the ends (#4739).+ #[test]+ fn grid_rows_break_at_headings_and_arrow_keys_skip_disabled_icons() {+ let c = |id| solidcraft_engine::find_command(id).unwrap();+ let grouped = [+ (Some("Primitives"), c("solid.box")),+ (None, c("solid.cylinder")),+ (None, c("solid.sphere")),+ (None, c("solid.torus")),+ (None, c("solid.pipe")),+ (Some("Other"), c("solid.extrude")),+ (None, c("solid.revolve")),+ ];+ // Too narrow for the groups side by side (two icons wide): rows as wide as the window, a+ // heading starting a row.+ let rows = grid_layout(&grouped, &[], 100.0);+ let at = |l: &GridLayout| l.cells.iter().map(|(_, at)| *at).collect::<Vec<_>>();+ assert_eq!(at(&rows), [(0, 0), (0, 1), (1, 0), (1, 1), (2, 0), (3, 0), (3, 1)]);+ assert_eq!(rows.headings.len(), 2);+ // Room enough: each group a column of two under its heading, the groups side by side.+ let side = grid_layout(&grouped, &[], 1000.0);+ assert_eq!(at(&side), [(0, 0), (0, 1), (1, 0), (1, 1), (2, 0), (0, 2), (0, 3)]);+ let headings: Vec<_> = side.headings.iter().map(|(p, _, h)| (p.x, *h)).collect();+ assert_eq!(headings, [(0.0, "Primitives"), (2.0 * GRID_CELL, "Other")]);+ assert_eq!(side.size, vec2(4.0 * GRID_CELL, GRID_HEADING + 3.0 * GRID_CELL));+ assert_eq!(side.separators, [2.0 * GRID_CELL], "a line between the two groups");+ assert!(rows.separators.is_empty(), "rows have none");+ assert!(side.cells.iter().all(|(r, _)| r.top() >= GRID_HEADING), "icons below the headings");+ // A menu without groups keeps its rows of five.+ let plain: Vec<_> = grouped.iter().map(|(_, c)| (None, *c)).collect();+ assert_eq!(at(&grid_layout(&plain, &[], 1000.0)), [(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (1, 0), (1, 1)]);+ let cells = at(&side);+ // `solid.pipe` (index 4) is disabled: `enabled` holds the others.+ let enabled = [0, 1, 2, 3, 5, 6];+ let step = |at, key| grid_step(&cells, &enabled, at, key).map(|k: usize| enabled[k]);+ assert_eq!((step(None, GridKey::Right), step(None, GridKey::Down)), (Some(0), Some(0)));+ assert_eq!((step(None, GridKey::Left), step(None, GridKey::Up)), (Some(6), Some(6)));+ assert_eq!(step(Some(2), GridKey::Right), Some(3), "Right runs on into the next row");+ assert_eq!(step(Some(0), GridKey::Left), Some(6), "and wraps");+ assert_eq!(step(Some(1), GridKey::Down), Some(3), "Down goes to the nearest enabled icon below");+ assert_eq!(step(Some(4), GridKey::Down), Some(3), "from the next group's column too");+ assert_eq!(step(Some(2), GridKey::Down), Some(0), "from the last enabled row Down wraps to the first");+ assert_eq!(step(Some(5), GridKey::Up), Some(3), "from the first row Up wraps to the last, nearest column");+ assert_eq!(step(Some(1), GridKey::Up), Some(3));+ assert_eq!(grid_step(&cells, &[], None, GridKey::Down), None);+ }++ /// A command in no group (Model › Modify's Delete) stands apart after the groups, without a+ /// heading: leaving out a pinned group (Specialise's Convert to Sheet Metal) must not move it+ /// under the group before (Bodies) (#4739).+ #[test]+ fn a_command_in_no_group_stays_apart_when_a_group_is_left_out() {+ let specs = solidcraft_engine::command_specs();+ let (cmds, _) = crate::workspace::layout("MODEL", "MODIFY", &specs).unwrap();+ let loose = crate::workspace::ungrouped("MODEL", "MODIFY", &cmds);+ assert_eq!(loose, ["timeline.delete"]);+ let column_of = |cmds: &[&'static solidcraft_engine::CommandSpec], id: &str| {+ let grouped = crate::workspace::grouped_commands("MODEL", "MODIFY", cmds);+ let layout = grid_layout(&grouped, &loose, 4000.0);+ let x = |id: &str| grouped.iter().position(|(_, c)| c.id == id).and_then(|i| layout.cells.get(i)).map(|(r, _)| r.left());+ let last_group = layout.separators.last().copied();+ (x(id), last_group)+ };+ let (delete, separator) = column_of(&cmds, "timeline.delete");+ assert_eq!(delete, separator, "Delete in a column of its own after Specialise");+ let skipped = skip_on_ribbon(cmds.clone(), &["sheet.convert"]);+ let (delete, separator) = column_of(&skipped, "timeline.delete");+ let (remove, _) = column_of(&skipped, "solid.remove");+ assert_eq!(delete, separator, "still apart without Specialise");+ assert!(delete > remove, "not under Bodies: {delete:?} vs {remove:?}");+ }++ /// Group headings sit below the drop-down's own header in the hierarchy: a smaller font than+ /// the header's, and written as named rather than in capitals (list and grid alike).+ #[test]+ fn group_headings_are_smaller_than_the_drop_down_header() {+ let t = Tokens::get();+ assert!(group_heading_font().size < t.font_caption, "{} vs the header's {}", group_heading_font().size, t.font_caption);+ assert_eq!(group_heading_text("Edges"), "Edges", "written as named, not in capitals");+ }++ /// Every panel's drop-down of every tab, and Sketch › Create's families, is at most+ /// GRID_ROWS high in the grid when the window is wide enough: big menus grow to the right.+ #[test]+ fn every_grid_menu_is_at_most_three_rows_high() {+ let rows = |l: &GridLayout| l.cells.iter().map(|(r, _)| r.top().round() as i32).collect::<std::collections::BTreeSet<_>>().len();+ let tabs: std::collections::BTreeSet<&str> = crate::workspace::SECTIONS.iter().map(|s| s.tab).collect();+ for tab in tabs {+ for (panel, cmds, _) in crate::toolbar_custom::panel_lists(tab) {+ let grouped = crate::workspace::grouped_commands(tab, panel, &cmds);+ let layout = grid_layout(&grouped, &crate::workspace::ungrouped(tab, panel, &cmds), 4000.0);+ assert!(rows(&layout) <= GRID_ROWS, "{tab} {panel}: {} rows", rows(&layout));+ if tab == "SKETCH" && panel == "CREATE" {+ let families = grid_layout(&sketch_create_grouped(&cmds), &[], 4000.0);+ assert!(rows(&families) <= GRID_ROWS, "Sketch › Create families: {} rows", rows(&families));+ }+ }+ }+ // A window too narrow for the width wraps into more rows instead of running off it.+ let c = |id| solidcraft_engine::find_command(id).unwrap();+ let many: Vec<_> = solidcraft_engine::command_specs().into_iter().take(30).map(|c| (None, c)).collect();+ let narrow = grid_layout(&many, &[], 4.0 * GRID_CELL);+ assert!(narrow.size.x <= 4.0 * GRID_CELL && rows(&narrow) > GRID_ROWS);+ let few = [(None, c("solid.box")), (None, c("solid.sphere"))];+ assert_eq!(grid_layout(&few, &[], 4000.0).size, vec2(2.0 * GRID_CELL, GRID_CELL), "a small menu is one row");+ }++ /// With `ribbon_icon_grid` on, a panel's drop-down shows the same commands as its list, as+ /// large icons in rows of at most five; arrow keys move across and down; a click starts the+ /// command, and a drag pins it, as from the list (#4739).+ #[test]+ fn the_icon_grid_shows_the_lists_commands_and_acts_like_it() {+ let mut h = crate::scenario::Harness::new();+ h.app.home.open = false;+ h.call("ui.resize", json!({"width":1600,"height":1000}));+ let open = |h: &mut crate::scenario::Harness| {+ h.frames(4);+ h.step(&json!({"click":{"handle":"panel:MODEL:CREATE"}})).unwrap();+ h.frames(6);+ let menu = crate::scenario::rect_of("toolbar_dropdown").expect("the drop-down is open");+ (menu, crate::scenario::handles("dropdown:"))+ };+ let (_, list) = open(&mut h);+ h.step(&json!({"key":"Escape"})).unwrap();+ assert!(!h.app.preferences.ribbon_icon_grid, "the list stays the default");+ h.call("ui.prefs", json!({"ribbon_icon_grid": true}));+ assert!(h.app.preferences.ribbon_icon_grid);+ let (menu, grid) = open(&mut h);+ let ids = |rows: &[(String, egui::Pos2)]| rows.iter().map(|(id, _)| id.clone()).collect::<Vec<_>>();+ assert_eq!(ids(&grid), ids(&list), "the grid shows the list's commands in its order");+ assert!(grid.len() > GRID_COLUMNS * GRID_ROWS, "MODEL CREATE is a big menu: {grid:?}");+ for (id, at) in &grid {+ assert!(menu.contains(*at), "{id} at {at:?} is outside the drop-down {menu:?}");+ }+ let ys: std::collections::BTreeSet<i32> = grid.iter().map(|(_, at)| at.y.round() as i32).collect();+ assert_eq!(ys.len(), GRID_ROWS, "laid out in {GRID_ROWS} rows, growing to the right: {ys:?}");+ let columns = grid.len().div_ceil(GRID_ROWS);+ assert!(menu.width() <= columns as f32 * GRID_CELL + 40.0, "no wider than its columns: {menu:?}");++ let hot = |h: &mut crate::scenario::Harness, key: &str| {+ h.step(&json!({"key": key})).unwrap();+ h.frames(3);+ let hot = crate::scenario::handles("dropdown_hot:");+ let [(_, at)] = hot.as_slice() else { panic!("one highlighted icon after {key}: {hot:?}") };+ *at+ };+ let first = hot(&mut h, "ArrowRight");+ let second = hot(&mut h, "ArrowRight");+ assert!(second.x > first.x && (second.y - first.y).abs() < 1.0, "Right moves along the row: {first:?} → {second:?}");+ let below = hot(&mut h, "ArrowDown");+ assert!(below.y > second.y, "Down moves to the row below: {second:?} → {below:?}");++ h.step(&json!({"click":{"handle":"dropdown:solid.box"}})).unwrap();+ h.frames(3);+ assert!(crate::scenario::rect_of("toolbar_dropdown").is_none(), "a click closes the drop-down");+ assert!(h.app.dialog.is_some() || h.app.tool.is_some(), "and starts the command");+ h.step(&json!({"key":"Escape"})).unwrap();+ h.frames(3);++ open(&mut h);+ let label = crate::scenario::handle_at("panel:MODEL:CREATE").unwrap();+ h.step(&json!({"drag":[{"handle":"dropdown:solid.cylinder"}, [label.x, label.y]],"steps":12})).unwrap();+ h.step(&json!({"key":"Escape"})).unwrap();+ assert!(crate::toolbar_custom::pinned_on(&h.app, "MODEL", "solid.cylinder").is_some(), "dragged onto the ribbon, it is pinned");+ assert!(h.app.session.doc.features.is_empty(), "pinning does not run the command");+ }++ /// A right-click on a drop-down's command, in the list and in the grid, opens its menu:+ /// Pin to Toolbar, Remove from Toolbar and Pin to Shortcuts act on that command.+ #[test]+ fn a_right_click_in_the_drop_down_pins_and_unpins() {+ for grid in [false, true] {+ let mut h = crate::scenario::Harness::new();+ h.app.home.open = false;+ h.call("ui.resize", json!({"width":1600,"height":1000}));+ h.app.preferences.ribbon_icon_grid = grid;+ let pick = |h: &mut crate::scenario::Harness, item: &str| {+ h.frames(4);+ h.step(&json!({"click":{"handle":"panel:MODEL:CREATE"}})).unwrap();+ h.frames(4);+ h.step(&json!({"click":{"handle":"dropdown:solid.box"},"button":"right"})).unwrap();+ h.frames(4);+ assert!(h.app.viewport.context_menu.is_some(), "grid {grid}: the right-click opens the command's menu");+ h.step(&json!({"widget": item})).unwrap_or_else(|e| panic!("grid {grid}: {item}: {e}"));+ h.frames(4);+ };+ pick(&mut h, "Pin to Toolbar");+ assert!(crate::toolbar_custom::pinned_on(&h.app, "MODEL", "solid.box").is_some(), "grid {grid}: pinned");+ pick(&mut h, "Remove from Toolbar");+ assert!(crate::toolbar_custom::pinned_on(&h.app, "MODEL", "solid.box").is_none(), "grid {grid}: unpinned");+ pick(&mut h, "Pin to Shortcuts");+ assert!(h.app.sbox.pinned.iter().any(|p| p == "solid.box"), "grid {grid}: a shortcut");+ // The pin shown on the pointed-at row or icon pins it, and again unpins it. A grid+ // icon's pin takes clicks only after the pointer has rested on it for PIN_DELAY.+ for pinned in [true, false] {+ h.step(&json!({"click":{"handle":"panel:MODEL:CREATE"}})).unwrap();+ h.frames(4);+ h.step(&json!({"move":{"handle":"dropdown:solid.box"}})).unwrap();+ h.frames(3);+ if grid {+ assert!(crate::scenario::handle_at("dropdown_pin:solid.box").is_none(), "no pin to click straight away");+ h.frames((PIN_DELAY * 60.0) as usize + 5);+ }+ h.step(&json!({"click":{"handle":"dropdown_pin:solid.box"}})).unwrap();+ h.frames(3);+ h.step(&json!({"key":"Escape"})).unwrap();+ assert_eq!(crate::toolbar_custom::pinned_on(&h.app, "MODEL", "solid.box").is_some(), pinned, "grid {grid}: the hover pin");+ }+ assert!(h.app.session.doc.features.is_empty(), "grid {grid}: pinning does not run the command");+ }+ }++ /// A quick click on a grid icon's corner, where its pin appears after PIN_DELAY, starts the+ /// command instead of pinning it.+ #[test]+ fn a_quick_click_on_the_pin_corner_starts_the_command() {+ let mut h = crate::scenario::Harness::new();+ h.app.home.open = false;+ h.call("ui.resize", json!({"width":1600,"height":1000}));+ h.app.preferences.ribbon_icon_grid = true;+ h.frames(4);+ h.step(&json!({"click":{"handle":"panel:MODEL:CREATE"}})).unwrap();+ h.frames(4);+ let at = crate::scenario::handle_at("dropdown:solid.box").unwrap() + vec2(GRID_CELL / 2.0 - 7.0, -GRID_CELL / 2.0 + 7.0);+ h.step(&json!({"click":[at.x, at.y]})).unwrap();+ h.frames(3);+ assert!(crate::toolbar_custom::pinned_on(&h.app, "MODEL", "solid.box").is_none(), "not pinned");+ assert!(h.app.dialog.is_some() || h.app.tool.is_some(), "the command starts");+ }++ /// A command pinned from the grid becomes a ribbon button; Remove from Toolbar in the+ /// button's own right-click menu takes it off again, with both options on.+ #[test]+ fn a_pinned_button_is_removed_from_its_own_menu() {+ for mode in [crate::shell::LayoutMode::Floating, crate::shell::LayoutMode::Docked] {+ a_pinned_button_is_removed_in(mode);+ }+ }++ fn a_pinned_button_is_removed_in(mode: crate::shell::LayoutMode) {+ let mut h = crate::scenario::Harness::new();+ h.app.home.open = false;+ h.call("ui.set", json!({"layout":mode}));+ h.call("ui.resize", json!({"width":1600,"height":1000}));+ h.app.preferences.ribbon_icon_grid = true;+ h.app.preferences.ribbon_menus_skip_pinned = true;+ h.frames(4);+ h.step(&json!({"click":{"handle":"panel:MODEL:CREATE"}})).unwrap();+ h.frames(4);+ h.step(&json!({"move":{"handle":"dropdown:solid.loft"}})).unwrap();+ h.frames((PIN_DELAY * 60.0) as usize + 5);+ h.step(&json!({"click":{"handle":"dropdown_pin:solid.loft"}})).unwrap();+ h.frames(3);+ h.step(&json!({"key":"Escape"})).unwrap();+ h.frames(4);+ assert!(crate::scenario::handle_at("button:solid.loft").is_some(), "pinned, Loft is a ribbon button");+ h.step(&json!({"click":{"handle":"button:solid.loft"},"button":"right"})).unwrap();+ h.frames(4);+ assert!(h.app.viewport.context_menu.is_some(), "the button's menu opens");+ h.step(&json!({"widget":"Remove from Toolbar"})).unwrap();+ h.frames(4);+ assert!(crate::toolbar_custom::pinned_on(&h.app, "MODEL", "solid.loft").is_none(), "removed: {:?}", h.app.toolbar_custom.panels);+ assert!(crate::scenario::handle_at("button:solid.loft").is_none(), "and gone from the ribbon");+ }++ /// Sketch › Create in the grid shows every variant of each family (Line, Rectangle, …) under+ /// the family's heading, then the other tools, as large icons; a click starts the tool.+ #[test]+ fn sketch_create_in_the_grid_shows_every_variant() {+ let mut h = crate::scenario::Harness::new();+ h.app.home.open = false;+ h.call("ui.resize", json!({"width":1600,"height":1000}));+ h.app.preferences.ribbon_icon_grid = true;+ h.app.run("sketch.create", json!({"plane":"XY"})).unwrap();+ h.frames(4);+ h.step(&json!({"click":{"handle":"panel:SKETCH:CREATE"}})).unwrap();+ h.frames(4);+ let cells: Vec<String> = crate::scenario::handles("dropdown:").into_iter().map(|(id, _)| id).collect();+ for id in ["sketch.line", "sketch.rectangle.center", "sketch.circle.three_point", "sketch.arc.tangent", "sketch.polygon.edge", "sketch.point"]+ {+ assert!(cells.iter().any(|c| *c == format!("dropdown:{id}")), "{id} is an icon of the grid: {cells:?}");+ }+ let grouped = sketch_create_grouped(+ &solidcraft_engine::command_specs().into_iter().filter(|c| c.id.starts_with("sketch.rectangle")).collect::<Vec<_>>(),+ );+ assert_eq!(grouped.first().and_then(|(h, _)| *h), Some("Rectangle"));+ assert!(grouped.iter().skip(1).all(|(h, _)| h.is_none()), "one heading per family");+ h.step(&json!({"click":{"handle":"dropdown:sketch.rectangle.center"}})).unwrap();+ h.frames(3);+ assert!(crate::scenario::rect_of("toolbar_dropdown").is_none(), "a click closes the drop-down");+ assert_eq!(h.app.tool.as_ref().map(|t| t.cmd), Some("sketch.rectangle.center"), "and starts the tool");+ }++ /// With `ribbon_menus_skip_pinned`, a drop-down leaves out the commands the ribbon shows as+ /// buttons, in the list and in the grid; a panel too narrow for its buttons lists them again.+ #[test]+ fn pinned_commands_can_be_left_out_of_the_drop_down() {+ for grid in [false, true] {+ let mut h = crate::scenario::Harness::new();+ h.app.home.open = false;+ h.call("ui.resize", json!({"width":1600,"height":1000}));+ h.app.preferences.ribbon_icon_grid = grid;+ let rows = |h: &mut crate::scenario::Harness, panel: &str| {+ h.frames(4);+ h.step(&json!({"click":{"handle":panel}})).unwrap();+ h.frames(4);+ let rows: Vec<String> = crate::scenario::handles("dropdown:").into_iter().map(|(id, _)| id).collect();+ h.step(&json!({"key":"Escape"})).unwrap();+ rows+ };+ let all = rows(&mut h, "panel:MODEL:CREATE");+ assert!(all.iter().any(|id| id == "dropdown:solid.extrude"), "grid {grid}: listed by default: {all:?}");+ h.call("ui.prefs", json!({"ribbon_menus_skip_pinned": true}));+ let rest = rows(&mut h, "panel:MODEL:CREATE");+ for pinned in ["solid.extrude", "solid.revolve", "solid.hole"] {+ assert!(!rest.iter().any(|id| *id == format!("dropdown:{pinned}")), "grid {grid}: {pinned} is on the ribbon: {rest:?}");+ }+ assert_eq!(rest.len() + 3, all.len(), "grid {grid}: only the ribbon's buttons are left out");+ // In a window too narrow for the Extrude button, MODEL CREATE's menu lists it again.+ let narrow = (3..=16).rev().map(|w| w as f32 * 100.0).find(|w| {+ h.call("ui.resize", json!({"width": w, "height": 1000}));+ h.frames(4);+ crate::scenario::handle_at("button:solid.extrude").is_none()+ });+ assert!(narrow.is_some(), "grid {grid}: a narrow window has no room for the Extrude button");+ let panel = ["panel:MODEL:CREATE", "collapsed:MODEL:CREATE"].into_iter().find(|p| crate::scenario::handle_at(p).is_some());+ let Some(panel) = panel else { panic!("grid {grid}: MODEL CREATE is in the » menu at {narrow:?}") };+ let folded = rows(&mut h, panel);+ assert!(folded.iter().any(|id| id == "dropdown:solid.extrude"), "grid {grid}: Extrude, off the ribbon, is listed: {folded:?}");+ }+ let box_ = solidcraft_engine::find_command("solid.box").unwrap();+ assert_eq!(skip_on_ribbon(vec![box_], &["solid.box"]).len(), 1, "a drop-down is never left empty");+ }}#[cfg(test)]diff --git a/crates/ui-egui/src/workspace.rs b/crates/ui-egui/src/workspace.rsindex 0834fe1228..610b1e3bb3 100644--- a/crates/ui-egui/src/workspace.rs+++ b/crates/ui-egui/src/workspace.rs@@ -81,6 +81,13 @@ pub fn grouped_commands<'a>(tab: &str, panel: &str, commands: &[&'a CommandSpec]out}+/// The ids of a panel's commands that are in none of its groups: [`grouped_commands`] puts them+/// last, without a heading.+pub fn ungrouped(tab: &str, panel: &str, commands: &[&CommandSpec]) -> Vec<&'static str> {+ let groups = groups(tab, panel);+ commands.iter().map(|c| c.id).filter(|id| !groups.iter().any(|g| g.ids.contains(id))).collect()+}+pub struct Section {pub tab: &'static str,pub panel: &'static str,diff --git a/docs/book/src/guide/ui-tour.md b/docs/book/src/guide/ui-tour.mdindex fd16d16ef7..ae07f200e5 100644--- a/docs/book/src/guide/ui-tour.md+++ b/docs/book/src/guide/ui-tour.md@@ -189,6 +189,17 @@ it sits on the left or under the browser and is wide enough for names. They arerows: the same eyes, folds and right-click menus, so one list is enough for single-part work. TheHistory at the bottom is unchanged.+Interface › **Menus** › **Large icons** (the default is **List**) shows a section's+command menu as rows of large icons instead of a list of names. Point at an icon for its name,+shortcut and help; the arrow keys move across and between rows. Rest the pointer on an icon for+two seconds and a pin in its corner can be clicked to pin it to the ribbon or remove it (a+quicker click anywhere on the icon starts the command). Right-clicking the icon, or dragging it+onto the ribbon, also pins it; a pinned command always shows its pin.++Interface › **Leave pinned commands out of the drop-down menus** (off by default) lists in a+section's menu only the commands that are not already buttons on the ribbon. When the window is+too narrow for a section's buttons, its menu lists them again.+### Colour themesInterface › **Theme** lists Dark, Light and System (follows the operating system), the built-in