b45255bb6fe2
layout.rs
//! Auto layout commands beyond `layout.add` / `layout.remove` (in `structure`) and the layout
//! keys of `node.set` (gap, padding, alignment, sizing, min/max, absolute, grid cells): grid tracks.
use figcraft_doc::{GridTrack, LayoutMode, Sizing};
use serde_json::Value;
use super::props::sizing;
use super::{CommandSpec, ok};
use crate::params::{get, num, req_num, req_targets, string};
use crate::{Result, Session, bad, spec};
pub fn specs() -> Vec<CommandSpec> {
vec![spec!(
"layout.setTrack",
"Set grid track size",
"{ids?, axis: columns|rows, index (0-based), sizing: fixed|hug|fill, value? (fixed: px, default the track's current size; fill: fr, default 1)}",
true,
set_track
)]
}
/// Same cap the layout pass applies to grid track counts.
const MAX_TRACKS: usize = 1000;
fn set_track(s: &mut Session, p: &Value) -> Result<Value> {
const CMD: &str = "layout.setTrack";
let ids = req_targets(CMD, s, p)?;
let columns = match string(p, "axis").map(|a| a.to_ascii_lowercase()).as_deref() {
Some("columns" | "column" | "col" | "x") => true,
Some("rows" | "row" | "y") => false,
_ => return Err(bad(CMD, "`axis` must be columns or rows")),
};
let index = req_num(CMD, p, "index")?;
let kind = get(p, "sizing").and_then(sizing).ok_or_else(|| bad(CMD, "`sizing` must be fixed, hug or fill"))?;
let value = num(p, "value");
let doc = s.doc_mut()?;
for id in ids {
// Current track sizes (switching to Fixed keeps the size the track has now).
let tracks_now = figcraft_layout::grid_geometry(doc, id).map(|g| if columns { g.columns } else { g.rows }).unwrap_or_default();
let n = doc.get_mut(id)?;
let Some(l) = n.layout.as_mut().filter(|l| l.mode == LayoutMode::Grid) else {
return Err(bad(CMD, format!("node {id} is not a grid auto layout frame")));
};
let count = tracks_now.len().max(if columns { l.grid_columns } else { l.grid_rows } as usize).min(MAX_TRACKS);
if index.fract() != 0.0 || !(0.0..count as f64).contains(&index) {
return Err(bad(CMD, format!("`index` must be an integer in 0..{count}")));
}
let i = index as usize;
let track = match kind {
Sizing::Fixed => {
let current = tracks_now.get(i).map(|(a, b)| b - a).unwrap_or(100.0);
GridTrack::fixed(value.unwrap_or(current).clamp(0.0, 1e6))
}
Sizing::Hug => GridTrack::hug(),
Sizing::Fill => GridTrack::fill(value.unwrap_or(1.0).clamp(0.0, 1e4)),
};
let tracks = if columns { &mut l.column_tracks } else { &mut l.row_tracks };
if tracks.len() <= i {
tracks.resize(i + 1, GridTrack::default());
}
if let Some(t) = tracks.get_mut(i) {
*t = track;
}
}
ok()
}
#[cfg(test)]
mod tests {
use figcraft_doc::{CrossAlign, Document, GridTrack, LayoutMode, Node, NodeId, Sizing};
use serde_json::{Value, json};
use crate::{EngineError, Session, params};
fn id(v: &Value) -> NodeId {
params::id_of(&v["id"]).unwrap()
}
fn ex(s: &mut Session, cmd: &str, p: Value) -> Value {
s.execute(cmd, &p).unwrap_or_else(|e| panic!("{cmd} {p}: {e}"))
}
fn node(s: &Session, id: NodeId) -> Node {
s.doc().unwrap().node(id).unwrap().clone()
}
fn x(s: &Session, id: NodeId) -> (f64, f64) {
let c = node(s, id).transform.as_coeffs();
(c[4], c[5])
}
/// A horizontal auto layout frame (padding 0, gap 10) with two 40×20 rectangles.
fn al_frame(s: &mut Session) -> (NodeId, NodeId, NodeId) {
let f = id(&ex(s, "frame.create", json!({"x": 0, "y": 0, "width": 300, "height": 100, "props": {"layout": "horizontal", "gap": 10}})));
let a = id(&ex(s, "shape.rectangle", json!({"x": 0, "y": 0, "width": 40, "height": 20, "parent": f})));
let b = id(&ex(s, "shape.rectangle", json!({"x": 0, "y": 0, "width": 40, "height": 20, "parent": f})));
(f, a, b)
}
#[test]
fn min_max_props_undo_and_order() {
let mut s = Session::new();
let (f, a, _) = al_frame(&mut s);
ex(&mut s, "node.set", json!({"id": f, "props": {"sizingH": "hug"}}));
assert_eq!(node(&s, f).width, 90.0);
ex(&mut s, "node.set", json!({"id": f, "props": {"minWidth": 200}}));
assert_eq!(node(&s, f).width, 200.0);
// A max below the min pulls the min down with it.
ex(&mut s, "node.set", json!({"id": f, "props": {"maxWidth": 150}}));
let n = node(&s, f);
assert_eq!((n.child_layout.min_w, n.child_layout.max_w, n.width), (Some(150.0), Some(150.0), 150.0));
s.undo().unwrap();
assert_eq!(node(&s, f).width, 200.0);
// null removes the limit.
ex(&mut s, "node.set", json!({"id": f, "props": {"minWidth": null, "maxWidth": null}}));
assert_eq!(node(&s, f).width, 90.0);
// Child limits clamp a fixed child; negatives become 0; junk is refused and rolled back.
ex(&mut s, "node.set", json!({"id": a, "props": {"minWidth": 70, "maxHeight": -5}}));
let n = node(&s, a);
assert_eq!((n.width, n.height, n.child_layout.max_h), (70.0, 0.0, Some(0.0)));
let before = s.ds().unwrap().history.undo.len();
assert!(s.execute("node.set", &json!({"id": a, "props": {"minWidth": "wide"}})).is_err());
assert!(s.execute("node.set", &json!({"id": a, "props": {"maxWidth": [1]}})).is_err());
assert_eq!(s.ds().unwrap().history.undo.len(), before);
assert_eq!(node(&s, a).child_layout.min_w, Some(70.0));
}
#[test]
fn absolute_child_keeps_place_and_follows_constraints() {
let mut s = Session::new();
let (f, a, b) = al_frame(&mut s);
ex(&mut s, "node.set", json!({"id": b, "props": {"sizingH": "fill"}}));
let at = x(&s, b);
ex(&mut s, "node.set", json!({"id": b, "props": {"absolute": true, "constraints": {"horizontal": "right"}}}));
let n = node(&s, b);
assert!(n.child_layout.absolute);
assert_eq!(n.child_layout.sizing_h, Sizing::Fixed, "an absolute child can't fill");
assert_eq!(x(&s, b), at, "toggling absolute keeps the child where it is");
// The flow ignores it: changing the gap moves nothing else.
ex(&mut s, "node.set", json!({"id": f, "props": {"paddingLeft": 30}}));
assert_eq!(x(&s, a).0, 30.0);
assert_eq!(x(&s, b), at);
// Resizing the frame applies its constraints (right: keeps its right margin).
let right_margin = 300.0 - at.0 - node(&s, b).width;
ex(&mut s, "node.set", json!({"id": f, "props": {"width": 400}}));
assert!((400.0 - x(&s, b).0 - node(&s, b).width - right_margin).abs() < 1e-9);
// Undo the resize, then back into the flow.
s.undo().unwrap();
assert_eq!(x(&s, b), at);
ex(&mut s, "node.set", json!({"id": b, "props": {"absolute": false}}));
assert_eq!(x(&s, b).0, 30.0 + 40.0 + 10.0);
assert!(s.execute("node.set", &json!({"id": b, "props": {"absolute": "maybe"}})).is_err());
}
/// Each side key writes its own padding slot and leaves the other three alone.
#[test]
fn each_side_padding_sets_its_side_alone() {
let mut s = Session::new();
let (f, _, _) = al_frame(&mut s);
// One side at a time: the other three stay 0 ([top, right, bottom, left]).
for (key, v, want) in [
("paddingTop", 8.0, [8.0, 0.0, 0.0, 0.0]),
("paddingRight", 12.0, [0.0, 12.0, 0.0, 0.0]),
("paddingBottom", 16.0, [0.0, 0.0, 16.0, 0.0]),
("paddingLeft", 20.0, [0.0, 0.0, 0.0, 20.0]),
] {
ex(&mut s, "node.set", json!({"id": f, "props": {"padding": 0}}));
ex(&mut s, "node.set", json!({"id": f, "props": {key: v}}));
assert_eq!(node(&s, f).layout.as_ref().unwrap().padding, want, "{key}");
}
// The [t, r, b, l] array and the axis pairs agree with the four sides.
ex(&mut s, "node.set", json!({"id": f, "props": {"padding": [8, 12, 16, 20]}}));
assert_eq!(node(&s, f).layout.as_ref().unwrap().padding, [8.0, 12.0, 16.0, 20.0]);
ex(&mut s, "node.set", json!({"id": f, "props": {"paddingHorizontal": 4}}));
assert_eq!(node(&s, f).layout.as_ref().unwrap().padding, [8.0, 4.0, 16.0, 4.0]);
ex(&mut s, "node.set", json!({"id": f, "props": {"paddingVertical": 2}}));
assert_eq!(node(&s, f).layout.as_ref().unwrap().padding, [2.0, 4.0, 2.0, 4.0]);
// Negatives clamp to 0; junk is refused.
ex(&mut s, "node.set", json!({"id": f, "props": {"paddingTop": -5}}));
assert_eq!(node(&s, f).layout.as_ref().unwrap().padding[0], 0.0);
assert!(s.execute("node.set", &json!({"id": f, "props": {"paddingLeft": "wide"}})).is_err());
}
#[test]
fn junk_axis_padding_is_refused_and_keeps_padding() {
let mut s = Session::new();
let (f, _, _) = al_frame(&mut s);
ex(&mut s, "node.set", json!({"id": f, "props": {"padding": 16}}));
for key in ["paddingHorizontal", "paddingVertical"] {
for junk in [json!("abc"), json!({"a": 1}), json!([1, 2])] {
assert!(s.execute("node.set", &json!({"id": f, "props": {key: junk}})).is_err(), "{key}");
assert_eq!(node(&s, f).layout.as_ref().unwrap().padding, [16.0; 4], "{key}");
}
}
}
#[test]
fn baseline_alignment_lines_up_text() {
let mut s = Session::new();
let f = id(&ex(&mut s, "frame.create", json!({"x": 0, "y": 0, "width": 400, "height": 100, "props": {"layout": "horizontal"}})));
let small = id(&ex(&mut s, "text.create", json!({"text": "Small", "x": 0, "y": 0, "parent": f, "props": {"fontSize": 12}})));
let big = id(&ex(&mut s, "text.create", json!({"text": "Big", "x": 0, "y": 0, "parent": f, "props": {"fontSize": 48}})));
ex(&mut s, "node.set", json!({"id": f, "props": {"crossAlign": "baseline"}}));
assert_eq!(node(&s, f).layout.unwrap().cross_align, CrossAlign::Baseline);
let base =
|s: &Session, t: NodeId| figcraft_text::layout_node(&node(s, t)).and_then(|(l, dy)| l.lines.first().map(|line| line.baseline + dy));
// Only meaningful when the text was measured (fonts available).
if let (Some(bs), Some(bb)) = (base(&s, small), base(&s, big))
&& (bb - bs).abs() > 1.0
{
assert!((x(&s, small).1 + bs - (x(&s, big).1 + bb)).abs() < 1e-6);
}
// Vertical layouts treat baseline as left.
ex(&mut s, "node.set", json!({"id": f, "props": {"layout": "vertical"}}));
assert_eq!(x(&s, small).0, x(&s, big).0);
}
/// "for baseline alignment, the bottoms of the icon and the word home are aligned on the red
/// line" (Use the horizontal and vertical flows in auto layout, the figure's caption; #1825): a
/// layer without text sits on the text's baseline with its bottom edge, not at the top.
#[test]
fn baseline_alignment_puts_an_icons_bottom_on_the_text_baseline() {
let mut s = Session::new();
let f = id(&ex(&mut s, "frame.create", json!({"x": 0, "y": 0, "width": 400, "height": 100, "props": {"layout": "horizontal", "gap": 8}})));
let icon = id(&ex(&mut s, "shape.rectangle", json!({"x": 0, "y": 0, "width": 16, "height": 16, "parent": f})));
let home = id(&ex(&mut s, "text.create", json!({"text": "Home", "x": 0, "y": 0, "parent": f, "props": {"fontSize": 48}})));
ex(&mut s, "node.set", json!({"id": f, "props": {"crossAlign": "baseline"}}));
let base = figcraft_text::layout_node(&node(&s, home)).and_then(|(l, dy)| l.lines.first().map(|line| line.baseline + dy));
// Only meaningful when the text was measured (fonts available) and its baseline is below
// the icon's height.
if let Some(b) = base
&& b > 16.0
{
let bottom = x(&s, icon).1 + 16.0;
assert!((bottom - (x(&s, home).1 + b)).abs() < 1e-6, "icon bottom {bottom}, text baseline {}", x(&s, home).1 + b);
}
// Top alignment puts it back at the top.
ex(&mut s, "node.set", json!({"id": f, "props": {"crossAlign": "min"}}));
assert_eq!(x(&s, icon).1, x(&s, home).1);
}
#[test]
fn grid_tracks_cells_and_undo() {
let mut s = Session::new();
let f = id(&ex(
&mut s,
"frame.create",
json!({"x": 0, "y": 0, "width": 320, "height": 200, "props": {"layout": "grid", "gridColumns": 3, "columnGap": 10, "rowGap": 10}}),
));
let kids: Vec<NodeId> =
(0..4).map(|_| id(&ex(&mut s, "shape.rectangle", json!({"x": 0, "y": 0, "width": 20, "height": 20, "parent": f})))).collect();
ex(&mut s, "node.set", json!({"id": f, "props": {"columnTracks": [100, "1fr", "auto"]}}));
let l = node(&s, f).layout.unwrap();
assert_eq!(l.column_tracks, vec![GridTrack::fixed(100.0), GridTrack::fill(1.0), GridTrack::hug()]);
// 320 - 20 gaps - 100 - 20 (hug) = 180 for the 1fr column.
assert_eq!(x(&s, kids[1]).0, 110.0);
assert_eq!(x(&s, kids[2]).0, 300.0);
// layout.setTrack: switching to fixed keeps the current size.
ex(&mut s, "layout.setTrack", json!({"ids": [f], "axis": "columns", "index": 1, "sizing": "fixed"}));
assert_eq!(node(&s, f).layout.unwrap().column_tracks.get(1).copied(), Some(GridTrack::fixed(180.0)));
ex(&mut s, "layout.setTrack", json!({"ids": [f], "axis": "rows", "index": 0, "sizing": "fixed", "value": 50}));
assert_eq!(node(&s, f).layout.unwrap().row_tracks, vec![GridTrack::fixed(50.0)]);
s.undo().unwrap();
assert!(node(&s, f).layout.unwrap().row_tracks.is_empty());
// Cells: anchor the last child at column 2, row 1, span the first over two columns.
ex(&mut s, "node.set", json!({"id": kids[3], "props": {"gridColumn": 2, "gridRow": 1}}));
ex(&mut s, "node.set", json!({"id": kids[0], "props": {"gridColumnSpan": 2, "sizingH": "fill"}}));
assert_eq!(node(&s, kids[0]).width, 100.0 + 10.0 + 180.0);
let info = crate::inspect::node_json(s.doc().unwrap(), kids[3], 0);
assert_eq!(info["gridCell"]["column"], json!(2));
assert_eq!(info["gridCell"]["row"], json!(1));
assert_eq!(info["gridCell"]["anchored"], json!(true));
// Inspected together with the frame, each child still gets its own cell.
let all = crate::inspect::node_json(s.doc().unwrap(), f, 1);
let cells: Vec<(Value, Value)> =
all["children"].as_array().unwrap().iter().map(|c| (c["gridCell"]["column"].clone(), c["gridCell"]["row"].clone())).collect();
assert_eq!(cells[3], (json!(2), json!(1)));
assert_eq!(cells[0].0, json!(0));
assert!(cells.iter().all(|(c, r)| c.is_number() && r.is_number()), "{cells:?}");
ex(&mut s, "node.set", json!({"id": kids[3], "props": {"gridColumn": "auto", "gridRow": null}}));
assert_eq!(node(&s, kids[3]).child_layout.grid_column, None);
// Fewer columns drop the extra tracks.
ex(&mut s, "node.set", json!({"id": f, "props": {"gridColumns": 2}}));
assert_eq!(node(&s, f).layout.unwrap().column_tracks.len(), 2);
// Errors roll back.
for bad in [
json!({"ids": [f], "axis": "diagonal", "index": 0, "sizing": "fixed"}),
json!({"ids": [f], "axis": "columns", "index": 9, "sizing": "fixed"}),
json!({"ids": [f], "axis": "columns", "index": -1, "sizing": "hug"}),
json!({"ids": [f], "axis": "columns", "index": 1.5, "sizing": "fixed", "value": 50}),
json!({"ids": [f], "axis": "columns", "index": 0, "sizing": "stretchy"}),
json!({"ids": [kids[1]], "axis": "columns", "index": 0, "sizing": "hug"}),
] {
assert!(s.execute("layout.setTrack", &bad).is_err(), "{bad}");
}
assert!(s.execute("node.set", &json!({"id": f, "props": {"columnTracks": ["1fr", "wide"]}})).is_err());
assert!(s.execute("node.set", &json!({"id": f, "props": {"rowTracks": 5}})).is_err());
}
#[test]
fn set_track_clamps_hostile_grid_counts() {
let mut s = Session::new();
let f = id(&ex(&mut s, "frame.create", json!({"x": 0, "y": 0, "width": 320, "height": 200, "props": {"layout": "grid"}})));
// A crafted file can carry a count node.set would have clamped.
s.doc_mut().unwrap().get_mut(f).unwrap().layout.as_mut().unwrap().grid_columns = 5_000_000;
let p = json!({"ids": [f], "axis": "columns", "index": 4_999_999, "sizing": "hug"});
assert!(s.execute("layout.setTrack", &p).is_err());
assert!(node(&s, f).layout.unwrap().column_tracks.len() <= 1000);
}
#[test]
fn layout_props_survive_hostile_values() {
let junk = [json!(null), json!("NaN"), json!(-1e308), json!(1e308), json!([]), json!({}), json!(true), json!("-5fr")];
let keys = [
"minWidth",
"maxWidth",
"minHeight",
"maxHeight",
"absolute",
"columnTracks",
"rowTracks",
"gridColumn",
"gridRow",
"gridColumnSpan",
"gridRowSpan",
"gridColumns",
"gridRows",
"columnGap",
"rowGap",
"crossAlign",
];
for k in keys {
for j in &junk {
let mut s = Session::new();
let f = id(&ex(&mut s, "frame.create", json!({"x": 0, "y": 0, "width": 100, "height": 100, "props": {"layout": "grid"}})));
let r = id(&ex(&mut s, "shape.rectangle", json!({"x": 0, "y": 0, "width": 10, "height": 10, "parent": f})));
for target in [f, r] {
if let Err(EngineError::Internal { cmd, msg }) = s.execute("node.set", &json!({"id": target, "props": {k: j}})) {
panic!("{cmd} panicked on {k}={j}: {msg}");
}
}
let doc: &Document = s.doc().unwrap();
for n in [f, r] {
let n = doc.node(n).unwrap();
assert!(n.width.is_finite() && n.height.is_finite(), "{k}={j}");
}
assert!(doc.node(f).unwrap().layout.as_ref().is_some_and(|l| l.mode == LayoutMode::Grid));
}
}
// Tracks as track objects and extreme strings.
let t: Vec<Option<GridTrack>> =
[json!({"sizing": "fill", "value": 2}), json!({"sizing": "fixed"}), json!("120px"), json!("1e400fr"), json!("hug")]
.iter()
.map(super::super::props::track_of)
.collect();
assert_eq!(t, vec![Some(GridTrack::fill(2.0)), None, Some(GridTrack::fixed(120.0)), None, Some(GridTrack::hug())]);
}
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.