diff --git a/crates/doc/src/node/live_shape.rs b/crates/doc/src/node/live_shape.rs index a384836442..0a17301331 100644 --- a/crates/doc/src/node/live_shape.rs +++ b/crates/doc/src/node/live_shape.rs @@ -144,10 +144,36 @@ impl LiveShape { /// from straight up (the Rotate field's sense). None for other shapes. pub fn polygon_angle(&self) -> Option { let LiveShape::Polygon { .. } = self else { return None }; - // No −0° or 360° from rounding: a polygon drawn upright reads 0°. + self.shape_angle() + } + /// A rectangle's, ellipse's or polygon's angle (Rectangle, Ellipse and Polygon Angle): the + /// counterclockwise degrees in [0, 360) it is turned by (the Rotate field's sense). A rectangle or + /// ellipse drawn level reads 0°, as does a polygon drawn with its first vertex straight up. None for + /// other shapes. + pub fn shape_angle(&self) -> Option { + let (LiveShape::Rectangle { .. } | LiveShape::Ellipse { .. } | LiveShape::Polygon { .. }) = self else { return None }; + // No −0° or 360° from rounding: a shape drawn level reads 0°. let a = (-self.angle_deg()).rem_euclid(360.0); Some(if a > 360.0 - 1e-9 { 0.0 } else { a + 0.0 }) } + /// Turn a rectangle, ellipse or polygon about its center to `angle` (degrees, as + /// [`LiveShape::shape_angle`]), keeping its size, corners and pie. Nothing changes for other + /// shapes or an angle that isn't finite. + pub fn set_shape_angle(&mut self, angle: f64) { + let Some(now) = self.shape_angle() else { return }; + if !angle.is_finite() { + return; + } + // Brought into [0, 360) first: `now - angle` loses `now` for a very large angle. + let angle = angle.rem_euclid(360.0); + let (xf, local) = match self { + LiveShape::Rectangle { w, h, xf, .. } | LiveShape::Ellipse { w, h, xf, .. } => (xf, Point::new(*w / 2.0, *h / 2.0)), + LiveShape::Polygon { xf, .. } => (xf, Point::ZERO), + LiveShape::Line { .. } | LiveShape::Path { .. } => return, + }; + let center = *xf * local; + *xf = Affine::rotate_about((now - angle).to_radians(), center) * *xf; + } /// Whether a polygon's sides are all as long: `xf` scales it evenly and doesn't shear it. True /// for other shapes. pub fn polygon_sides_equal(&self) -> bool { @@ -171,12 +197,8 @@ impl LiveShape { } /// Turn a polygon about its centre to `angle` (degrees, as [`LiveShape::polygon_angle`]). pub fn set_polygon_angle(&mut self, angle: f64) { - let Some(now) = self.polygon_angle() else { return }; - if let LiveShape::Polygon { xf, .. } = self - && angle.is_finite() - { - let centre = *xf * Point::ZERO; - *xf = Affine::rotate_about((now - angle).to_radians(), centre) * *xf; + if let LiveShape::Polygon { .. } = self { + self.set_shape_angle(angle); } } /// A line's length in the document, from its first end to its second. None for other shapes. diff --git a/crates/doc/src/node/tests.rs b/crates/doc/src/node/tests.rs index 789e0f66b2..cdcbf2cf85 100644 --- a/crates/doc/src/node/tests.rs +++ b/crates/doc/src/node/tests.rs @@ -184,6 +184,20 @@ fn a_polygon_reports_and_takes_its_radius_angle_and_equal_sides() { assert_eq!((e.polygon_radius(), e.polygon_angle()), (None, None)); } +/// A very large angle turns a rectangle to that angle modulo 360, whatever angle it had before. +#[test] +fn a_shape_takes_a_very_large_angle() { + let close = |a: f64, b: f64| (a - b).abs() < 1e-6; + let want = 1e20f64.rem_euclid(360.0); + for turned in [0.0, 90.0] { + let xf = Affine::translate((50.0, 50.0)) * Affine::rotate(-f64::to_radians(turned)); + let mut r = LiveShape::Rectangle { w: 100.0, h: 50.0, radii: [0.0; 4], kinds: Default::default(), radii_relative: false, xf }; + assert!(close(r.shape_angle().unwrap(), turned), "{:?}", r.shape_angle()); + r.set_shape_angle(1e20); + assert!(close(r.shape_angle().unwrap(), want), "from {turned}°: {:?}, not {want}", r.shape_angle()); + } +} + /// A node holding a live rectangle (`w` × `h`, all radii `r`, placed by `xf`) and its path. fn live_rect(w: f64, h: f64, r: f64, xf: Affine) -> Node { let live = LiveShape::Rectangle { w, h, radii: [r; 4], kinds: Default::default(), radii_relative: false, xf }; diff --git a/crates/engine/src/cmd/object/commands.rs b/crates/engine/src/cmd/object/commands.rs index 2f80e3b6c6..e5ff38efa6 100644 --- a/crates/engine/src/cmd/object/commands.rs +++ b/crates/engine/src/cmd/object/commands.rs @@ -305,7 +305,7 @@ pub fn specs() -> Vec { "Live Shape Properties", [], None, - "{id?, ids?, radius?: pt (or % of each corner's maximum when `relativeRadii` is true), kind?: \"round\"|\"invertedRound\"|\"chamfer\", relativeRadii?: bool (Relative rounding, as in the reference app: store radii as fractions of each corner's maximum so they scale with the shape), corners?: [i…], items?: [{id, corners?: [i…]}] (several objects, each with its own corners, in place of ids and corners: the canvas's corner widgets across a selection), sides?: n, polygonAngle?: degrees (counter-clockwise from its first vertex straight up), polygonRadius?: pt (centre to vertex), sideLength?: pt (sets the radius), makeSidesEqual?: true (a polygon scaled unevenly: drops the uneven scale and shear, keeping its centre, angle and mean radius), pieStart?, pieEnd?: degrees (an ellipse's pie, counter-clockwise from 3 o'clock; 0 to 360 is the whole ellipse), invertPie?: true (swaps them: the other part of the ellipse), constrainPie?: bool (Constrain Pie Angle: with one of pieStart and pieEnd, not both and not with invertPie, the other angle moves by as much, so each ellipse keeps its span), lineLength?: pt (a live line's length, above 0; its first end stays), lineAngle?: degrees (a live line's angle, counter-clockwise from 3 o'clock, from its first end to its second; it turns about its midpoint)} (Live Corners on any path: radius and kind set its corners (anchors that aren't smooth, where two sides, straight or curved (#1144), meet at an angle): `corners` (anchor indices of the path with its corners uncut, counting every subpath's anchors in order: a rectangle's 0 top-left, 1 top-right, 2 bottom-right, 3 bottom-left; a polygon's from the first vertex clockwise), else the corners with a Direct-Selected anchor, else every corner; each radius is drawn no larger than half the corner's shorter side allows; a path that isn't a live shape keeps its uncut outline so its corners stay editable, and is plain again once none is cut; sides: a polygon's, which keep the radius they shared; the polygon params apply in that order: sides, makeSidesEqual, polygonAngle, then sideLength or else polygonRadius; a line's lineLength applies before its lineAngle)", + "{id?, ids?, radius?: pt (or % of each corner's maximum when `relativeRadii` is true), kind?: \"round\"|\"invertedRound\"|\"chamfer\", relativeRadii?: bool (Relative rounding, as in the reference app: store radii as fractions of each corner's maximum so they scale with the shape), corners?: [i…], items?: [{id, corners?: [i…]}] (several objects, each with its own corners, in place of ids and corners: the canvas's corner widgets across a selection), sides?: n, polygonAngle?: degrees (counter-clockwise from its first vertex straight up), polygonRadius?: pt (centre to vertex), sideLength?: pt (sets the radius), makeSidesEqual?: true (a polygon scaled unevenly: drops the uneven scale and shear, keeping its centre, angle and mean radius), pieStart?, pieEnd?: degrees (an ellipse's pie, counter-clockwise from 3 o'clock; 0 to 360 is the whole ellipse), invertPie?: true (swaps them: the other part of the ellipse), constrainPie?: bool (Constrain Pie Angle: with one of pieStart and pieEnd, not both and not with invertPie, the other angle moves by as much, so each ellipse keeps its span), lineLength?: pt (a live line's length, above 0; its first end stays), lineAngle?: degrees (a live line's angle, counter-clockwise from 3 o'clock, from its first end to its second; it turns about its midpoint), rectangleAngle?: degrees (a live rectangle's, counterclockwise from level), ellipseAngle?: degrees (a live ellipse's, counterclockwise from level; its pie turns with it)} (rectangleAngle, ellipseAngle and polygonAngle turn each shape of that kind about its own center and leave other objects as they are; a pixel-aligned shape then goes back on the pixel grid, as after other edits, which can move its center or change its size; an angle that is not a number is an error, and `null` counts as an omitted key; a shape that a turn would take past the coordinate limit (±4,000,000 pt) is an error that changes nothing; Live Corners on any path: radius and kind set its corners (anchors that aren't smooth, where two sides, straight or curved (#1144), meet at an angle): `corners` (anchor indices of the path with its corners uncut, counting every subpath's anchors in order: a rectangle's 0 top-left, 1 top-right, 2 bottom-right, 3 bottom-left; a polygon's from the first vertex clockwise), else the corners with a Direct-Selected anchor, else every corner; each radius is drawn no larger than half the corner's shorter side allows; a path that isn't a live shape keeps its uncut outline so its corners stay editable, and is plain again once none is cut; sides: a polygon's, which keep the radius they shared; the polygon params apply in that order: sides, makeSidesEqual, polygonAngle, then sideLength or else polygonRadius; a line's lineLength applies before its lineAngle)", has_selection, set_live_shape ), diff --git a/crates/engine/src/cmd/object/shape.rs b/crates/engine/src/cmd/object/shape.rs index 02edf6193b..b2e69cc279 100644 --- a/crates/engine/src/cmd/object/shape.rs +++ b/crates/engine/src/cmd/object/shape.rs @@ -202,6 +202,16 @@ pub(super) fn set_live_shape(s: &mut Session, p: &Value) -> Result { // A polygon's Polygon Properties: its angle, radius or side length, Make Sides Equal. let (polygon_angle, polygon_radius, side) = (angle("polygonAngle")?, length("polygonRadius")?, length("sideLength")?); let equal = p.get("makeSidesEqual").and_then(Value::as_bool) == Some(true); + // A rectangle's Rectangle Angle and an ellipse's Ellipse Angle, as `polygonAngle` turns a polygon. + let (rectangle_angle, ellipse_angle) = (angle("rectangleAngle")?, angle("ellipseAngle")?); + // Whether a shape at `now` already stands at `a`: a turn the rounding of an earlier one left + // (89.999999999°, or 359.9999999999° against 0°) counts as no change. + let at_angle = |now: Option, a: f64| { + now.is_some_and(|n| { + let d = (n - a).rem_euclid(360.0); + d.min(360.0 - d) < 1e-9 + }) + }; // A line's Line Properties: its length (its first end stays) and its angle (about its midpoint). // A line's length can reach across the whole canvas, past `MAX_COORD`: its ends are checked below. let line_length = number("lineLength", |x| x > 0.0, "a length in points above 0")?; @@ -249,12 +259,15 @@ pub(super) fn set_live_shape(s: &mut Session, p: &Value) -> Result { Some(l @ LiveShape::Polygon { sides: now, .. }) if !(sides.is_none_or(|n| n.clamp(3, 1000) == u64::from(*now)) && (!equal || l.polygon_sides_equal()) - && polygon_angle.is_none_or(|a| l.polygon_angle() == Some(a)) + && polygon_angle.is_none_or(|a| at_angle(l.polygon_angle(), a)) && side.and_then(|len| l.polygon_radius_for_side(len)).or(polygon_radius).is_none_or(|r| l.polygon_radius() == Some(r))) => { return false; } - Some(LiveShape::Ellipse { pie, .. }) if pie_of(*pie) != *pie => return false, + Some(l @ LiveShape::Ellipse { pie, .. }) if pie_of(*pie) != *pie || ellipse_angle.is_some_and(|a| !at_angle(l.shape_angle(), a)) => { + return false; + } + Some(l @ LiveShape::Rectangle { .. }) if rectangle_angle.is_some_and(|a| !at_angle(l.shape_angle(), a)) => return false, _ => {} } if relative_radii.is_some_and(|on| live.as_deref().map(|l| l.radii_relative()) != Some(on)) { @@ -298,9 +311,18 @@ pub(super) fn set_live_shape(s: &mut Session, p: &Value) -> Result { } *path = l.to_path(); } - if let Some(l @ LiveShape::Ellipse { .. }) = live.as_deref_mut() - && (pie_start.is_some() || pie_end.is_some() || invert) + if let Some(a) = rectangle_angle + && let Some(l @ LiveShape::Rectangle { .. }) = live.as_deref_mut() { + l.set_shape_angle(a); + *path = l.to_path(); + } + if let Some(l @ LiveShape::Ellipse { .. }) = live.as_deref_mut() + && (pie_start.is_some() || pie_end.is_some() || invert || ellipse_angle.is_some()) + { + if let Some(a) = ellipse_angle { + l.set_shape_angle(a); + } if let LiveShape::Ellipse { pie, .. } = l { *pie = pie_of(*pie); } @@ -339,6 +361,11 @@ pub(super) fn set_live_shape(s: &mut Session, p: &Value) -> Result { for id in &ids { super::pixelgrid::resnap(d, *id); } + // A shape named in `ids` and not selected is not checked after the edit: one that a turn or + // a new radius would take past the coordinate limit is an error here, and nothing changes. + if !crate::sanity::objects_in_range(d, &ids) { + return Err(bad("object.setLiveShape", format!("coordinate out of range (limit ±{MAX_COORD} pt)"))); + } Ok(()) })?; ok() diff --git a/crates/engine/src/tests/livecorners.rs b/crates/engine/src/tests/livecorners.rs index e372467603..1ea6e5091f 100644 --- a/crates/engine/src/tests/livecorners.rs +++ b/crates/engine/src/tests/livecorners.rs @@ -585,6 +585,106 @@ fn a_polygon_takes_its_angle_radius_side_length_and_equal_sides() { } } +/// Rectangle Angle and Ellipse Angle: `rectangleAngle` and `ellipseAngle` turn each selected live +/// rectangle or ellipse about its own center, keeping its size, corners and pie, as one undo step. +/// The angle it already has records no step, each key leaves the other kind as it is, and a value +/// that is not a number is an error. +#[test] +fn a_rectangle_and_an_ellipse_take_their_angle() { + let (mut s, rect) = session(); + run(&mut s, json!({"radius": 8})); + let ellipse = NodeId(s.execute("shape.ellipse", &json!({"x": 200, "y": 200, "width": 120, "height": 80})).unwrap()["id"].as_u64().unwrap()); + run(&mut s, json!({"pieStart": 30, "pieEnd": 120})); + let live = |s: &Session, id: NodeId| { + let n = s.doc().unwrap().doc.node(id).unwrap(); + (n.live_shape().unwrap().clone(), n.geometric_bounds().unwrap()) + }; + let steps = |s: &Session| s.doc().unwrap().history.undo.len(); + let close = |a: f64, b: f64| (a - b).abs() < 1e-6; + let angle = |s: &Session, id: NodeId| live(s, id).0.shape_angle().unwrap(); + // The ellipse's center: the middle of its untransformed box, wherever its pie leaves the path. + let ellipse_center = |s: &Session| match live(s, ellipse).0 { + LiveShape::Ellipse { w, h, xf, .. } => xf * vectorcraft_geom::Point::new(w / 2.0, h / 2.0), + l => panic!("{l:?}"), + }; + let center = ellipse_center(&s); + + s.execute("select.set", &json!({"ids": [rect.0]})).unwrap(); + let n = steps(&s); + run(&mut s, json!({"rectangleAngle": 90})); + let (l, b) = live(&s, rect); + assert!(close(angle(&s, rect), 90.0), "{l:?}"); + // 100 × 60 at (10, 10) turned about (60, 40): 60 wide, 100 tall, same center. + assert!(close(b.width(), 60.0) && close(b.height(), 100.0) && close(b.center().x, 60.0) && close(b.center().y, 40.0), "{b:?}"); + let LiveShape::Rectangle { w, h, radii, .. } = &l else { panic!("{l:?}") }; + assert!(close(*w, 100.0) && close(*h, 60.0) && *radii == [8.0; 4], "{w} {h} {radii:?}"); + assert_eq!(steps(&s), n + 1, "one undo step"); + for same in [json!({"rectangleAngle": 90}), json!({"rectangleAngle": 450}), json!({"rectangleAngle": -270}), json!({"ellipseAngle": 10})] { + run(&mut s, same.clone()); + assert_eq!(steps(&s), n + 1, "{same} records no undo step"); + } + // A turn the field gives back rounded is the angle the shape has: typing it again records no step. + run(&mut s, json!({"rectangleAngle": 33.3})); + let now = angle(&s, rect); + run(&mut s, json!({"rectangleAngle": now})); + run(&mut s, json!({"rectangleAngle": 33.3})); + assert_eq!(steps(&s), n + 2); + for bad in [json!({"rectangleAngle": "left"}), json!({"ellipseAngle": "up"}), json!({"rectangleAngle": true})] { + assert!(s.execute("object.setLiveShape", &bad).is_err(), "{bad}"); + assert_eq!(steps(&s), n + 2, "{bad} changes nothing"); + } + + // The ellipse turns about its center and keeps its pie. + s.execute("select.set", &json!({"ids": [ellipse.0]})).unwrap(); + run(&mut s, json!({"ellipseAngle": 90})); + let (l, b) = live(&s, ellipse); + assert!(close(angle(&s, ellipse), 90.0), "{l:?}"); + let LiveShape::Ellipse { pie, .. } = &l else { panic!("{l:?}") }; + assert_eq!(*pie, (30.0, 120.0)); + let now = ellipse_center(&s); + assert!(close(now.x, center.x) && close(now.y, center.y), "{center:?} → {now:?}"); + assert!(b.width() < b.height(), "120 × 80 turned a quarter turn: {b:?}"); + + // Both selected: each key turns its own kind only, each about its own center. + s.execute("select.set", &json!({"ids": [rect.0, ellipse.0]})).unwrap(); + run(&mut s, json!({"rectangleAngle": 45})); + assert!(close(angle(&s, rect), 45.0) && close(angle(&s, ellipse), 90.0)); + let b = live(&s, rect).1; + assert!(close(b.center().x, 60.0) && close(b.center().y, 40.0), "{b:?}"); + s.execute("edit.undo", &json!({})).unwrap(); + assert!(close(angle(&s, rect), 33.3)); + + // A reflected rectangle takes the angle too, about its center. + s.execute("select.set", &json!({"ids": [rect.0]})).unwrap(); + s.execute("object.reflect", &json!({"axis": "vertical"})).unwrap(); + let before = live(&s, rect).1.center(); + run(&mut s, json!({"rectangleAngle": 20})); + let after = live(&s, rect).1.center(); + assert!(close(angle(&s, rect), 20.0) && close(before.x, after.x) && close(before.y, after.y), "{before:?} → {after:?}"); +} + +/// A shape named in `ids` that a turn would take past the coordinate limit (±4,000,000 pt) is an +/// error that changes nothing, whether or not it is selected. +#[test] +fn a_turn_past_the_coordinate_limit_is_an_error() { + let mut s = Session::new(); + s.execute("file.new", &json!({"width": 400, "height": 400})).unwrap(); + let mut add = |cmd: &str, p: Value| s.execute(cmd, &p).unwrap()["id"].as_u64().unwrap(); + // Each reaches within 10 pt of the limit and past it when turned. + let rect = add("shape.rectangle", json!({"x": 3_999_890, "y": 100, "width": 100, "height": 100})); + let ellipse = add("shape.ellipse", json!({"x": 3_999_950, "y": 100, "width": 40, "height": 100})); + let polygon = add("shape.polygon", json!({"cx": 3_999_955, "cy": 200, "radius": 50, "sides": 6})); + for (id, key, angle) in [(rect, "rectangleAngle", 45), (ellipse, "ellipseAngle", 90), (polygon, "polygonAngle", 90)] { + for selected in [false, true] { + s.execute("select.set", &json!({"ids": if selected { vec![id] } else { vec![] }})).unwrap(); + let (doc, steps) = (s.doc().unwrap().doc.clone(), s.doc().unwrap().history.undo.len()); + let e = s.execute("object.setLiveShape", &json!({"ids": [id], key: angle})).unwrap_err(); + assert!(e.to_string().contains("out of range"), "{key}, selected {selected}: {e}"); + assert!(*s.doc().unwrap().doc == *doc && s.doc().unwrap().history.undo.len() == steps, "{key}, selected {selected}: changed"); + } + } +} + /// A live line's Line Properties: Line Length keeps its first end in place, Line Angle (degrees /// counterclockwise, any finite value brought into 0 to 360) turns it about its midpoint, the /// length applies before the angle, every selected line takes them in one undo step, and a value diff --git a/crates/engine/tests/command_sweep.rs b/crates/engine/tests/command_sweep.rs index b8114f705c..1413bb17bb 100644 --- a/crates/engine/tests/command_sweep.rs +++ b/crates/engine/tests/command_sweep.rs @@ -1278,6 +1278,39 @@ fn polygon_properties_junk() { assert!(failures.is_empty(), "{} failures:\n{}", failures.len(), failures.join("\n")); } +/// A live rectangle's and ellipse's Rectangle and Ellipse Angle with junk values, drawn plain, +/// scaled unevenly, flattened to nothing and sheared: never a panic, and the document stays sound. +#[test] +fn rectangle_and_ellipse_angle_junk() { + let mut failures = vec![]; + for (shape, key) in [("shape.rectangle", "rectangleAngle"), ("shape.ellipse", "ellipseAngle")] { + for xf in [ + None, + Some(("object.scale", json!({"sx": 300, "sy": 20}))), + Some(("object.scale", json!({"sx": 1e-300, "sy": 100}))), + Some(("object.shear", json!({"angle": 40}))), + ] { + for v in junk_values() { + let p = json!({ key: v }); + let mut s = Fixture::Multi.session(); + let Ok(_) = no_panic(s.execute(shape, &json!({"x": 60, "y": 60, "width": 80, "height": 50}))) else { continue }; + if let Some((cmd, q)) = &xf { + let _ = no_panic(s.execute(cmd, q)); + } + match catch_quiet(|| no_panic(s.execute("object.setLiveShape", &p))) { + Err(m) => failures.push(format!("PANIC object.setLiveShape {p} [{xf:?}]: {m}")), + Ok(_) => { + if let Err(e) = catch_quiet(|| check_all(&mut s)).unwrap_or_else(|m| Err(format!("panic in checks: {m}"))) { + failures.push(format!("object.setLiveShape {p} [{xf:?}]: {e}")); + } + } + } + } + } + } + assert!(failures.is_empty(), "{} failures:\n{}", failures.len(), failures.join("\n")); +} + /// A live line's Line Properties with junk values (the fixtures have no line), on a line, a line /// whose ends meet and one at the coordinate limit: never a panic, and the document stays sound. #[test] diff --git a/crates/ui-egui/src/panels/transform.rs b/crates/ui-egui/src/panels/transform.rs index 14eb352d31..42e0dba358 100644 --- a/crates/ui-egui/src/panels/transform.rs +++ b/crates/ui-egui/src/panels/transform.rs @@ -441,6 +441,8 @@ pub(crate) fn live_shape_rows(app: &mut VectorcraftApp, ui: &mut Ui, n: &Node, l if headed { widgets::subheader(ui, tl!("Rectangle Properties:")); } + let fw = super::field_width(ui); + shape_angle_row(app, ui, live, &format!("{id}-rectangle"), "rectangleAngle", fw); corner_radius_row(app, ui, n, &format!("{id}-radius")); } LiveShape::Polygon { .. } => { @@ -451,6 +453,7 @@ pub(crate) fn live_shape_rows(app: &mut VectorcraftApp, ui: &mut Ui, n: &Node, l } LiveShape::Ellipse { pie, .. } => { widgets::subheader(ui, tl!("Ellipse Properties:")); + shape_angle_row(app, ui, live, &format!("{id}-ellipse"), "ellipseAngle", 60.0); pie_rows(app, ui, *pie, &format!("{id}-pie")); } LiveShape::Line { .. } => return line_rows(app, ui, live, &format!("{id}-line")), @@ -459,6 +462,55 @@ pub(crate) fn live_shape_rows(app: &mut VectorcraftApp, ui: &mut Ui, n: &Node, l true } +/// A live rectangle's or ellipse's Angle row (Rectangle and Ellipse Angle, counterclockwise): the +/// angle the selected shapes of its kind share, blank when they differ. `key` is the +/// `object.setLiveShape` param an edit sets, which turns each of them about its own center. +fn shape_angle_row(app: &mut VectorcraftApp, ui: &mut Ui, live: &LiveShape, id: &str, key: &str, width: f32) { + let angle = shared_shape_angle(app, ui.ctx(), live); + ui.horizontal(|ui| { + widgets::dim_label(ui, tl!("Angle:")); + if let Some(a) = widgets::mixed_field_named(ui, (id, "angle"), Some(tl!("Angle:")), angle, "°", 1, width) { + app.run("object.setLiveShape", json!({ key: a })).ok(); + } + }); +} + +/// The selected live shapes of `live`'s kind, the document uid and revision they were read at, and +/// the angle they share. +type SharedAngle = Option<((u64, u64, std::mem::Discriminant), Option)>; + +/// The angle ([`LiveShape::shape_angle`]) every selected live shape of `live`'s kind shares, `None` +/// when they differ or none is selected. Measured once per (document uid, revision) and kind: the +/// panels read it every frame, and Select All can select hundreds of thousands of shapes. +fn shared_shape_angle(app: &VectorcraftApp, ctx: &egui::Context, live: &LiveShape) -> Option { + let st = app.session.active()?; + let key = (st.uid, st.revision, std::mem::discriminant(live)); + if let Some((k, angle)) = pstate::(ctx, "shape-angle") + && k == key + { + return angle; + } + let mut angles = st + .selection + .objects + .iter() + .filter_map(|id| st.doc.node(*id)?.live_shape()) + .filter(|l| std::mem::discriminant(*l) == key.2) + .filter_map(LiveShape::shape_angle); + // With no shape of its kind selected, the panel shows `live`'s own angle. + let angle = match angles.next() { + None => live.shape_angle(), + Some(first) => angles + .all(|a| { + let d = (a - first).rem_euclid(360.0); + d.min(360.0 - d) < 1e-9 + }) + .then_some(first), + }; + set_pstate::(ctx, "shape-angle", Some((key, angle))); + angle +} + /// Whether every selected object is a live line (and one is selected). fn only_lines_selected(app: &VectorcraftApp) -> bool { let Some(st) = app.session.active() else { return false }; @@ -546,6 +598,7 @@ pub(crate) fn polygon_rows(app: &mut VectorcraftApp, ui: &mut Ui, n: &Node, live let side = radius.map(|r| 2.0 * r * (std::f64::consts::PI / f64::from((*sides).max(3))).sin()); let kind = super::corner_style(app, n).1; let kinds: Vec<&str> = CornerKind::ALL.iter().map(|k| corner_kind(*k)).collect(); + let angle = shared_shape_angle(app, ui.ctx(), live); // The `object.setLiveShape` param an edited field sets. let mut set = None; egui::Grid::new((id, "grid")).num_columns(2).spacing([6.0, 6.0]).show(ui, |ui| { @@ -555,7 +608,7 @@ pub(crate) fn polygon_rows(app: &mut VectorcraftApp, ui: &mut Ui, n: &Node, live } ui.end_row(); widgets::dim_label(ui, tl!("Angle:")); - if let Some(a) = widgets::plain_field_named(ui, (id, "angle"), Some(tl!("Angle:")), live.polygon_angle().unwrap_or(0.0), "°", 1, fw) { + if let Some(a) = widgets::mixed_field_named(ui, (id, "angle"), Some(tl!("Angle:")), angle, "°", 1, fw) { set = Some(("polygonAngle", json!(a))); } ui.end_row(); diff --git a/crates/ui-egui/src/panels/transform/tests.rs b/crates/ui-egui/src/panels/transform/tests.rs index bb6b5f5000..dbb92b3cd4 100644 --- a/crates/ui-egui/src/panels/transform/tests.rs +++ b/crates/ui-egui/src/panels/transform/tests.rs @@ -154,6 +154,56 @@ fn an_ellipse_shows_its_pie_properties() { assert!(shown.iter().any(|s| s == "30°") && shown.iter().any(|s| s == "120°"), "{shown:?}"); } +/// A live rectangle and a live ellipse show their own angle (Rectangle and Ellipse Angle) in the +/// Transform panel and the Properties panel's Transform section, apart from the Rotate field's box +/// angle, which Reset Bounding Box squares to the page. Selected shapes of one kind at different +/// angles show a blank angle. +#[test] +fn a_rectangle_and_an_ellipse_show_their_angle() { + let mut app = VectorcraftApp::new(vectorcraft_engine::Session::new(), Default::default()); + app.run("file.new", json!({"width": 400, "height": 400})).unwrap(); + for (shape, heading) in [("shape.rectangle", "Rectangle Properties:"), ("shape.ellipse", "Ellipse Properties:")] { + let mut ids = vec![]; + for (y, angle) in [(20, 30), (200, 60)] { + let id = app.run(shape, json!({"x": 50, "y": y, "width": 100, "height": 50})).unwrap()["id"].as_u64().unwrap(); + app.run("object.rotate", json!({"angle": angle, "absolute": true})).unwrap(); + app.run("object.resetBoundingBox", json!({})).unwrap(); + ids.push(id); + } + app.run("select.set", json!({"ids": [ids[0]]})).unwrap(); + for (draw, rotate) in [(show as fn(&mut VectorcraftApp, &mut Ui), "Rotate"), (crate::panels::properties::transform_section, "Rotation")] { + assert_eq!(field_text(&mut app, draw, rotate), "0°", "{shape}: {rotate}"); + assert_eq!(field_text(&mut app, draw, "Angle:"), "30°", "{shape}: {rotate}"); + } + assert!(texts(&mut app, show).iter().any(|s| s == heading), "{heading}"); + app.run("select.set", json!({"ids": ids})).unwrap(); + assert_eq!(field_text(&mut app, show, "Angle:"), "", "{shape}: mixed angles"); + app.run("select.set", json!({"ids": [ids[1]]})).unwrap(); + assert_eq!(field_text(&mut app, show, "Angle:"), "60°", "{shape}"); + } +} + +/// The text in `draw`'s input named `label`, read from the accessibility tree of a headless frame. +fn field_text(app: &mut VectorcraftApp, draw: fn(&mut VectorcraftApp, &mut Ui), label: &str) -> String { + use egui_kittest::kittest::Queryable; + let state = std::mem::replace(app, VectorcraftApp::new(vectorcraft_engine::Session::new(), Default::default())); + let mut fonts = false; + let mut h = egui_kittest::Harness::builder().with_size(egui::vec2(320.0, 900.0)).with_accessibility_check(false).build_ui_state( + move |ui, app: &mut VectorcraftApp| { + if !std::mem::replace(&mut fonts, true) { + crate::theme::install_fonts(ui.ctx()); + return; + } + draw(app, ui); + }, + state, + ); + h.run_steps(3); + let text = h.get_by_role_and_label(egui::accesskit::Role::TextInput, label).value().unwrap_or_default(); + *app = h.into_state(); + text +} + /// Ellipse Properties' Constrain Pie Angle link, in the Transform panel and the Properties panel's /// Transform section: off at first, a click or Space with the keyboard on it toggles it, and while /// it is on a typed Pie Start or End Angle moves the other angle by as much, keeping the span, in diff --git a/docs/mcp.md b/docs/mcp.md index 966175ccc2..1ca2693fc0 100644 --- a/docs/mcp.md +++ b/docs/mcp.md @@ -7367,6 +7367,25 @@ midpoint; any finite value is brought into 0 to 360). With both, the length appl and a line that would reach past the coordinate limit (±4,000,000 pt), are errors that change no line. Each call is one undo step. +A live rectangle's Rectangle Angle and a live ellipse's Ellipse Angle are `rectangleAngle` and `ellipseAngle` +(degrees counterclockwise, 0 for a shape drawn level; any number is read modulo 360). The help page +(https://helpx.adobe.com/illustrator/desktop/draw-shapes-and-paths/modify-live-shapes/live-shape-properties.html) lists +both as the shape's rotation on the canvas from 0° to 360°. The rest are VectorCraft's own rules: each selected shape +of that kind turns about its own center, keeping its size, corners and pie (an ellipse's pie turns with it), and other +objects stay as they are. A pixel-aligned shape then goes back on the pixel grid, as after other edits, which can move +its center or change its size. The Transform and Properties panels show the angle in each shape's Properties section, +blank when the selected shapes of that kind differ. It is the shape's own angle: after Reset Bounding Box +(`object.resetBoundingBox`) the Rotate field reads 0° while the shape angle keeps the turn. An angle that is not a +number is an error and changes nothing (`null` counts as an omitted key), a shape that the turn would take past the +coordinate limit (±4,000,000 pt) is an error that changes nothing, whether or not it is selected, and the angle the +shape already has records no undo step; the same holds for `polygonAngle`, and the Polygon Properties angle is blank, +too, when the selected polygons differ. + +```json +{"name":"run_command","arguments":{"command":"object.setLiveShape","params":{"rectangleAngle":30}}} +{"name":"run_command","arguments":{"command":"object.setLiveShape","params":{"ellipseAngle":45}}} +``` + `object.setLiveShape` returns a parameter error, and leaves the document and its undo history as they were, for a key it does not take, at the top level (`` unknown parameter `path` ``) or in one of `items` (`` unknown parameter `items[0].corner`; did you mean `items[0].corners`? ``), for a `sides` that is not a whole number diff --git a/docs/target-app-parity.md b/docs/target-app-parity.md index 6ab02bea78..d6ce18bffa 100644 --- a/docs/target-app-parity.md +++ b/docs/target-app-parity.md @@ -1065,6 +1065,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur - While a Type tool (Type, Area Type, Type on a Path and their vertical versions) adds or edits type, the contextual task bar shows the font family menu, the font style menu, the Font Size combo and the Fill chip (); the Touch Type tool shows no bar, as the same page describes. Type selected with a selection tool shows the same three font controls beside its Create Outlines, conversion and Type on a Path items (). The controls act as the Character panel's do: on the characters a Type tool selects, else on every selected type object, with the size left blank where the sizes differ. VectorCraft's own rules: a Type tool's bar leaves out the object actions, the Stroke chip, Recolor Artwork and Lock; a Type tool shows no bar before it adds type or with other art selected; type selected with other art shows no font controls; the font controls go on a second row when one row would be wider than the canvas, and narrow to fit a canvas narrower than they are; while a Type tool edits type, the Fill chip shows the edited characters' fill ("?" where it differs). Evidence: `the_type_tools_show_font_and_fill_controls`, `the_type_tools_show_no_bar_without_type`, `selected_type_shows_font_controls_beside_its_actions`, `the_task_bars_font_size_sets_what_the_character_panel_would`, `the_type_tools_fill_chip_activates_the_fill`, `the_type_tools_bar_is_named_and_stays_on_the_canvas`, `selected_types_font_controls_take_a_second_row_on_a_narrow_canvas` and `the_type_tools_fill_chip_shows_the_edited_characters_fill` in `crates/ui-egui/src/tests/taskbar.rs`. - The help page describes the contextual task bar as one horizontal row () and gives no rule for a canvas narrower than that row. VectorCraft's own rule: the bar stays whole on the canvas. When its actions don't fit in one row, they wrap, in order, onto rows under the row with the handle, the chips and More Options; an action wider than any row, or one that would need a row past the canvas's height, is listed in More Options instead; when the chips don't fit beside the handle and More Options, they take rows after the actions; with no row to spare for the font controls, the bar leaves them out; a canvas too small for the handle and More Options shows no bar. Evidence: `a_task_bars_actions_wrap_on_a_narrow_canvas` and `a_task_bar_action_wider_than_the_canvas_goes_in_more_options` in `crates/ui-egui/src/tests/taskbar.rs`. - With a live rectangle, rounded rectangle, ellipse or polygon selected with the Selection tool, the contextual task bar shows a Shape Properties button in place of Lock. It opens a popup with the shape's rows from the Transform panel (corner radius, pie angles, or sides, angle, corner and radius), which edit it through `object.setLiveShape`. The overview describes this: when a shape drawn with a shape tool (Rectangle, Star) is selected, the bar offers to change its properties where Lock Object would be ([Contextual Task Bar overview](https://helpx.adobe.com/illustrator/desktop/get-started/learn-the-basics/contextual-task-bar-overview.html)). Object › Lock and ⌘2 still lock the shape. Not done: stars, which the app draws as plain paths. Evidence: `a_basic_shape_shows_its_properties_in_place_of_lock`, `the_shape_properties_popup_edits_the_shape` and `other_selections_keep_lock` in `crates/ui-egui/src/tests/taskbar.rs`. + - Rectangle Properties and Ellipse Properties in the Transform panel, the Properties panel and the task bar's Shape Properties popup have an Angle field, as Polygon Properties does: the help page lists Rectangle Angle and Ellipse Angle as the shape's rotation on the canvas from 0° to 360° (). A typed angle turns the shape through `object.setLiveShape {rectangleAngle, ellipseAngle}`. VectorCraft's own rules: degrees counterclockwise, 0 for a shape drawn level; each selected shape of that kind turns about its own center and keeps its size, corners and pie; the field is blank when the selected shapes of that kind differ, as the Polygon Properties angle now is too; the shape keeps its angle after Reset Bounding Box squares the Rotate field's box to the page; the angle a shape already has records no undo step. Evidence: `a_rectangle_and_an_ellipse_take_their_angle` in `crates/engine/src/tests/livecorners.rs` and `a_rectangle_and_an_ellipse_show_their_angle` in `crates/ui-egui/src/panels/transform/tests.rs`. - While the Rectangle, Rounded Rectangle, Ellipse, Polygon or Star tool is in use, the contextual task bar offers Edit Path (the Direct Selection tool), the Fill and Stroke chips, and Shape Properties for the shape it draws, as the help page lists for those five tools (). VectorCraft's own rules: the bar shows while one of those tools has one closed path selected whole, as right after it draws one, and not with nothing selected, several objects, a group, an open path, type or picked-out anchors; it shows nothing during the drag that draws the shape; it leaves out the selection tools' Duplicate, Offset Path, Simplify, Recolor Artwork and Lock; the Line Segment tool shows no bar. Not done: Shape Properties for a star, which the app draws as a plain path, and Gen Shape Fill and Generate Vectors, which the app doesn't have. Evidence: `shape_tools_show_edit_path_paint_and_properties_after_drawing`, `shape_tools_have_no_shape_bar_without_a_single_shape` and `shape_tool_bar_retargets_after_another_shape_and_undo` in `crates/ui-egui/src/tests/taskbar.rs`. - While the Smooth tool is in use with a path it can smooth selected (a path with three or more anchors, or two joined by a curve, on its own or inside a selected group), the contextual task bar shows the tool's Fidelity field and Tool Options…, which opens the Smooth tool's options. The overview says the Smooth tool's bar has its tool options (), and the tool's help page names Fidelity as its option (). A value typed or stepped in the field sets the tool's Fidelity through `tool.setOption`, with the same range, unit (screen pixels) and steps as the field in its options. VectorCraft's own rules: with nothing selected, or only straight lines or type selected, the tool shows no bar; the bar leaves out the selection tools' actions, the Fill and Stroke chips, Recolor Artwork and Lock; on a canvas too narrow for the field, More Options lists Fidelity, which opens the tool's options. Evidence: `the_smooth_tool_shows_fidelity_and_tool_options_for_a_path` and `the_smooth_tool_shows_no_bar_without_a_path_to_smooth` in `crates/ui-egui/src/tests/taskbar.rs`. - The contextual task bar has a Stroke chip beside the Fill chip, drawn with the paint the Stroke proxy shows (a "?" when the selected objects' strokes differ, as on the Fill chip); a click brings the Stroke proxy forward and shows the Swatches panel wherever it is docked, floating or closed, as a click on the Fill chip does for the Fill proxy. The reference app's bar has Fill and Stroke controls for changing an object's colors ([Contextual Task Bar overview](https://helpx.adobe.com/illustrator/desktop/get-started/learn-the-basics/contextual-task-bar-overview.html)). Evidence: `the_task_bar_shows_a_stroke_chip_beside_fill` and `the_task_bar_chips_follow_the_proxies_and_show_swatches_anywhere` in `crates/ui-egui/src/canvas/tests.rs`.