DesignCraft: An open-source page and layout design editor written by scratch in pure Rust
Tools: live corners round a frame's corners by dragging
aiongg3bda745a520e
diff --git a/ROADMAP.md b/ROADMAP.mdindex 0d1c1ef5e..78dac7edb 100644--- a/ROADMAP.md+++ b/ROADMAP.md@@ -129,6 +129,8 @@ list) · [roadmap.md](docs/roadmap.md) (milestones, plan) · [parity-checklist.mNewest first.+- **2026-10-11** · Live corners: the yellow widget on a selected rectangle frame shows corner+ diamonds; dragging one rounds the corners, Alt-click steps the corner shape (#186).- **2026-10-10** · Version 0.6.0; releases add a Linux riscv64 tar.gz (cross-compiled, CLIsmoke-tested under QEMU).- **2026-10-10** · Readiness per audience: full ~47% (method aligned with the standard, wasdiff --git a/crates/engine/src/cmd/object.rs b/crates/engine/src/cmd/object.rsindex 17c44c27a..afc8db384 100644--- a/crates/engine/src/cmd/object.rs+++ b/crates/engine/src/cmd/object.rs@@ -498,14 +498,9 @@ pub fn specs() -> Vec<CommandSpec> {"Corner Options…",["Object"],None,- "{shape: none|rounded|inverseRounded|inset|bevel|fancy, size, ids?}",+ "{shape: none|rounded|inverseRounded|inset|bevel|fancy, size, corners?: [{shape, size}] (4 entries in path order: top-left, top-right, bottom-right, bottom-left; replaces shape and size), ids?}",has_selection,- |s, p| {- let shape =- p.get("shape").and_then(|v| serde_json::from_value(v.clone()).ok()).unwrap_or(designcraft_geom::corners::CornerShape::Rounded);- let size = f64_or(p, "size", 12.0);- set_flag(s, p, move |i| i.corners = designcraft_geom::corners::CornerOptions::uniform(shape, size), false)- }+ corner_options),cmd!("object.textWrap",@@ -1352,6 +1347,25 @@ fn ungroup(s: &mut Session, p: &Value) -> Result<Value> {})}+fn corner_options(s: &mut Session, p: &Value) -> Result<Value> {+ use designcraft_geom::corners::{Corner, CornerOptions, CornerShape};+ let opts = match p.get("corners") {+ Some(v) => {+ let corners: [Corner; 4] =+ serde_json::from_value(v.clone()).map_err(|e| bad("object.cornerOptions", format!("corners: four {{shape, size}} entries ({e})")))?;+ if corners.iter().any(|c| !c.size.is_finite() || c.size < 0.0) {+ return Err(bad("object.cornerOptions", "corner sizes must be finite and not negative"));+ }+ CornerOptions { corners }+ }+ None => {+ let shape = p.get("shape").and_then(|v| serde_json::from_value(v.clone()).ok()).unwrap_or(CornerShape::Rounded);+ CornerOptions::uniform(shape, f64_or(p, "size", 12.0))+ }+ };+ set_flag(s, p, move |i| i.corners = opts, false)+}+fn set_flag(s: &mut Session, p: &Value, f: impl Fn(&mut Item), deselect: bool) -> Result<Value> {let ids = targets(s, p)?;s.edit(|d, sel| {diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rsindex c1032bccf..9a1707f0e 100644--- a/crates/engine/src/tests.rs+++ b/crates/engine/src/tests.rs@@ -561,3 +561,42 @@ fn commands_take_non_object_params_without_panicking() {assert!(r.is_ok(), "{p}: {r:?}");}}++#[test]+fn live_corner_gestures_are_one_undo_step_each() {+ use designcraft_geom::corners::CornerShape;+ use designcraft_tools::{Mods, PointerEvent, PointerKind};+ let mut s = session();+ s.execute("frame.create", &json!({"rect": [100, 100, 300, 250], "content": "graphic"})).unwrap();+ let id = s.doc().unwrap().doc.spreads[0].items[0].id;+ s.execute("selection.set", &json!({"ids": [id.0]})).unwrap();+ s.set_tool("selection");+ let v = ViewInfo::at_zoom(1.0);+ let undo = |s: &Session| s.doc().unwrap().history.undo.len();+ let corners = |s: &Session| s.doc().unwrap().doc.item(id).unwrap().corners.corners;+ let before = undo(&s);+ // Click the widget, then drag the top-left diamond 20 pt toward the centre.+ s.pointer(&PointerEvent::new(PointerKind::Down, 300.0, 111.5), v).unwrap();+ s.pointer(&PointerEvent::new(PointerKind::Up, 300.0, 111.5), v).unwrap();+ s.pointer(&PointerEvent::new(PointerKind::Down, 112.0, 100.0), v).unwrap();+ for x in [116.0, 124.0, 132.0] {+ s.pointer(&PointerEvent::new(PointerKind::Drag, x, 100.0), v).unwrap();+ }+ s.pointer(&PointerEvent::new(PointerKind::Up, 132.0, 100.0), v).unwrap();+ assert_eq!(undo(&s), before + 1);+ assert!(corners(&s).iter().all(|c| c.shape == CornerShape::Rounded && (c.size - 20.0).abs() < 1e-9), "{:?}", corners(&s));+ // Alt-click the top-left diamond, now 20 pt along the edge.+ let alt = Mods { alt: true, ..Default::default() };+ s.pointer(&PointerEvent::new(PointerKind::Down, 120.0, 100.0).with_mods(alt), v).unwrap();+ s.pointer(&PointerEvent::new(PointerKind::Up, 120.0, 100.0).with_mods(alt), v).unwrap();+ assert_eq!(undo(&s), before + 2);+ assert_eq!(corners(&s)[0].shape, CornerShape::InverseRounded);+ assert_eq!(corners(&s)[1].shape, CornerShape::Rounded);+ s.execute("edit.undo", &json!({})).unwrap();+ assert_eq!(corners(&s)[0].shape, CornerShape::Rounded);+ // Malformed per-corner parameters are errors, not silent defaults.+ let c = json!({"shape": "rounded", "size": 5});+ assert!(s.execute("object.cornerOptions", &json!({"corners": [c, c, c]})).is_err());+ assert!(s.execute("object.cornerOptions", &json!({"corners": [c, c, c, {"shape": "rounded", "size": -1}]})).is_err());+ assert!(s.execute("object.cornerOptions", &json!({"corners": "rounded"})).is_err());+}diff --git a/crates/engine/src/tooling.rs b/crates/engine/src/tooling.rsindex 1bf8db930..508e767fa 100644--- a/crates/engine/src/tooling.rs+++ b/crates/engine/src/tooling.rs@@ -138,6 +138,7 @@ impl Session {Action::Dialog(id, params) => self.ui_requests.push(UiRequest::Dialog { id, params }),Action::SwitchTool(id) => self.set_tool(&id),Action::View(params) => self.ui_requests.push(UiRequest::View { params }),+ Action::Handled => {}}}Ok(())diff --git a/crates/tools/src/corners.rs b/crates/tools/src/corners.rsnew file mode 100644index 000000000..48f6dca84--- /dev/null+++ b/crates/tools/src/corners.rs@@ -0,0 +1,191 @@+//! Live corners: the yellow widget on a selected rectangle frame and the four corner diamonds.+//!+//! Geometry works in the frame's local coordinates (the space its path and corner sizes live in)+//! and maps through the frame's canvas transform, so rotated and sheared frames work unchanged.++use designcraft_doc::{ItemId, Shape};+use designcraft_geom::corners::{Corner, CornerOptions, CornerShape};+use designcraft_geom::{Affine, Point, Vec2};+use serde_json::{Value, json};++use crate::ToolContext;++/// Screen distance of the widget below the frame's top-right corner, along the right edge.+const WIDGET_OFFSET_PX: f64 = 11.5;+/// Both sides of the frame must be at least this long on screen to show the widget.+const MIN_SIDE_PX: f64 = 40.0;+/// Diamonds stay at least this far (screen) from their corner, clear of the resize handles.+const DIAMOND_MIN_PX: f64 = 12.0;+/// Hit radius of the widget and the diamonds.+pub(crate) const HIT_PX: f64 = 5.0;+/// Corner size an Alt-click gives a corner that has none.+const DEFAULT_SIZE: f64 = 12.0;+/// Shapes an Alt-click steps through.+const CYCLE: [CornerShape; 5] = [CornerShape::Rounded, CornerShape::InverseRounded, CornerShape::Inset, CornerShape::Bevel, CornerShape::Fancy];++/// A selected rectangle frame that can show live corners.+#[derive(Clone, Debug)]+pub(crate) struct LiveFrame {+ pub id: ItemId,+ /// Local → canvas.+ pub m: Affine,+ /// Path corners in path order (top-left, top-right, bottom-right, bottom-left for a new rectangle).+ pub pts: [Point; 4],+ pub corners: CornerOptions,+}++/// The single selected, unlocked rectangle frame, when it is large enough on screen.+pub(crate) fn live_frame(cx: &ToolContext) -> Option<LiveFrame> {+ let [id] = cx.selection.items.as_slice() else { return None };+ if cx.selection.text.is_some() {+ return None;+ }+ let it = cx.doc.item(*id)?;+ let layer_locked = cx.doc.layer(it.layer).is_some_and(|l| l.locked);+ if !matches!(it.shape, Shape::Rectangle) || !it.children().is_empty() || it.locked || layer_locked {+ return None;+ }+ let [sp] = it.path.subpaths.as_slice() else { return None };+ let [a, b, c, d] = sp.anchors.as_slice() else { return None };+ if !sp.closed || sp.anchors.iter().any(|a| a.has_in() || a.has_out()) {+ return None;+ }+ let m = cx.item_canvas_xf(*id)? * it.xf;+ let det = m.determinant();+ if !det.is_finite() || det.abs() < 1e-12 {+ return None;+ }+ let pts = [a.p, b.p, c.p, d.p];+ let short = (0..4).map(|i| ((m * pts[i]) - (m * pts[(i + 1) % 4])).hypot()).fold(f64::INFINITY, f64::min);+ if short.is_nan() || short * cx.zoom < MIN_SIDE_PX {+ return None;+ }+ Some(LiveFrame { id: *id, m, pts, corners: it.corners })+}++impl LiveFrame {+ /// The other end of the edge corner `i` slides along: corners 0 and 1 share one edge, 2 and 3 the opposite one.+ fn neighbour(i: usize) -> usize {+ if i.is_multiple_of(2) { (i + 1) % 4 } else { (i + 3) % 4 }+ }++ /// Unit direction (local) from corner `i` along its edge, and that edge's local length.+ fn edge(&self, i: usize) -> Option<(Vec2, f64)> {+ let p = *self.pts.get(i)?;+ let q = *self.pts.get(Self::neighbour(i))?;+ let len = (q - p).hypot();+ (len.is_finite() && len > 1e-9).then(|| ((q - p) / len, len))+ }++ /// Largest corner size: half the shorter side.+ pub fn max_size(&self) -> f64 {+ (0..4).map(|i| (self.pts[(i + 1) % 4] - self.pts[i]).hypot()).fold(f64::INFINITY, f64::min) / 2.0+ }++ /// Corner `i`'s effective size (0 without a shape), clamped to the frame.+ pub fn size(&self, i: usize) -> f64 {+ self.corners.corners.get(i).filter(|c| !c.is_none()).map_or(0.0, |c| c.size.clamp(0.0, self.max_size().max(0.0)))+ }++ /// The widget's canvas position: on the right edge, a little below the top-right corner.+ pub fn widget(&self, zoom: f64) -> Point {+ let (mut x1, mut y0) = (f64::NEG_INFINITY, f64::INFINITY);+ for p in &self.pts {+ x1 = x1.max(p.x);+ y0 = y0.min(p.y);+ }+ let tr = self.m * Point::new(x1, y0);+ let down = (self.m * Point::new(x1, y0 + 1.0)) - tr;+ let len = down.hypot();+ if len.is_nan() || len <= 1e-12 {+ return tr;+ }+ tr + down / len * (WIDGET_OFFSET_PX / zoom.max(1e-9))+ }++ /// Canvas positions of the four diamonds: each at its corner size along its edge, but at least+ /// a few screen pixels from the corner.+ pub fn diamonds(&self, zoom: f64) -> Vec<Point> {+ (0..4)+ .filter_map(|i| {+ let (u, len) = self.edge(i)?;+ let p = self.pts[i];+ let per_unit = ((self.m * (p + u)) - (self.m * p)).hypot();+ let min = if per_unit > 1e-12 { DIAMOND_MIN_PX / zoom.max(1e-9) / per_unit } else { 0.0 };+ let d = self.size(i).max(min).min(len / 2.0);+ Some(self.m * (p + u * d))+ })+ .collect()+ }++ /// Index of the diamond under canvas point `p`.+ pub fn diamond_at(&self, p: Point, zoom: f64, tol: f64) -> Option<usize> {+ let ds = self.diamonds(zoom);+ if ds.len() != 4 {+ return None;+ }+ ds.iter().enumerate().map(|(i, d)| (i, (*d - p).hypot())).filter(|(_, dist)| *dist <= tol).min_by(|a, b| a.1.total_cmp(&b.1)).map(|(i, _)| i)+ }++ /// Change of corner size when the pointer moves from `start` to `p` (canvas) while dragging+ /// corner `i`: the movement along that corner's edge, in local units.+ pub fn drag_delta(&self, i: usize, start: Point, p: Point) -> Option<f64> {+ let (u, _) = self.edge(i)?;+ let inv = self.m.inverse();+ let d = ((inv * p) - (inv * start)).dot(u);+ d.is_finite().then_some(d)+ }++ /// Options after dragging corner `i` to `size`: every corner takes that size, or only corner+ /// `i` with `only`. A corner without a shape becomes rounded.+ pub fn dragged(&self, i: usize, size: f64, only: bool) -> CornerOptions {+ let size = size.clamp(0.0, self.max_size().max(0.0));+ let mut out = self.corners;+ for (k, c) in out.corners.iter_mut().enumerate() {+ if only && k != i {+ continue;+ }+ if c.shape == CornerShape::None {+ c.shape = CornerShape::Rounded;+ }+ c.size = size;+ }+ out+ }++ /// Options after an Alt-click on corner `i`: that corner (or every corner, with `all`) takes+ /// the shape after corner `i`'s. A corner without a size gets a default one.+ pub fn cycled(&self, i: usize, all: bool) -> CornerOptions {+ let cur = self.corners.corners.get(i).map_or(CornerShape::None, |c| c.shape);+ let next = CYCLE.iter().position(|s| *s == cur).map_or(CornerShape::Rounded, |k| CYCLE[(k + 1) % CYCLE.len()]);+ let fallback = DEFAULT_SIZE.min(self.max_size().max(0.0));+ let mut out = self.corners;+ for (k, c) in out.corners.iter_mut().enumerate() {+ if !all && k != i {+ continue;+ }+ c.shape = next;+ if c.size.is_nan() || c.size <= 0.0 {+ c.size = fallback;+ }+ }+ out+ }+}++fn shape_id(s: CornerShape) -> &'static str {+ match s {+ CornerShape::None => "none",+ CornerShape::Rounded => "rounded",+ CornerShape::InverseRounded => "inverseRounded",+ CornerShape::Inset => "inset",+ CornerShape::Bevel => "bevel",+ CornerShape::Fancy => "fancy",+ }+}++/// `object.cornerOptions` parameters that set every corner of item `id`.+pub(crate) fn params(id: ItemId, opts: &CornerOptions) -> Value {+ let corners: Vec<Value> = opts.corners.iter().map(|c: &Corner| json!({"shape": shape_id(c.shape), "size": c.size})).collect();+ json!({"ids": [id.0], "corners": corners})+}diff --git a/crates/tools/src/lib.rs b/crates/tools/src/lib.rsindex 247494f84..1cbb63b04 100644--- a/crates/tools/src/lib.rs+++ b/crates/tools/src/lib.rs@@ -11,6 +11,7 @@mod anchors;pub mod catalog;+mod corners;mod frame;mod gradient;pub mod layout;@@ -105,6 +106,8 @@ pub enum Action {SwitchTool(String),/// Ask the UI to pan/zoom: `{"pan":[dx,dy]}` (screen px) or `{"zoomAt":[x,y], "factor":f}` (canvas).View(Value),+ /// The tool used the event for its own state; the engine has nothing to do.+ Handled,}/// Which snap categories are on, and the snap zone in screen pixels.@@ -309,6 +312,10 @@ pub enum Overlay {b: Point,label: String,},+ /// The live-corner widget (yellow square): clicking it starts corner editing.+ LiveCornerWidget(Point),+ /// A live-corner diamond: dragging it sets the corner size.+ LiveCornerDiamond(Point),}/// Correction from a snap, in spread coordinates for `delta`.diff --git a/crates/tools/src/select.rs b/crates/tools/src/select.rsindex 8f59c3503..8a1198f97 100644--- a/crates/tools/src/select.rs+++ b/crates/tools/src/select.rs@@ -3,11 +3,15 @@//! Click selects the frontmost item (Shift toggles), drag moves (Alt duplicates, Shift constrains),//! the 8 bounding-box handles resize (Shift keeps proportions, Alt from centre, Cmd scales content),//! empty-canvas drags make a marquee, double-clicking a text frame switches to the Type tool.+//! A selected rectangle frame shows the live-corner widget: clicking it shows a diamond at each+//! corner; dragging a diamond sets the corner size (Shift: that corner only), Alt-clicking one+//! steps its shape (Shift+Alt: every corner). Escape or clicking empty canvas ends corner editing.use designcraft_doc::{ItemId, SpreadRef};use designcraft_geom::{Affine, Point, Rect, Vec2};use serde_json::{Value, json};+use crate::corners::{self, LiveFrame};use crate::{Action, Cursor, Gesture, Mods, Overlay, PointerEvent, PointerKind, SnapRequest, Tool, ToolContext, ToolKey, rect_json, spread_json};#[derive(Clone, Debug)]@@ -38,6 +42,13 @@ enum Drag {start: Point,cur: Point,},+ /// Dragging live-corner diamond `corner`. `frame` is read at pointer down: during the drag+ /// the document is the previous preview.+ Corner {+ frame: LiveFrame,+ corner: usize,+ start: Point,+ },Anchor {id: u64,si: usize,@@ -100,11 +111,37 @@ pub struct SelectionTool {guides: Vec<Overlay>,/// Selected item to toggle if this Shift press never becomes a drag.shift_release: Option<u64>,+ /// Frame whose live corners are being edited (diamonds shown).+ live: Option<ItemId>,}impl SelectionTool {pub fn new(direct: bool) -> Self {- Self { direct, drag: Drag::None, hover_handle: None, guides: vec![], shift_release: None }+ Self { direct, drag: Drag::None, hover_handle: None, guides: vec![], shift_release: None, live: None }+ }++ /// The frame in live-corner editing, while it is still the selection.+ fn live_corners(&self, cx: &ToolContext) -> Option<LiveFrame> {+ let id = self.live?;+ corners::live_frame(cx).filter(|f| f.id == id)+ }++ /// The frame whose live-corner widget is under `p` (not while editing its corners).+ fn widget_at(&self, cx: &ToolContext, p: Point) -> Option<LiveFrame> {+ if self.direct || self.live_corners(cx).is_some() {+ return None;+ }+ corners::live_frame(cx).filter(|f| (f.widget(cx.zoom) - p).hypot() <= cx.tol(corners::HIT_PX))+ }++ /// The frame and the index of the live-corner diamond under `p`.+ fn diamond_at(&self, cx: &ToolContext, p: Point) -> Option<(LiveFrame, usize)> {+ if self.direct {+ return None;+ }+ let f = self.live_corners(cx)?;+ let i = f.diamond_at(p, cx.zoom, cx.tol(corners::HIT_PX))?;+ Some((f, i))}}@@ -371,6 +408,12 @@ impl Tool for SelectionTool {fn pointer(&mut self, cx: &ToolContext, ev: &PointerEvent) -> Vec<Action> {let p = ev.pos;+ // Selecting something else ends live-corner editing.+ if let Some(id) = self.live+ && cx.selection.items != [id]+ {+ self.live = None;+ }match ev.kind {PointerKind::Move => {self.hover_handle = handle_at(cx, p);@@ -385,6 +428,20 @@ impl Tool for SelectionTool {self.drag = Drag::Anchor { id, si, ai, handle, start: p, at };return vec![Action::Begin(if handle.is_some() { "Move Direction Handle".into() } else { "Move Anchor".into() })];}+ if let Some((frame, corner)) = self.diamond_at(cx, p) {+ if ev.mods.alt {+ self.drag = Drag::None;+ let opts = frame.cycled(corner, ev.mods.shift);+ return vec![Action::Exec("object.cornerOptions".into(), corners::params(frame.id, &opts))];+ }+ self.drag = Drag::Corner { frame, corner, start: p };+ return vec![Action::Begin("Corner Options".into())];+ }+ if let Some(frame) = self.widget_at(cx, p) {+ self.live = Some(frame.id);+ self.drag = Drag::None;+ return vec![Action::Handled];+ }if !self.direct&& handle_at(cx, p).is_none()&& let Some(center) = rotate_zone(cx, p)@@ -431,6 +488,7 @@ impl Tool for SelectionTool {out}None => {+ self.live = None;self.drag = Drag::Pending { start: p, hit: false };if ev.mods.shift { vec![] } else { vec![Action::Exec("selection.set".into(), json!({"ids": []}))] }}@@ -592,6 +650,11 @@ impl Tool for SelectionTool {self.drag = Drag::Marquee { start, cur: p };vec![]}+ Drag::Corner { frame, corner, start } => {+ let Some(d) = frame.drag_delta(corner, start, p) else { return vec![] };+ let opts = frame.dragged(corner, frame.size(corner) + d, ev.mods.shift);+ vec![Action::Preview("object.cornerOptions".into(), corners::params(frame.id, &opts))]+ }Drag::Rotate { center, start_angle, start_rotation } => {let mut a = ((p - center).atan2() - start_angle).to_degrees();self.guides.clear();@@ -682,7 +745,7 @@ impl Tool for SelectionTool {let release = self.shift_release.take();let d = std::mem::replace(&mut self.drag, Drag::None);match d {- Drag::Move { .. } | Drag::Resize { .. } | Drag::Anchor { .. } | Drag::Rotate { .. } => vec![Action::Commit],+ Drag::Move { .. } | Drag::Resize { .. } | Drag::Anchor { .. } | Drag::Rotate { .. } | Drag::Corner { .. } => vec![Action::Commit],Drag::Pending { .. } => match release {Some(id) => vec![Action::Exec("selection.toggle".into(), json!({"id": id}))],None => vec![],@@ -724,6 +787,9 @@ impl Tool for SelectionTool {fn key(&mut self, cx: &ToolContext, key: ToolKey, mods: Mods) -> Vec<Action> {let inc = cx.doc.settings.keyboard_increment * if mods.shift { 10.0 } else { 1.0 };+ if key == ToolKey::Escape && self.live.take().is_some_and(|id| cx.selection.items == [id]) {+ return vec![Action::Handled];+ }let mv = |dx: f64, dy: f64| vec![Action::Exec("transform.move".into(), json!({"dx": dx, "dy": dy, "copy": mods.alt}))];if cx.selection.items.is_empty() {return vec![];@@ -739,12 +805,20 @@ impl Tool for SelectionTool {}}- fn overlays(&self, _cx: &ToolContext) -> Vec<Overlay> {- match &self.drag {+ fn overlays(&self, cx: &ToolContext) -> Vec<Overlay> {+ let mut out = match &self.drag {Drag::Marquee { start, cur } => vec![Overlay::Marquee(Rect::from_points(*start, *cur))],Drag::Move { .. } | Drag::Resize { .. } | Drag::Rotate { .. } | Drag::Anchor { .. } => self.guides.clone(),_ => vec![],+ };+ if !self.direct {+ if let Some(f) = self.live_corners(cx) {+ out.extend(f.diamonds(cx.zoom).into_iter().map(Overlay::LiveCornerDiamond));+ } else if let Some(f) = corners::live_frame(cx) {+ out.push(Overlay::LiveCornerWidget(f.widget(cx.zoom)));+ }}+ out}fn cursor(&self, cx: &ToolContext, p: Point, _m: Mods) -> Cursor {@@ -755,8 +829,12 @@ impl Tool for SelectionTool {Drag::Move { .. } => return Cursor::Move,Drag::Resize { handle, .. } => return handle_cursor(handle),Drag::Rotate { .. } => return Cursor::Rotate,+ Drag::Corner { .. } => return Cursor::Arrow,_ => {}}+ if self.diamond_at(cx, p).is_some() || self.widget_at(cx, p).is_some() {+ return Cursor::Arrow;+ }match handle_at(cx, p) {Some(h) => handle_cursor(h),None if rotate_zone(cx, p).is_some() => Cursor::Rotate,diff --git a/crates/tools/src/tests.rs b/crates/tools/src/tests.rsindex 6c75b0da6..8fe9d9bd2 100644--- a/crates/tools/src/tests.rs+++ b/crates/tools/src/tests.rs@@ -705,3 +705,145 @@ fn pen_click_snaps_to_a_guide() {let x = p["anchors"][0]["p"][0].as_f64().unwrap();assert!((x - 100.0).abs() < 1e-6, "anchor x {x}");}++/// A 200 × 150 pt rectangle frame, selected.+fn live_corner_doc() -> (Document, ItemId) {+ let mut d = Document::new(&NewDocument::default());+ let id = add_rect(&mut d, Rect::new(100.0, 100.0, 300.0, 250.0));+ (d, id)+}++fn corner_preview(a: &[Action]) -> Vec<(String, f64)> {+ let p = match a {+ [Action::Preview(cmd, p)] | [Action::Exec(cmd, p)] if cmd == "object.cornerOptions" => p,+ other => panic!("{other:?}"),+ };+ p["corners"].as_array().unwrap().iter().map(|c| (c["shape"].as_str().unwrap().to_string(), c["size"].as_f64().unwrap())).collect()+}++fn diamonds(o: &[Overlay]) -> Vec<Point> {+ o.iter().filter_map(|o| if let Overlay::LiveCornerDiamond(p) = o { Some(*p) } else { None }).collect()+}++#[test]+fn live_corners_click_widget_then_drag_rounds_all_corners() {+ let (d, id) = live_corner_doc();+ let s = Selection { items: vec![id], ..Default::default() };+ let (c, l) = (Cache::new(), CanvasLayout::new(&d, false));+ let cx = ctx(&d, &s, &c, &l);+ let at = |x, y| spread_pt(&l, x, y);+ let mut t = create("selection");+ // The widget sits on the right edge, a little below the top-right corner.+ let w = at(300.0, 111.5);+ assert!(t.overlays(&cx).iter().any(|o| matches!(o, Overlay::LiveCornerWidget(p) if near(*p, w))));+ assert!(diamonds(&t.overlays(&cx)).is_empty());+ assert_eq!(t.pointer(&cx, &PointerEvent::new(PointerKind::Down, w.x, w.y)), vec![Action::Handled]);+ assert!(t.pointer(&cx, &PointerEvent::new(PointerKind::Up, w.x, w.y)).is_empty());+ // Without corner sizes the diamonds sit 12 px along the top and bottom edges.+ let want = [at(112.0, 100.0), at(288.0, 100.0), at(288.0, 250.0), at(112.0, 250.0)];+ let got = diamonds(&t.overlays(&cx));+ assert!(got.len() == 4 && got.iter().zip(want).all(|(g, w)| near(*g, w)), "{got:?}");+ assert!(!t.overlays(&cx).iter().any(|o| matches!(o, Overlay::LiveCornerWidget(_))));+ // Drag the top-left diamond 20 pt toward the centre.+ let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Down, want[0].x, want[0].y));+ assert_eq!(a, vec![Action::Begin("Corner Options".into())]);+ let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, want[0].x + 20.0, want[0].y + 3.0));+ assert_eq!(corner_preview(&a), vec![("rounded".to_string(), 20.0); 4]);+ // The size stops at half the shorter side.+ let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, want[0].x + 500.0, want[0].y));+ assert_eq!(corner_preview(&a), vec![("rounded".to_string(), 75.0); 4]);+ assert_eq!(t.pointer(&cx, &PointerEvent::new(PointerKind::Up, want[0].x + 500.0, want[0].y)), vec![Action::Commit]);+}++#[test]+fn live_corners_shift_drag_and_alt_click_change_one_corner() {+ let (mut d, id) = live_corner_doc();+ d.item_mut(id).unwrap().corners = designcraft_geom::corners::CornerOptions::uniform(designcraft_geom::corners::CornerShape::Rounded, 30.0);+ let s = Selection { items: vec![id], ..Default::default() };+ let (c, l) = (Cache::new(), CanvasLayout::new(&d, false));+ let cx = ctx(&d, &s, &c, &l);+ let at = |x, y| spread_pt(&l, x, y);+ let mut t = create("selection");+ let w = at(300.0, 111.5);+ t.pointer(&cx, &PointerEvent::new(PointerKind::Down, w.x, w.y));+ t.pointer(&cx, &PointerEvent::new(PointerKind::Up, w.x, w.y));+ // With 30 pt corners the diamonds sit 30 pt along the edges.+ let tr = at(270.0, 100.0);+ assert!(diamonds(&t.overlays(&cx)).iter().any(|p| near(*p, tr)));+ let shift = Mods { shift: true, ..Default::default() };+ t.pointer(&cx, &PointerEvent::new(PointerKind::Down, tr.x, tr.y).with_mods(shift));+ let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, tr.x - 10.0, tr.y).with_mods(shift));+ let r = |n: f64| ("rounded".to_string(), n);+ assert_eq!(corner_preview(&a), vec![r(30.0), r(40.0), r(30.0), r(30.0)]);+ t.pointer(&cx, &PointerEvent::new(PointerKind::Up, tr.x - 10.0, tr.y));+ // Alt-click steps the bottom-right corner's shape; Shift+Alt steps every corner.+ let br = at(270.0, 250.0);+ let alt = Mods { alt: true, ..Default::default() };+ let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Down, br.x, br.y).with_mods(alt));+ assert_eq!(corner_preview(&a), vec![r(30.0), r(30.0), ("inverseRounded".to_string(), 30.0), r(30.0)]);+ assert!(t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, br.x - 30.0, br.y).with_mods(alt)).is_empty());+ assert!(t.pointer(&cx, &PointerEvent::new(PointerKind::Up, br.x - 30.0, br.y)).is_empty());+ let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Down, br.x, br.y).with_mods(Mods { alt: true, shift: true, ..Default::default() }));+ assert_eq!(corner_preview(&a), vec![("inverseRounded".to_string(), 30.0); 4]);+}++#[test]+fn live_corners_end_on_escape_empty_click_and_other_selection() {+ let (mut d, id) = live_corner_doc();+ let other = add_rect(&mut d, Rect::new(400.0, 100.0, 500.0, 200.0));+ let s = Selection { items: vec![id], ..Default::default() };+ let (c, l) = (Cache::new(), CanvasLayout::new(&d, false));+ let cx = ctx(&d, &s, &c, &l);+ let w = spread_pt(&l, 300.0, 111.5);+ let mut t = create("selection");+ let enter = |t: &mut Box<dyn Tool>| {+ t.pointer(&cx, &PointerEvent::new(PointerKind::Down, w.x, w.y));+ t.pointer(&cx, &PointerEvent::new(PointerKind::Up, w.x, w.y));+ assert_eq!(diamonds(&t.overlays(&cx)).len(), 4);+ };+ // Escape leaves corner editing and keeps the selection; the next Escape deselects.+ enter(&mut t);+ assert_eq!(t.key(&cx, ToolKey::Escape, Mods::default()), vec![Action::Handled]);+ assert!(diamonds(&t.overlays(&cx)).is_empty());+ assert_eq!(t.key(&cx, ToolKey::Escape, Mods::default()), vec![Action::Exec("selection.set".into(), serde_json::json!({"ids": []}))]);+ // A click on empty canvas.+ enter(&mut t);+ let e = spread_pt(&l, 350.0, 400.0);+ t.pointer(&cx, &PointerEvent::new(PointerKind::Down, e.x, e.y));+ t.pointer(&cx, &PointerEvent::new(PointerKind::Up, e.x, e.y));+ assert!(diamonds(&t.overlays(&cx)).is_empty());+ // Another selection.+ enter(&mut t);+ let s2 = Selection { items: vec![other], ..Default::default() };+ let cx2 = ctx(&d, &s2, &c, &l);+ assert!(diamonds(&t.overlays(&cx2)).is_empty());+ t.pointer(&cx2, &PointerEvent::new(PointerKind::Move, 0.0, 0.0));+ assert!(diamonds(&t.overlays(&cx)).is_empty());+ // A frame too small on screen has no widget.+ let mut far = ctx(&d, &s, &c, &l);+ far.zoom = 0.1;+ assert!(!t.overlays(&far).iter().any(|o| matches!(o, Overlay::LiveCornerWidget(_))));+}++#[test]+fn live_corner_diamonds_follow_a_rotated_frame() {+ let mut d = Document::new(&NewDocument::default());+ let id = add_rotated(&mut d, Rect::new(100.0, 100.0, 300.0, 250.0), 30.0);+ let s = Selection { items: vec![id], ..Default::default() };+ let (c, l) = (Cache::new(), CanvasLayout::new(&d, false));+ let cx = ctx(&d, &s, &c, &l);+ let m = l.xf(SpreadRef::Doc(0)) * d.item(id).unwrap().xf;+ let mut t = create("selection");+ // The widget: 11.5 pt from the top-right corner along the turned right edge.+ let w = m * Point::new(300.0, 111.5);+ t.pointer(&cx, &PointerEvent::new(PointerKind::Down, w.x, w.y));+ t.pointer(&cx, &PointerEvent::new(PointerKind::Up, w.x, w.y));+ let tl = m * Point::new(112.0, 100.0);+ assert!(diamonds(&t.overlays(&cx)).iter().any(|p| near(*p, tl)), "{:?}", t.overlays(&cx));+ // Dragging along the turned top edge sets the size.+ t.pointer(&cx, &PointerEvent::new(PointerKind::Down, tl.x, tl.y));+ let to = m * Point::new(137.0, 100.0);+ let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, to.x, to.y));+ let got = corner_preview(&a);+ assert!(got.iter().all(|(shape, size)| shape == "rounded" && (size - 25.0).abs() < 1e-6), "{got:?}");+}diff --git a/crates/ui-egui/src/canvas.rs b/crates/ui-egui/src/canvas.rsindex 34dd61442..d1f892594 100644--- a/crates/ui-egui/src/canvas.rs+++ b/crates/ui-egui/src/canvas.rs@@ -771,6 +771,13 @@ fn draw_item_edges(painter: &egui::Painter, xf: &Xf, doc: &Document, it: &Item,}}+/// Layer colour of the first selected item: live-corner marks are outlined in it.+fn selection_color(app: &DesignApp) -> Color32 {+ let fallback = Color32::from_rgb(79, 153, 255);+ let Some(st) = app.session.active() else { return fallback };+ st.selection.items.first().and_then(|id| st.doc.item(*id)).map_or(fallback, |it| layer_color(&st.doc, it))+}+fn layer_color(doc: &Document, it: &Item) -> Color32 {doc.layer(it.layer).map(|l| c32(l.color)).unwrap_or(Color32::from_rgb(79, 153, 255))}@@ -849,15 +856,8 @@ fn draw_selection(app: &DesignApp, painter: &egui::Painter, xf: &Xf, doc: &Documpainter.rect_stroke(u, 0.0, Stroke::new(1.0, color), StrokeKind::Middle);}let hs = 6.5;- // Centre point and the live-corner widget.+ // Centre point. The Selection tool draws the live-corner widget as an overlay.painter.rect_filled(Rect::from_center_size(u.center(), vec2(3.5, 3.5)), 0.0, color);- if sel.items.len() == 1- && doc.item(sel.items[0]).is_some_and(|i| matches!(i.shape, designcraft_doc::Shape::Rectangle) && i.children().is_empty())- {- let lc = Rect::from_center_size(pos2(u.max.x, u.min.y + 11.5), vec2(6.0, 6.0));- painter.rect_filled(lc, 0.0, Color32::from_rgb(0xff, 0xe5, 0x00));- painter.rect_stroke(lc, 0.0, Stroke::new(1.0, color), StrokeKind::Inside);- }for h in designcraft_tools::select::handles(DRect::new(u.min.x as f64, u.min.y as f64, u.max.x as f64, u.max.y as f64)) {let r = Rect::from_center_size(pos2(h.x as f32, h.y as f32), vec2(hs, hs));painter.rect_filled(r, 0.0, Color32::WHITE);@@ -1171,6 +1171,7 @@ fn draw_tool_overlays(app: &mut DesignApp, painter: &egui::Painter, xf: &Xf) {}let tok = Tokens::get(painter.ctx());let ov = app.session.overlays(app.view_info());+ let sel_color = selection_color(app);for o in ov {match o {Overlay::Marquee(r) => {@@ -1212,6 +1213,17 @@ fn draw_tool_overlays(app: &mut DesignApp, painter: &egui::Painter, xf: &Xf) {painter.rect_filled(r, 3.0, tok.measure_bg);painter.galley(r.min + vec2(5.0, 3.0), g, tok.measure_text);}+ Overlay::LiveCornerWidget(p) => {+ let r = Rect::from_center_size(xf.to_screen(p), vec2(6.0, 6.0));+ painter.rect_filled(r, 0.0, tok.live_corner);+ painter.rect_stroke(r, 0.0, Stroke::new(1.0, sel_color), StrokeKind::Inside);+ }+ Overlay::LiveCornerDiamond(p) => {+ let c = xf.to_screen(p);+ let h = 4.5;+ let pts = vec![c + vec2(0.0, -h), c + vec2(h, 0.0), c + vec2(0.0, h), c + vec2(-h, 0.0)];+ painter.add(egui::Shape::convex_polygon(pts, tok.live_corner, Stroke::new(1.0, sel_color)));+ }Overlay::Path { .. } => {}}}@@ -1798,6 +1810,56 @@ mod tests {}}+ /// The live-corner widget draws on a selected rectangle frame; clicking it draws the diamonds.+ #[test]+ fn live_corner_widget_and_diamonds_draw() {+ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());+ app.run("file.new", json!({})).unwrap();+ app.run("frame.create", json!({"rect": [100, 100, 300, 250], "content": "graphic"})).unwrap();+ let id = app.session.doc().unwrap().doc.spreads[0].items[0].id;+ app.run("selection.set", json!({"ids": [id.0]})).unwrap();+ let mut h = Harness::builder().with_size(vec2(1440.0, 900.0)).with_pixels_per_point(1.0).wgpu().build_ui_state(+ |ui, app: &mut DesignApp| {+ let ctx = ui.ctx().clone();+ app.logic(&ctx);+ app.ui(ui);+ },+ app,+ );+ h.run_steps(4);+ let screen = |h: &Harness<'_, DesignApp>, x: f64, y: f64| {+ let app = h.state();+ let layout = CanvasLayout::new(&app.session.doc().unwrap().doc, false);+ let xf = Xf::new(app.canvas_rect.unwrap(), app.view().unwrap());+ xf.to_screen(layout.to_canvas(SpreadRef::Doc(0), Point::new(x, y)))+ };+ let widget = screen(&h, 300.0, 100.0) + vec2(0.0, 11.5);+ let diamond = screen(&h, 100.0, 100.0) + vec2(12.0, 0.0);+ let yellow = |h: &mut Harness<'_, DesignApp>, p: Pos2| -> Option<bool> {+ let img = match h.render() {+ Ok(img) => img,+ Err(e) => {+ eprintln!("skipped: no offscreen renderer ({e})");+ return None;+ }+ };+ let px = img.get_pixel(p.x.round() as u32, p.y.round() as u32).0;+ Some(px[0] > 200 && px[1] > 180 && px[2] < 100)+ };+ let Some(w) = yellow(&mut h, widget) else { return };+ assert!(w, "no widget at {widget:?}");+ assert_eq!(yellow(&mut h, diamond), Some(false));+ h.hover_at(widget);+ h.step();+ for pressed in [true, false] {+ h.event(egui::Event::PointerButton { pos: widget, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() });+ h.step();+ }+ h.run_steps(3);+ assert_eq!(yellow(&mut h, diamond), Some(true), "no diamond at {diamond:?}");+ assert_eq!(yellow(&mut h, widget), Some(false));+ }+#[test]fn rulers_open_no_units_menu_without_a_document() {let mut h = harness(DesignApp::new(designcraft_engine::Session::new(), crate::Services::default()));diff --git a/crates/ui-egui/src/theme.rs b/crates/ui-egui/src/theme.rsindex 3dd50180f..5f4cbf02e 100644--- a/crates/ui-egui/src/theme.rs+++ b/crates/ui-egui/src/theme.rs@@ -83,6 +83,8 @@ pub struct Tokens {/// Measurement labels on the canvas (smart dimensions, gaps).pub measure_bg: Color32,pub measure_text: Color32,+ /// Live-corner widget and corner diamonds.+ pub live_corner: Color32,}fn hex(s: u32) -> Color32 {@@ -125,6 +127,7 @@ impl Tokens {smart_guide: hex(0x00c853),measure_bg: Color32::from_rgba_unmultiplied(70, 70, 70, 230),measure_text: Color32::WHITE,+ live_corner: hex(0xffe500),};match b {Brightness::Dark => dark,diff --git a/docs/roadmap.md b/docs/roadmap.mdindex e738da950..17f09e555 100644--- a/docs/roadmap.md+++ b/docs/roadmap.md@@ -57,7 +57,7 @@ set exists; depth gaps are in gaps.md.| # | Milestone | State ||---|---|---|| M0 | Skeleton + vertical slice | ✅ |-| M1 | Selection, transform, layers, pages, MCP | ✅ core; handle and snapping issues (#186, #188, #337) |+| M1 | Selection, transform, layers, pages, MCP | ✅ core; handle and snapping issues (#188, #337) || M2 | Type I (Type tool, threading, Character/Paragraph, composer) | partial: Type tool and composer ✅; **manual threading missing** (alpha blocker); caret formatting (#289); no IME (#322) || M3 | Styles (nested/GREP, bullets, keeps, span columns) | ✅; style editing reliability (#169) || M4 | Color & effects | ✅ core; colour management depth |diff --git a/docs/target-app-parity.md b/docs/target-app-parity.mdindex 8044ed51b..c9b548aeb 100644--- a/docs/target-app-parity.md+++ b/docs/target-app-parity.md@@ -206,7 +206,7 @@ table is the one summed.| Application shell & workspace | 99% | 55% | 40–60 | context menus not opening on some systems; window controls (#333); System theme (#237); New Window/Arrange; Help menu || Documents, pages, spreads | 100% | 65% | 20–35 | Layout ▸ Pages submenu items, Page Attributes / Color Label, Go Back/Forward, layout grid (CJK) || Layers | 100% | 75% | 5–10 | IDML layer order fixed 2026-10-09; Layer panel options depth |-| Frames, shapes & paths | 100% | 60% | 25–40 | object copy/paste failures, live-corner handle (#186), reference point relocation (#337), Join/Reverse Path/Convert Point menu |+| Frames, shapes & paths | 100% | 60% | 25–40 | object copy/paste failures, reference point relocation (#337), Join/Reverse Path/Convert Point menu || Transform | 100% | 70% | 10–20 | Rotate 180°; transform panel depth || Fill, stroke, colour | 100% | 60% | 20–35 | hex entry (#323); Assign Profiles / Convert to Profile; color-managed proofing depth; Adobe Color Themes OOS || Effects & transparency | 100% | 50% | 20–30 | effects fidelity vs InDesign unmeasured; Clear Effects / Clear All Transparency; flattener depth |diff --git a/docs/ui-parity.md b/docs/ui-parity.mdindex ee6db4232..1910ec29e 100644--- a/docs/ui-parity.md+++ b/docs/ui-parity.md@@ -1,6 +1,6 @@# UI and interaction parity-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-10 · **Change:** minor (stage re-normalized to pre-alpha by the core-workflow gate; earlier today: major, first version) · **Target:** Adobe InDesign 2026 (21.6, Medium Dark, macOS)+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-11 · **Change:** minor (live corners work) · **Target:** Adobe InDesign 2026 (21.6, Medium Dark, macOS)Tools, handles, snapping, nudging, modifiers, shortcuts, panels, menus, context menus and feel,against InDesign 2026. The look was measured from the running app@@ -30,7 +30,7 @@ basics of editing fail for too many users on Windows and Linux.| Properties panel and Contextual Task Bar | per selection | ✓, task bar movable (#143) | ✓ | || Selection tool: click, marquee, move, Alt-duplicate, resize handles, rotate from corners | ✓ | ✓ | ✓ | || Direct Selection, Pen family, Pencil, Scissors | ✓ | ✓ | ~ | moving reference point "0" fails (#337) |-| Live corners (yellow handle) | ✓ | ✓ | ~ | not working for some users (#186) |+| Live corners (yellow handle) | ✓ | ✓ widget on a selected rectangle frame; diamonds drag the corner size (Shift: one corner), Alt-click steps the shape (Shift+Alt: all) | ✓ | #186 || Content grabber, frame fitting by double-click | ✓ | ✓ | ✓ | || Smart guides, snapping to guides/grid/baseline | ✓ | ✓ (2,049-line `snap.rs`) | ~ | vertical smart spacing between two rectangles (#188) || Nudging with arrows, Shift ×10 | ✓ | ✓ | ✓ | |@@ -65,7 +65,7 @@ context menus, typing at a caret) are things a layout artist does every minute,| Copy/paste, context menus, threading clicks, caret formatting on every platform, with control-channel regression tests | 30–50 || Canvas IME (port from VectorCraft) | 10–20 || Missing menu items (~150) and panels (Tabs, Navigator, Trap Presets) | 40–70 |-| Handle/tool feel fixes (#186, #188, #337), font search focus | 10–20 |+| Handle/tool feel fixes (#188, #337), font search focus | 10–20 || Dialog depth pass against 07-dialogs.md | 30–40 || **Total** | **120–180** (overlaps gaps 1, 8, 16) |@@ -73,5 +73,6 @@ context menus, typing at a caret) are things a layout artist does every minute,| Date | Change | Summary ||---|---|---|+| 2026-10-11 | minor | Live corners row to ✓: widget, diamonds, drag, Shift-drag, Alt-click shape cycling (#186) || 2026-10-10 | minor | Threading row corrected to ✗ after checking the code (no out-port interaction, no thread command) || 2026-10-10 | major | Created: measured menu coverage, 27-row interaction checklist from the code and issues |