diff --git a/crates/ui-egui/locales/en.toml b/crates/ui-egui/locales/en.toml index f8c75bfa6..55d8cbe63 100644 --- a/crates/ui-egui/locales/en.toml +++ b/crates/ui-egui/locales/en.toml @@ -534,6 +534,9 @@ name = "English" "Edit padding on all sides" = "Edit padding on all sides" "Edit style" = "Edit style" "Edit variable" = "Edit variable" +"Edit variables" = "Edit variables" +"Scope" = "Scope" +"No scope is shared by all the selected variables" = "No scope is shared by all the selected variables" "Edit with the builder" = "Edit with the builder" "Edited {when}" = "Edited {when}" "Effect settings" = "Effect settings" diff --git a/crates/ui-egui/src/a11y.rs b/crates/ui-egui/src/a11y.rs index 502452765..d0e34d6fe 100644 --- a/crates/ui-egui/src/a11y.rs +++ b/crates/ui-egui/src/a11y.rs @@ -883,9 +883,17 @@ pub fn tab(resp: &Response, label: &str, selected: bool) { } pub fn checkbox(resp: &Response, label: &str, on: bool) { + checkbox_tri(resp, label, Some(on)); +} + +/// A checkbox that can be mixed (`None`, announced as "mixed" rather than unchecked). +pub fn checkbox_tri(resp: &Response, label: &str, state: Option) { node(resp, label, |n| { n.set_role(Role::CheckBox); - n.set_toggled(toggled(on)); + n.set_toggled(match state { + Some(on) => toggled(on), + None => Toggled::Mixed, + }); }); } diff --git a/crates/ui-egui/src/a11y_tests.rs b/crates/ui-egui/src/a11y_tests.rs index 14be637dd..941f5854b 100644 --- a/crates/ui-egui/src/a11y_tests.rs +++ b/crates/ui-egui/src/a11y_tests.rs @@ -431,3 +431,80 @@ fn the_custom_panel_edges_never_enter_the_keyboard_or_focus_order() { } assert!(!seen.contains(&left) && !seen.contains(&right), "Tab never stops on a panel edge: {seen:?}"); } + +#[test] +fn a_mixed_checkbox_is_announced_as_mixed_and_a_checked_one_as_true() { + let ctx = egui::Context::default(); + ctx.enable_accesskit(); + let mut out = ctx.run_ui(egui::RawInput::default(), |ui| { + crate::widgets::checkbox_tri(ui, None, "Mixed one"); + crate::widgets::checkbox_tri(ui, Some(true), "Checked one"); + crate::widgets::checkbox_tri(ui, Some(false), "Plain one"); + }); + out.textures_delta.clear(); + let nodes: Vec = out.platform_output.accesskit_update.expect("an AccessKit update").nodes.into_iter().map(|(_, n)| n).collect(); + assert_eq!(find(&nodes, Role::CheckBox, "Mixed one").toggled(), Some(Toggled::Mixed)); + assert_eq!(find(&nodes, Role::CheckBox, "Checked one").toggled(), Some(Toggled::True)); + assert_eq!(find(&nodes, Role::CheckBox, "Plain one").toggled(), Some(Toggled::False)); +} + +/// Runs one headless frame of a lone tri-state checkbox; returns whether it was clicked. +fn tri_frame(ctx: &egui::Context, state: Option, events: Vec) -> bool { + let mut clicked = false; + let input = egui::RawInput { events, ..Default::default() }; + let mut out = ctx.run_ui(input, |ui| { + clicked = crate::widgets::checkbox_tri(ui, state, "Keyed one"); + }); + out.textures_delta.clear(); + clicked +} + +fn key(key: Key, pressed: bool) -> Event { + Event::Key { key, physical_key: None, pressed, repeat: false, modifiers: Modifiers::NONE } +} + +#[test] +fn a_checkbox_is_keyboard_operable_tab_to_it_then_space_or_enter_toggles_it() { + for activate in [Key::Space, Key::Enter] { + let ctx = egui::Context::default(); + tri_frame(&ctx, Some(false), vec![]); + tri_frame(&ctx, Some(false), vec![key(Key::Tab, true), key(Key::Tab, false)]); + assert!(ctx.memory(|m| m.focused()).is_some(), "Tab focuses the checkbox"); + tri_frame(&ctx, Some(false), vec![]); + let clicked = tri_frame(&ctx, Some(false), vec![key(activate, true), key(activate, false)]); + assert!(clicked, "{activate:?} on the focused checkbox toggles it"); + } +} + +/// The marks (paths, meshes, segments) painted inside the 14-point box of a lone checkbox. +fn box_marks(state: Option) -> Vec { + fn walk(s: &egui::Shape, out: &mut Vec) { + match s { + egui::Shape::Vec(v) => v.iter().for_each(|s| walk(s, out)), + egui::Shape::Path(_) | egui::Shape::Mesh(_) | egui::Shape::LineSegment { .. } => out.push(s.visual_bounding_rect()), + _ => {} + } + } + let ctx = egui::Context::default(); + let mut out = Vec::new(); + for _ in 0..2 { + let mut o = ctx.run_ui(egui::RawInput::default(), |ui| { + crate::widgets::checkbox_tri(ui, state, "Painted one"); + }); + o.textures_delta.clear(); + out.clear(); + o.shapes.iter().for_each(|c| walk(&c.shape, &mut out)); + } + out +} + +#[test] +fn a_mixed_checkbox_paints_a_dash_and_a_checked_one_a_tick() { + // Icon::Minus is one flat bar; Icon::Check is a taller path. + let mixed = box_marks(None); + assert!(mixed.iter().any(|r| r.width() >= 5.0 && r.height() <= 2.5), "a flat dash is painted for the mixed state: {mixed:?}"); + let checked = box_marks(Some(true)); + assert!(checked.iter().any(|r| r.width() >= 5.0 && r.height() > 3.5), "a tick is painted for the checked state: {checked:?}"); + assert!(!checked.iter().any(|r| r.width() >= 5.0 && r.height() <= 2.5), "no dash on a checked box: {checked:?}"); + assert!(box_marks(Some(false)).is_empty(), "an empty box paints no mark"); +} diff --git a/crates/ui-egui/src/dialogs/variables_panel.rs b/crates/ui-egui/src/dialogs/variables_panel.rs index a2a421052..4367ac610 100644 --- a/crates/ui-egui/src/dialogs/variables_panel.rs +++ b/crates/ui-egui/src/dialogs/variables_panel.rs @@ -59,6 +59,10 @@ pub struct Editor { pub(crate) anchor: Option, /// The variable ids the table shows now, in row order (the range a Shift+click covers). pub(crate) order: Vec, + /// The variables the compact "Edit variables" editor is open on (empty = closed). + bulk_edit: Vec, + /// That editor's tab: 0 Details, 1 Scope. + bulk_tab: usize, } /// A click on row `id`: plain selects only it, Shift extends from the anchor to it through the @@ -113,8 +117,13 @@ fn bulk_run(app: &mut FigApp, label: &str, vars: &[&Variable], step: impl Fn(&Va /// The context menu of a row that is part of a selection of several: delete, move to a group and /// scope act on all of them. -fn bulk_menu(app: &mut FigApp, ui: &mut Ui, coll_groups: &[String], vars: &[&Variable]) { +fn bulk_menu(app: &mut FigApp, ui: &mut Ui, st: &mut Editor, coll_groups: &[String], vars: &[&Variable]) { let n = vars.len(); + if menu_item(ui, tr("Edit variables"), "") { + st.bulk_edit = vars.iter().map(|v| v.id.clone()).collect(); + st.bulk_tab = 0; + ui.close(); + } if menu_item(ui, &trn("Delete {n} variables", n, &[]), "") { bulk_run(app, "Delete variables", vars, |v| Some(("variable.delete", json!({"variable": v.id})))); ui.close(); @@ -277,6 +286,7 @@ pub fn show(app: &mut FigApp, ctx: &Context) { }); }); details(app, ctx, &doc.variables, &mut st); + bulk_details(app, ctx, &doc.variables, &mut st); app.ui.variables = open.then_some(st); } @@ -848,7 +858,7 @@ fn var_row(app: &mut FigApp, ui: &mut Ui, view: &View, coll: &Collection, v: &Va crate::right::context_popup(&resp).show(|ui| { if let Some(vars) = bulk_ids(view, st, v) { let coll_groups = groups(view.in_collection(&coll.id).map(|x| x.name.as_str())); - bulk_menu(app, ui, &coll_groups, &vars); + bulk_menu(app, ui, st, &coll_groups, &vars); return; } if menu_item(ui, tr("Edit variable"), "") { @@ -1178,9 +1188,115 @@ fn details(app: &mut FigApp, ctx: &Context, vars: &Variables, st: &mut Editor) { } } +/// Whether `f` holds for every variable (Some(true)), for none (Some(false)) or only some (None). +/// With no variables nothing is on: Some(false), never a checked box for an empty list. +fn tri(vars: &[&T], f: impl Fn(&T) -> bool) -> Option { + if vars.is_empty() { + return Some(false); + } + let on = vars.iter().filter(|v| f(v)).count(); + if on == vars.len() { + Some(true) + } else if on == 0 { + Some(false) + } else { + None + } +} + +/// The compact editor of several selected variables: Details (only Hide from publishing) and Scope +/// (the scopes every selected variable's type has), each box mixed where the selection differs; a +/// click sets or clears it on all of them in one undo step. +fn bulk_details(app: &mut FigApp, ctx: &Context, vars: &Variables, st: &mut Editor) { + if st.bulk_edit.is_empty() { + return; + } + let list: Vec<&Variable> = st.bulk_edit.iter().filter_map(|id| vars.get_by_id(id)).filter(|v| v.extends.is_none()).collect(); + // The menu offers Edit variables only for two or more editable, non-inherited variables of a + // file collection (`bulk_ids`), so this closes only when they have since gone (deleted, + // undone) or a library was opened: there is nothing left to edit. + if list.is_empty() || st.library.is_some() { + st.bulk_edit.clear(); + return; + } + let t = Tokens::get(ctx); + let mut open = true; + egui::Window::new(tr("Edit variables")) + .id(Id::unique("variables_bulk_details")) + .open(&mut open) + .collapsible(false) + .resizable(false) + .default_width(280.0) + .frame(egui::Frame::window(&ctx.global_style()).fill(t.panel).inner_margin(egui::Margin::same(16))) + .show(ctx, |ui| { + ui.set_width(260.0); + if let Some(i) = widgets::segmented_text(ui, &[tr("Details"), tr("Scope")], st.bulk_tab) { + st.bulk_tab = i; + } + ui.add_space(8.0); + if st.bulk_tab == 0 { + let hidden = tri(&list, |v| v.hidden_from_publishing); + if widgets::checkbox_tri(ui, hidden, tr("Hide from publishing")) { + let to = hidden != Some(true); + bulk_run(app, "Edit variables", &list, |v| Some(("variable.update", json!({"variable": v.id, "hiddenFromPublishing": to})))); + } + return; + } + // The scopes every selected variable's type has. + let first = list.first().map_or(&[][..], |v| scopes_for(v.kind)); + let common: Vec<(&'static str, &'static str)> = + first.iter().filter(|(id, _)| list.iter().all(|v| scopes_for(v.kind).iter().any(|(k, _)| k == id))).copied().collect(); + if common.is_empty() { + widgets::label(ui, tr("No scope is shared by all the selected variables"), t.text_secondary); + return; + } + let all = tri(&list, |v| v.scopes.is_none()); + if widgets::checkbox_tri(ui, all, tr("All supported properties")) { + let to_all = all != Some(true); + bulk_run(app, "Edit variables", &list, |v| { + Some(("variable.update", json!({"variable": v.id, "scopes": if to_all { Value::Null } else { json!([]) }}))) + }); + } + for (sid, label) in common { + let state = tri(&list, |v| v.in_scope(sid)); + let clicked = ui + .horizontal(|ui| { + ui.add_space(16.0); + widgets::checkbox_tri(ui, state, tr(label)) + }) + .inner; + if clicked { + let to = state != Some(true); + bulk_run(app, "Edit variables", &list, |v| { + let next: Vec<&str> = + scopes_for(v.kind).iter().map(|(id, _)| *id).filter(|id| if *id == sid { to } else { v.in_scope(id) }).collect(); + Some(("variable.update", json!({"variable": v.id, "scopes": next}))) + }); + } + } + }); + if !open { + st.bulk_edit.clear(); + } +} + #[cfg(test)] mod tests { - use super::groups; + use super::{groups, tri}; + + #[test] + fn tri_is_checked_empty_or_mixed() { + let (a, b) = (true, false); + assert_eq!(tri(&[&a, &a], |v| *v), Some(true)); + assert_eq!(tri(&[&b, &b], |v| *v), Some(false)); + assert_eq!(tri(&[&a, &b], |v| *v), None); + } + + #[test] + fn tri_of_no_variables_is_not_checked() { + let none: [&bool; 0] = []; + assert_eq!(tri(&none, |v| *v), Some(false)); + } #[test] fn groups_include_parents_once_and_sorted() { diff --git a/crates/ui-egui/src/variables_select_tests.rs b/crates/ui-egui/src/variables_select_tests.rs index b391df326..1ae91bd57 100644 --- a/crates/ui-egui/src/variables_select_tests.rs +++ b/crates/ui-egui/src/variables_select_tests.rs @@ -250,3 +250,175 @@ fn the_bulk_menu_scrolls_when_forty_groups_make_it_taller_than_the_window() { assert!(visible(&shapes), "scrolling the menu never brought {last:?} into view"); assert!(screen.contains_rect(popup_rect(&u))); } + +/// Three colour variables: bravo and charlie also have Stroke in their scopes, delta does not. +fn colour_window() -> Ui { + let mut s = Session::new(); + s.execute("variable.createCollection", &json!({"name": "Theme"})).unwrap(); + for (n, scopes) in + [("bravo", json!(["FRAME_FILL", "STROKE_COLOR"])), ("charlie", json!(["FRAME_FILL", "STROKE_COLOR"])), ("delta", json!(["FRAME_FILL"]))] + { + s.execute("variable.create", &json!({"collection": "Theme", "name": n, "type": "color", "value": "#ff0000"})).unwrap(); + s.execute("variable.update", &json!({"variable": n, "scopes": scopes})).unwrap(); + } + let mut u = Ui::new(s); + u.app.ui.variables = Some(Default::default()); + for _ in 0..10 { + u.frame(vec![]); + } + u +} + +fn open_edit_variables(u: &mut Ui) -> Vec { + let menu = select_three_and_open_menu(u); + assert!(has_text(&menu, "Edit variables"), "the bulk menu offers Edit variables"); + click(u, text_center(&menu, "Edit variables"), PointerButton::Primary, Modifiers::NONE); + flat(&u.frame_output(vec![]).shapes) +} + +fn flags(u: &Ui) -> Vec<(bool, bool)> { + let doc = u.app.session.doc().unwrap(); + ["bravo", "charlie", "delta"] + .iter() + .map(|n| { + let v = doc.variables.variables.iter().find(|v| v.name == *n).unwrap(); + (v.hidden_from_publishing, v.in_scope("STROKE_COLOR")) + }) + .collect() +} + +#[test] +fn edit_variables_sets_stroke_on_all_selected_in_one_undo_step() { + let mut u = colour_window(); + let shapes = open_edit_variables(&mut u); + assert!(has_text(&shapes, "Hide from publishing") && has_text(&shapes, "Scope")); + click(&mut u, text_center(&shapes, "Scope"), PointerButton::Primary, Modifiers::NONE); + let shapes = flat(&u.frame_output(vec![]).shapes); + assert!(has_text(&shapes, "Stroke")); + assert_eq!(flags(&u), [(false, true), (false, true), (false, false)]); + let before = u.app.session.undo_labels(100).len(); + click(&mut u, text_center(&shapes, "Stroke"), PointerButton::Primary, Modifiers::NONE); + assert!(u.app.ui.last_error.is_none(), "{:?}", u.app.ui.last_error); + assert_eq!(flags(&u), [(false, true), (false, true), (false, true)]); + assert_eq!(u.app.session.undo_labels(100).len(), before + 1, "one undo step"); + u.app.session.undo().unwrap(); + assert_eq!(flags(&u), [(false, true), (false, true), (false, false)]); +} + +#[test] +fn edit_variables_hides_all_selected_from_publishing_in_one_undo_step() { + let mut u = colour_window(); + let shapes = open_edit_variables(&mut u); + let before = u.app.session.undo_labels(100).len(); + click(&mut u, text_center(&shapes, "Hide from publishing"), PointerButton::Primary, Modifiers::NONE); + assert!(u.app.ui.last_error.is_none(), "{:?}", u.app.ui.last_error); + assert!(flags(&u).iter().all(|f| f.0), "all hidden"); + assert_eq!(u.app.session.undo_labels(100).len(), before + 1, "one undo step"); + u.app.session.undo().unwrap(); + assert!(flags(&u).iter().all(|f| !f.0)); +} + +/// Bravo, charlie and delta of the given types (a value fitting each). +fn typed_window(types: [&str; 3]) -> Ui { + let mut s = Session::new(); + s.execute("variable.createCollection", &json!({"name": "Theme"})).unwrap(); + for (n, t) in ["bravo", "charlie", "delta"].into_iter().zip(types) { + let value = match t { + "number" => json!(1), + "boolean" => json!(true), + "string" => json!("x"), + _ => json!("#ff0000"), + }; + s.execute("variable.create", &json!({"collection": "Theme", "name": n, "type": t, "value": value})).unwrap(); + } + let mut u = Ui::new(s); + u.app.ui.variables = Some(Default::default()); + for _ in 0..10 { + u.frame(vec![]); + } + u +} + +fn scope_tab(u: &mut Ui) -> Vec { + let shapes = open_edit_variables(u); + click(u, text_center(&shapes, "Scope"), PointerButton::Primary, Modifiers::NONE); + flat(&u.frame_output(vec![]).shapes) +} + +fn scopes(u: &Ui) -> Vec>> { + let doc = u.app.session.doc().unwrap(); + ["bravo", "charlie", "delta"].iter().map(|n| doc.variables.variables.iter().find(|v| v.name == *n).unwrap().scopes.clone()).collect() +} + +#[test] +fn all_supported_properties_turns_on_for_every_selected_variable_and_off_again_one_undo_step_each() { + let mut u = colour_window(); + let shapes = scope_tab(&mut u); + assert!(scopes(&u).iter().all(|s| s.is_some()), "each variable starts limited"); + let before = u.app.session.undo_labels(100).len(); + click(&mut u, text_center(&shapes, "All supported properties"), PointerButton::Primary, Modifiers::NONE); + assert!(u.app.ui.last_error.is_none(), "{:?}", u.app.ui.last_error); + assert!(scopes(&u).iter().all(|s| s.is_none()), "on: no variable is limited: {:?}", scopes(&u)); + assert_eq!(u.app.session.undo_labels(100).len(), before + 1, "one undo step"); + let shapes = flat(&u.frame_output(vec![]).shapes); + click(&mut u, text_center(&shapes, "All supported properties"), PointerButton::Primary, Modifiers::NONE); + assert!(u.app.ui.last_error.is_none(), "{:?}", u.app.ui.last_error); + assert!(scopes(&u).iter().all(|s| s.as_ref().is_some_and(|l| l.is_empty())), "off: hidden from pickers: {:?}", scopes(&u)); + assert_eq!(u.app.session.undo_labels(100).len(), before + 2, "one undo step each"); +} + +#[test] +fn clicking_a_checked_scope_clears_it_on_every_selected_variable_in_one_undo_step() { + let mut u = colour_window(); + let shapes = scope_tab(&mut u); + let before = u.app.session.undo_labels(100).len(); + // Frame fill is on for all three: checked, so the click clears it. + click(&mut u, text_center(&shapes, "Frame fill"), PointerButton::Primary, Modifiers::NONE); + assert!(u.app.ui.last_error.is_none(), "{:?}", u.app.ui.last_error); + let doc = u.app.session.doc().unwrap(); + assert!(["bravo", "charlie", "delta"].iter().all(|n| !doc.variables.variables.iter().find(|v| v.name == *n).unwrap().in_scope("FRAME_FILL"))); + assert_eq!(flags(&u), [(false, true), (false, true), (false, false)], "the other scopes stay"); + assert_eq!(u.app.session.undo_labels(100).len(), before + 1, "one undo step"); + u.app.session.undo().unwrap(); + assert!(scopes(&u).iter().all(|s| s.as_ref().is_some_and(|l| l.iter().any(|x| x == "FRAME_FILL")))); +} + +#[test] +fn booleans_share_no_scope_and_the_scope_tab_says_so() { + let mut u = typed_window(["boolean", "boolean", "boolean"]); + let shapes = scope_tab(&mut u); + assert!(has_text(&shapes, "No scope is shared by all the selected variables")); + assert!(!has_text(&shapes, "All supported properties")); +} + +#[test] +fn mixed_types_list_only_the_scopes_every_type_has() { + // Number and string share only Text content; a colour shares nothing with them. + let mut u = typed_window(["number", "number", "string"]); + let shapes = scope_tab(&mut u); + assert!(has_text(&shapes, "Text content"), "the shared scope is shown"); + for other in ["Corner radius", "Font family", "Font size"] { + assert!(!has_text(&shapes, other), "{other} is not common"); + } + assert!(!has_text(&shapes, "No scope is shared by all the selected variables")); + let mut u = typed_window(["number", "color", "string"]); + let shapes = scope_tab(&mut u); + assert!(has_text(&shapes, "No scope is shared by all the selected variables")); +} + +#[test] +fn edit_variables_is_not_offered_when_every_selected_variable_is_inherited() { + let mut u = window(); + u.app.session.execute("variable.extendCollection", &json!({"collection": "Theme"})).unwrap(); + u.app.ui.variables = Some(crate::dialogs::variables_panel::Editor::on(Some("Theme (extended)".into()))); + for _ in 0..10 { + u.frame(vec![]); + } + click_row(&mut u, "bravo", Modifiers::NONE); + click_row(&mut u, "delta", SHIFT); + assert_eq!(selected(&u), ["bravo", "charlie", "delta"]); + let p = row(&mut u, "delta"); + click(&mut u, p, PointerButton::Secondary, Modifiers::NONE); + let menu = flat(&u.frame_output(vec![]).shapes); + assert!(!has_text(&menu, "Edit variables"), "inherited variables are edited in their own collection"); +} diff --git a/crates/ui-egui/src/widgets.rs b/crates/ui-egui/src/widgets.rs index 533b78dff..91eb70aed 100644 --- a/crates/ui-egui/src/widgets.rs +++ b/crates/ui-egui/src/widgets.rs @@ -1295,13 +1295,19 @@ pub fn paint_swatch(painter: &egui::Painter, rect: Rect, paint: &figcraft_color: /// A small checkbox with label. pub fn checkbox(ui: &mut Ui, on: bool, label: &str) -> bool { + checkbox_tri(ui, Some(on), label) +} + +/// A checkbox that can show a mixed state (`None`: a dash, for a setting that differs across a +/// selection); returns whether it was clicked. +pub fn checkbox_tri(ui: &mut Ui, state: Option, label: &str) -> bool { let t = Tokens::get(ui.ctx()); let (rect, resp) = ui.allocate_exact_size(vec2(ui.available_width().min(200.0), FIELD_H), Sense::click()); - a11y::checkbox(&resp, label, on); + a11y::checkbox_tri(&resp, label, state); let b = Rect::from_min_size(pos2(rect.min.x, rect.center().y - 7.0), vec2(14.0, 14.0)); - if on { + if state != Some(false) { ui.painter().rect_filled(b, CornerRadius::same(3), t.accent); - icons::paint(ui.painter(), b.shrink(1.5), Icon::Check, t.accent_on); + icons::paint(ui.painter(), b.shrink(1.5), if state.is_some() { Icon::Check } else { Icon::Minus }, t.accent_on); } else { ui.painter().rect_stroke(b, CornerRadius::same(3), Stroke::new(1.0, t.border_strong), StrokeKind::Inside); } diff --git a/docs/components-parity.md b/docs/components-parity.md index 83e708a27..c228aa94d 100644 --- a/docs/components-parity.md +++ b/docs/components-parity.md @@ -81,6 +81,7 @@ updates with overrides kept: `library_tests.rs`, `components_scale_tests.rs`. | Date | Change | Summary | |---|---|---| +| 2026-11-07 | minor | M3, #2082: Edit variables in the context menu of a selection of several local variables opens the reference's compact editor with two tabs: Details holds only Hide from publishing, Scope the scopes every selected variable's type has (All supported properties and one box per scope; a selection that shares none says so). Each box is checked when all selected variables have it, empty when none, and shows a dash when they differ; a click sets it on all (or clears it when checked on all), each change one `command.batch`, so one undo step. Names, descriptions and code syntax stay single-variable, as in the reference. The Scope: menu entries stay. A tri-state `widgets::checkbox_tri` draws the dash. Tests: `variables_select_tests` (headless UI). Grade unchanged | | 2026-11-10 | minor | M7, #2174: a text style binds a number variable to its weight (`style.bind {field: "fontWeight"}`): the style takes the face nearest the number and sets the `wght` axis, so static and variable fonts both follow; a face-name (string) binding and a weight binding replace each other, and the weight wins in a file carrying both. The style editor's weight menu offers number variables beside string ones. A number bound to a line height is applied in pixels, as the reference tool does, which a test now pins. Numbers unchanged. Tests: `style_vars_tests`, `style_picker::tests`. | | 2026-11-07 | patch | M3, #2088: with two or more layers selected the Design panel header's component button opens a menu with Create component, Create multiple components and Create component set (`component.createSet`, naming measured in Figma), as Figma's does; one layer keeps the plain button. Tests: `create_multiple_menu_tests`, `components_behaviour_tests::create_multiple_components_keeps_names_and_places_and_is_one_undo_step`, `components_behaviour_tests::create_set_*`. Grade unchanged. | | 2026-11-05 | minor | M3, #2002: the Local variables window selects several variables, as the Layers panel selects layers. A click selects one row, Shift+click the range from the anchor through the rows shown, Cmd/Ctrl+click toggles a row, Escape or a click on the empty space below the rows clears; selected rows use the sidebar's selected-row colour. Right-clicking a row that is part of a selection of several offers Delete, Move to group and Scope (all supported properties, hidden from pickers, or only one scope) for the selected local variables, each sent as one `command.batch`, so one undo step; no engine command changed. Renaming and value edits stay single-row. Tests: `variables_select_tests` (headless UI). Grade unchanged |