mirror of
https://github.com/storytold/figcraft.git
synced 2026-11-17 21:53:00 +00:00
Merge remote-tracking branch 'origin/main' into codex/figcraft-native-consumer
# Conflicts: # crates/format/src/fig/map.rs # crates/format/src/fig/map/board.rs # crates/format/src/fig/map/layer.rs # docs/file-format-parity.md
This commit is contained in:
@@ -16,8 +16,8 @@ concurrency:
|
||||
|
||||
jobs:
|
||||
sonarcloud:
|
||||
# Pin the coverage setup that checks out this repo's pinned craft-i18n data.
|
||||
uses: storytold/craft-common-actions/.github/workflows/sonarcloud.yml@ea24c9c24e1997238334182160f60e602e5bce32
|
||||
# Pin the coverage setup that provisions test data and fetches locked dependencies before offline metadata tests.
|
||||
uses: storytold/craft-common-actions/.github/workflows/sonarcloud.yml@5008f8cd1b011b35eed223a7d058d7a8e9075ef6
|
||||
with:
|
||||
# The shared coverage archive's shards omit the CLI executable used by integration tests.
|
||||
# Run this repository's suite in one instrumented job and provide its pinned test data.
|
||||
|
||||
@@ -2,15 +2,21 @@
|
||||
//! `--no-system-fonts` or `FIGCRAFT_NO_SYSTEM_FONTS=1` opts out.
|
||||
|
||||
use std::process::Command;
|
||||
use std::sync::atomic::{AtomicU64, Ordering};
|
||||
|
||||
use serde_json::{Value, json};
|
||||
|
||||
/// The result of one `figcraft-cli run` step (script file `name`); `opt_out` sets the environment
|
||||
/// variable.
|
||||
fn run_one(name: &str, step: Value, args: &[&str], opt_out: bool) -> Value {
|
||||
static NEXT_SCRIPT: AtomicU64 = AtomicU64::new(0);
|
||||
let d = std::env::temp_dir().join(format!("figcraft-cli-fonts-{}", std::process::id()));
|
||||
std::fs::create_dir_all(&d).unwrap();
|
||||
let script = d.join(format!("{name}.json"));
|
||||
// Tests in this binary run concurrently. `sketch_imports_keep_to_no_system_fonts` also calls
|
||||
// `families`, so a shared `families.json` could be truncated while another child reads it;
|
||||
// an empty script is valid and makes the CLI exit successfully without printing result JSON.
|
||||
let sequence = NEXT_SCRIPT.fetch_add(1, Ordering::Relaxed);
|
||||
let script = d.join(format!("{name}-{sequence}.json"));
|
||||
std::fs::write(&script, json!([step]).to_string()).unwrap();
|
||||
let mut cmd = Command::new(env!("CARGO_BIN_EXE_figcraft-cli"));
|
||||
cmd.arg("run").arg(&script).args(args);
|
||||
@@ -20,8 +26,21 @@ fn run_one(name: &str, step: Value, args: &[&str], opt_out: bool) -> Value {
|
||||
cmd.env_remove("FIGCRAFT_NO_SYSTEM_FONTS");
|
||||
}
|
||||
let out = cmd.output().unwrap();
|
||||
assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
|
||||
let line: Value = serde_json::from_slice(&out.stdout).unwrap();
|
||||
assert!(
|
||||
out.status.success(),
|
||||
"{name}: CLI status {:?}; stdout={:?}; stderr={}",
|
||||
out.status.code(),
|
||||
String::from_utf8_lossy(&out.stdout),
|
||||
String::from_utf8_lossy(&out.stderr),
|
||||
);
|
||||
let line: Value = serde_json::from_slice(&out.stdout).unwrap_or_else(|error| {
|
||||
panic!(
|
||||
"{name} {:?}: CLI returned success without JSON: {error}; stdout={:?}; stderr={}",
|
||||
args,
|
||||
String::from_utf8_lossy(&out.stdout),
|
||||
String::from_utf8_lossy(&out.stderr),
|
||||
)
|
||||
});
|
||||
line["result"].clone()
|
||||
}
|
||||
|
||||
|
||||
@@ -329,14 +329,22 @@ pub(super) fn paste_over(s: &mut Session, _p: &Value) -> Result<Value> {
|
||||
let sel = s.selection();
|
||||
let page = s.page()?;
|
||||
let doc = s.doc()?;
|
||||
let (parent, at) = match sel.first() {
|
||||
let (parent, at, above) = match sel.first() {
|
||||
Some(i) => {
|
||||
let parent = doc.node(*i).and_then(|n| n.parent).unwrap_or(page);
|
||||
(parent, doc.world_bounds(*i).map(|b| (b.x0, b.y0)))
|
||||
(parent, doc.world_bounds(*i).map(|b| (b.x0, b.y0)), doc.index_in_parent(*i).map(|ix| ix + 1))
|
||||
}
|
||||
None => (page, None),
|
||||
None => (page, None, None),
|
||||
};
|
||||
let ids = paste_into(s, parent, at)?;
|
||||
if let Some(above) = above {
|
||||
let doc = s.doc_mut()?;
|
||||
for (k, i) in
|
||||
ids.iter().filter(|i| doc.node(**i).is_some_and(|n| n.parent == Some(parent))).copied().collect::<Vec<_>>().into_iter().enumerate()
|
||||
{
|
||||
doc.reorder(i, above + k)?;
|
||||
}
|
||||
}
|
||||
s.set_selection(ids.clone());
|
||||
Ok(json!({"ids": ids}))
|
||||
}
|
||||
|
||||
@@ -283,25 +283,34 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
spec!("view.zoomSelection", "Zoom to selection", "{}", false, |s, _| {
|
||||
let ds = s.ds_mut()?;
|
||||
if let Some(b) = ds.doc.bounds_of(&ds.selection) {
|
||||
ds.view.fit(b, 256.0);
|
||||
ds.view.fit_selection(b, 256.0);
|
||||
}
|
||||
Ok(json!({"zoom": ds.view.zoom}))
|
||||
}),
|
||||
spec!("view.set", "Set view", "{zoom?, cx?, cy? (page coordinate at the centre), vw?, vh? (viewport size)}", false, |s, p| {
|
||||
let v = view(s)?;
|
||||
if let Some(z) = num(p, "zoom") {
|
||||
v.zoom = z.clamp(ViewState::MIN_ZOOM, ViewState::MAX_ZOOM);
|
||||
spec!(
|
||||
"view.set",
|
||||
"Set view",
|
||||
"{zoom?, cx?, cy? (page coordinate at the centre), vw?, vh? (viewport size), bottomInset? (height of the strip the bottom toolbar covers)}",
|
||||
false,
|
||||
|s, p| {
|
||||
let v = view(s)?;
|
||||
if let Some(z) = num(p, "zoom") {
|
||||
v.zoom = z.clamp(ViewState::MIN_ZOOM, ViewState::MAX_ZOOM);
|
||||
}
|
||||
v.cx = num_or(p, "cx", v.cx);
|
||||
v.cy = num_or(p, "cy", v.cy);
|
||||
if let Some(w) = num(p, "vw") {
|
||||
v.vw = w.clamp(10.0, 20000.0);
|
||||
}
|
||||
if let Some(h) = num(p, "vh") {
|
||||
v.vh = h.clamp(10.0, 20000.0);
|
||||
}
|
||||
if let Some(i) = num(p, "bottomInset") {
|
||||
v.bottom_inset = i.clamp(0.0, 20000.0);
|
||||
}
|
||||
Ok(serde_json::to_value(&*v).unwrap_or(Value::Null))
|
||||
}
|
||||
v.cx = num_or(p, "cx", v.cx);
|
||||
v.cy = num_or(p, "cy", v.cy);
|
||||
if let Some(w) = num(p, "vw") {
|
||||
v.vw = w.clamp(10.0, 20000.0);
|
||||
}
|
||||
if let Some(h) = num(p, "vh") {
|
||||
v.vh = h.clamp(10.0, 20000.0);
|
||||
}
|
||||
Ok(serde_json::to_value(&*v).unwrap_or(Value::Null))
|
||||
}),
|
||||
),
|
||||
spec!(
|
||||
"view.zoomAt",
|
||||
"Zoom tool",
|
||||
|
||||
@@ -345,6 +345,24 @@ fn copy_paste_and_duplicate() {
|
||||
assert_eq!(d["ids"].as_array().unwrap().len(), 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn paste_over_puts_the_copies_just_above_the_selected_layer() {
|
||||
let mut s = sess();
|
||||
let frame = id(&s.execute("frame.create", &json!({"x": 0, "y": 0, "width": 200, "height": 200})).unwrap());
|
||||
let layer =
|
||||
|s: &mut Session, x: f64| id(&s.execute("shape.rectangle", &json!({"x": x, "y": 10, "width": 10, "height": 10, "parent": frame})).unwrap());
|
||||
let (a, b, c) = (layer(&mut s, 10.0), layer(&mut s, 30.0), layer(&mut s, 50.0));
|
||||
let kids = |s: &Session| s.doc().unwrap().node(frame).unwrap().children.clone();
|
||||
assert_eq!(kids(&s), vec![a, b, c]);
|
||||
s.execute("edit.copy", &json!({"ids": [b, c]})).unwrap();
|
||||
s.set_selection(vec![a]);
|
||||
let pasted: Vec<NodeId> = s.execute("edit.pasteOver", &json!({})).unwrap()["ids"].as_array().unwrap().iter().filter_map(params::id_of).collect();
|
||||
assert_eq!(pasted.len(), 2);
|
||||
assert_eq!(kids(&s), vec![a, pasted[0], pasted[1], b, c], "in the selected layer's frame, just above it, in the copied order");
|
||||
assert_eq!(s.doc().unwrap().world_bounds(pasted[0]).unwrap().x0, 10.0, "at the selected layer's position");
|
||||
assert_eq!(s.selection(), pasted);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn boolean_and_flatten() {
|
||||
let mut s = sess();
|
||||
|
||||
@@ -131,7 +131,7 @@ fn zoom_to_fit_selection_and_frames() {
|
||||
// (command, selection before, zoom, centre, selection after, derivation)
|
||||
let rows: Vec<(&str, Vec<NodeId>, f64, (f64, f64), Vec<NodeId>, &str)> = vec![
|
||||
("view.zoomFit", vec![], fit(content), (470.0, 300.0), vec![], "Shift+1 fits everything on the page into the view"),
|
||||
("view.zoomSelection", vec![r], fit(Rect::new(0.0, 0.0, 40.0, 40.0)), (920.0, 20.0), vec![r], "Shift+2 zooms to the selection"),
|
||||
("view.zoomSelection", vec![r], (800.0 - 80.0) / 40.0, (920.0, 20.0), vec![r], "Shift+2 zooms to the selection, with a 40-point margin"),
|
||||
(
|
||||
"view.nextFrame",
|
||||
vec![],
|
||||
@@ -225,7 +225,7 @@ fn view_shortcuts_follow_the_documented_keys() {
|
||||
(Platform::Other, "-", m(true, false, false, false), "view.zoomOut", "Shift and - zooms out"),
|
||||
(Platform::Mac, "0", m(true, false, false, false), "view.zoom100", "Shift+0 zooms to 100%"),
|
||||
(Platform::Other, "1", m(true, false, false, false), "view.zoomFit", "Shift+1 zooms to fit"),
|
||||
(Platform::Mac, "2", m(true, false, false, false), "view.zoomSelection", "Shift+2 zooms to the selection"),
|
||||
(Platform::Mac, "2", m(true, false, false, false), "view.zoomSelection", "Shift+2 zooms to the selection, with a 40-point margin"),
|
||||
(Platform::Mac, "N", m(false, false, false, false), "view.nextFrame", "N zooms to the next frame"),
|
||||
(Platform::Other, "N", m(true, false, false, false), "view.prevFrame", "Shift+N zooms to the previous frame"),
|
||||
(Platform::Mac, "R", m(true, false, false, false), "view.rulers", "Shift+R shows and hides the rulers"),
|
||||
@@ -771,3 +771,151 @@ fn view_toggles_are_kept_for_the_next_launch() {
|
||||
}
|
||||
assert!(!view.outlines && !view.outlines_selection && !view.proof_srgb, "{view:?}");
|
||||
}
|
||||
|
||||
/// Select a fresh rectangle at the origin, set the view and run `cmd`; the rect's screen box is
|
||||
/// returned as (left, top, right, bottom).
|
||||
fn zoom_on(cmd: &str, inset: f64, w: f64, h: f64) -> (ViewState, (f64, f64, f64, f64)) {
|
||||
let mut s = Session::new();
|
||||
let r = rect(&mut s, 0.0, 0.0, w, h, None);
|
||||
ex(&mut s, "view.set", json!({"vw": 1389, "vh": 903, "bottomInset": inset}));
|
||||
ex(&mut s, "select.set", json!({"ids": [r]}));
|
||||
ex(&mut s, cmd, json!({}));
|
||||
let v = view(&s);
|
||||
let (l, t) = v.page_to_screen(0.0, 0.0);
|
||||
let (rr, b) = v.page_to_screen(w, h);
|
||||
(v, (l, t, rr, b))
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn zoom_to_selection_leaves_forty_points_and_clears_the_toolbar() {
|
||||
// Measured in Figma's web app, 2026-11-09: 40 points on every side of the canvas above the toolbar.
|
||||
let (v, (l, t, r, b)) = zoom_on("view.zoomSelection", 58.0, 100.0, 100.0);
|
||||
assert!((v.zoom - 7.65).abs() < 0.01, "{}", v.zoom);
|
||||
assert!((t - 40.0).abs() < 0.5 && (b - (845.0 - 40.0)).abs() < 0.5, "top {t}, bottom {b}");
|
||||
assert!((l - (1389.0 - r)).abs() < 0.5, "left {l}, right {r}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn zoom_to_selection_on_a_wide_layer_is_limited_by_the_width() {
|
||||
let (v, (l, _, r, _)) = zoom_on("view.zoomSelection", 58.0, 1000.0, 200.0);
|
||||
assert!((v.zoom - (1389.0 - 80.0) / 1000.0).abs() < 0.001, "{}", v.zoom);
|
||||
assert!((l - 40.0).abs() < 0.5 && ((1389.0 - r) - 40.0).abs() < 0.5, "left {l}, right {r}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn zoom_to_selection_without_a_toolbar_inset_uses_the_whole_height() {
|
||||
let (v, _) = zoom_on("view.zoomSelection", 0.0, 100.0, 100.0);
|
||||
assert!((v.zoom - (903.0 - 80.0) / 100.0).abs() < 1e-6, "{}", v.zoom);
|
||||
let (_, top) = v.page_to_screen(0.0, 0.0);
|
||||
let (_, bottom) = v.page_to_screen(100.0, 100.0);
|
||||
assert!((top - 40.0).abs() < 1e-6 && (bottom - 863.0).abs() < 1e-6, "top {top}, bottom {bottom}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn zoom_to_selection_in_a_short_canvas_still_ends_above_the_toolbar() {
|
||||
// A canvas 130 points high with the 60-point toolbar strip leaves 70 above it: too short for
|
||||
// 40 points a side, so the margin shrinks and the selection stays clear of the toolbar.
|
||||
let mut s = Session::new();
|
||||
let r = rect(&mut s, 0.0, 0.0, 100.0, 100.0, None);
|
||||
ex(&mut s, "view.set", json!({"vw": 1389, "vh": 130, "bottomInset": 60}));
|
||||
ex(&mut s, "select.set", json!({"ids": [r]}));
|
||||
ex(&mut s, "view.zoomSelection", json!({}));
|
||||
let v = view(&s);
|
||||
let (_, top) = v.page_to_screen(0.0, 0.0);
|
||||
let (_, bottom) = v.page_to_screen(100.0, 100.0);
|
||||
assert!(top >= 0.0 && bottom <= 70.0 + 1e-6, "top {top}, bottom {bottom}");
|
||||
assert!((top - (70.0 - bottom)).abs() < 1e-6, "centred above the toolbar: top {top}, bottom {bottom}");
|
||||
// The margin shrinks to a quarter of the 70 points (17.5) and the zoom is the exact fit, not the floor.
|
||||
assert!((v.zoom - 0.35).abs() < 1e-9, "{}", v.zoom);
|
||||
assert!((top - 17.5).abs() < 1e-6 && (bottom - 52.5).abs() < 1e-6, "top {top}, bottom {bottom}");
|
||||
}
|
||||
|
||||
/// A canvas narrower than 160 points keeps a quarter of its width on each side.
|
||||
#[test]
|
||||
fn zoom_to_selection_in_a_narrow_canvas_shrinks_the_side_margins() {
|
||||
let mut s = Session::new();
|
||||
let r = rect(&mut s, 0.0, 0.0, 100.0, 100.0, None);
|
||||
ex(&mut s, "view.set", json!({"vw": 100, "vh": 903, "bottomInset": 0}));
|
||||
ex(&mut s, "select.set", json!({"ids": [r]}));
|
||||
ex(&mut s, "view.zoomSelection", json!({}));
|
||||
let v = view(&s);
|
||||
let (left, _) = v.page_to_screen(0.0, 0.0);
|
||||
let (right, _) = v.page_to_screen(100.0, 100.0);
|
||||
assert!((v.zoom - 0.5).abs() < 1e-9, "{}", v.zoom);
|
||||
assert!((left - 25.0).abs() < 1e-6 && (right - 75.0).abs() < 1e-6, "left {left}, right {right}");
|
||||
}
|
||||
|
||||
/// A view 1000 by 800 with a 100-point toolbar strip, for the edge cases of the fit.
|
||||
fn strip_view() -> ViewState {
|
||||
ViewState { vw: 1000.0, vh: 800.0, bottom_inset: 100.0, ..ViewState::default() }
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fitting_a_selection_survives_points_lines_extremes_and_junk() {
|
||||
// A point: the zoom stays, and it lands in the middle of the area above the toolbar (y = 350).
|
||||
let mut v = strip_view();
|
||||
v.zoom = 2.0;
|
||||
v.fit_selection(Rect::new(10.0, 20.0, 10.0, 20.0), 32.0);
|
||||
assert_eq!(v.zoom, 2.0);
|
||||
let (x, y) = v.page_to_screen(10.0, 20.0);
|
||||
assert!((x - 500.0).abs() < 1e-9 && (y - 350.0).abs() < 1e-9, "{x}, {y}");
|
||||
// A zero-width line is limited by its height, a zero-height one by its width.
|
||||
let mut v = strip_view();
|
||||
v.fit_selection(Rect::new(0.0, 0.0, 0.0, 100.0), 32.0);
|
||||
assert!((v.zoom - (700.0 - 80.0) / 100.0).abs() < 1e-9, "{}", v.zoom);
|
||||
let mut v = strip_view();
|
||||
v.fit_selection(Rect::new(0.0, 0.0, 100.0, 0.0), 32.0);
|
||||
assert!((v.zoom - (1000.0 - 80.0) / 100.0).abs() < 1e-9, "{}", v.zoom);
|
||||
// A tiny one stops at the maximum zoom, a huge one at the minimum.
|
||||
let mut v = strip_view();
|
||||
v.fit_selection(Rect::new(0.0, 0.0, 0.001, 0.001), 32.0);
|
||||
assert_eq!(v.zoom, 32.0);
|
||||
v.fit_selection(Rect::new(0.0, 0.0, 1e12, 1e12), 32.0);
|
||||
assert_eq!(v.zoom, ViewState::MIN_ZOOM);
|
||||
// A rectangle with any coordinate that is not a finite number changes nothing.
|
||||
for bad in [
|
||||
Rect::new(0.0, f64::NAN, 10.0, 10.0),
|
||||
Rect::new(0.0, 0.0, f64::INFINITY, 10.0),
|
||||
Rect::new(0.0, 0.0, 10.0, f64::NAN),
|
||||
Rect::new(f64::NAN, 0.0, 10.0, 10.0),
|
||||
] {
|
||||
let mut v = strip_view();
|
||||
let before = (v.zoom, v.cx, v.cy);
|
||||
v.fit_selection(bad, 32.0);
|
||||
assert_eq!((v.zoom, v.cx, v.cy), before, "{bad:?}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_bottom_inset_is_clamped_and_never_saved() {
|
||||
let mut s = Session::new();
|
||||
ex(&mut s, "view.set", json!({"bottomInset": -5}));
|
||||
assert_eq!(view(&s).bottom_inset, 0.0);
|
||||
ex(&mut s, "view.set", json!({"bottomInset": 1e12}));
|
||||
assert_eq!(view(&s).bottom_inset, 20000.0);
|
||||
// Larger than the viewport: the fit still leaves a sliver of canvas and a finite centre.
|
||||
ex(&mut s, "view.set", json!({"vw": 400, "vh": 300, "bottomInset": 5000}));
|
||||
let r = rect(&mut s, 0.0, 0.0, 10.0, 10.0, None);
|
||||
ex(&mut s, "select.set", json!({"ids": [r]}));
|
||||
ex(&mut s, "view.zoomSelection", json!({}));
|
||||
let v = view(&s);
|
||||
assert!(v.zoom.is_finite() && v.cx.is_finite() && v.cy.is_finite(), "{v:?}");
|
||||
// It is not part of what the view saves.
|
||||
let saved = serde_json::to_string(&v).unwrap();
|
||||
assert!(!saved.to_lowercase().contains("inset"), "{saved}");
|
||||
let back: ViewState = serde_json::from_str(&saved).unwrap();
|
||||
assert_eq!(back.bottom_inset, 0.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn zoom_to_fit_is_unchanged() {
|
||||
// Left alone on purpose: its 64-point margin is not measured against Figma yet.
|
||||
let mut s = Session::new();
|
||||
rect(&mut s, 0.0, 0.0, 100.0, 100.0, None);
|
||||
ex(&mut s, "view.set", json!({"vw": 1389, "vh": 903, "bottomInset": 58}));
|
||||
ex(&mut s, "view.zoomFit", json!({}));
|
||||
let v = view(&s);
|
||||
assert!((v.zoom - (903.0 - 128.0) / 100.0).abs() < 1e-6);
|
||||
// No toolbar offset: the rectangle's own centre stays in the middle of the whole viewport.
|
||||
assert_eq!((v.cx, v.cy), (50.0, 50.0));
|
||||
}
|
||||
|
||||
@@ -12,6 +12,10 @@ pub struct ViewState {
|
||||
/// Viewport size in logical pixels (set by the UI; used by zoom-to-fit).
|
||||
pub vw: f64,
|
||||
pub vh: f64,
|
||||
/// Height in screen points of the strip the floating bottom toolbar covers (from its top edge to
|
||||
/// the canvas's bottom edge); set by the UI every frame, 0 when it's hidden. Never saved.
|
||||
#[serde(skip)]
|
||||
pub bottom_inset: f64,
|
||||
pub pixel_grid: bool,
|
||||
pub layout_grids: bool,
|
||||
pub rulers: bool,
|
||||
@@ -51,6 +55,7 @@ impl Default for ViewState {
|
||||
zoom: 1.0,
|
||||
vw: 1200.0,
|
||||
vh: 800.0,
|
||||
bottom_inset: 0.0,
|
||||
pixel_grid: true,
|
||||
layout_grids: true,
|
||||
rulers: false,
|
||||
@@ -105,6 +110,32 @@ impl ViewState {
|
||||
self.cx = r.center().x;
|
||||
self.cy = r.center().y;
|
||||
}
|
||||
/// Fit a page rectangle for Zoom to selection: a 40 point margin on all four sides of the area
|
||||
/// above the bottom toolbar (`vw` by `vh - bottom_inset`), centred in that area.
|
||||
pub fn fit_selection(&mut self, r: figcraft_geom::Rect, max_zoom: f64) {
|
||||
// A rectangle that isn't all finite numbers leaves the view as it is.
|
||||
if ![r.x0, r.y0, r.x1, r.y1].iter().all(|v| v.is_finite()) {
|
||||
return;
|
||||
}
|
||||
let inset = if self.bottom_inset.is_finite() { self.bottom_inset.clamp(0.0, (self.vh - 1.0).max(0.0)) } else { 0.0 };
|
||||
let area_h = (self.vh - inset).max(1.0);
|
||||
// A point (nothing to fit) is centred in the area above the toolbar at the zoom it has.
|
||||
if !(r.width() > 0.0 || r.height() > 0.0) {
|
||||
self.cx = r.center().x;
|
||||
self.cy = r.center().y + (self.vh - area_h) / 2.0 / self.zoom.max(1e-6);
|
||||
return;
|
||||
}
|
||||
// 40 points as measured; a canvas too small for that keeps a quarter of its size on each
|
||||
// side instead, so the selection still ends above the toolbar.
|
||||
let mx = (self.vw / 4.0).clamp(0.0, 40.0);
|
||||
let my = (area_h / 4.0).clamp(0.0, 40.0);
|
||||
let zx = (self.vw - mx * 2.0).max(1.0) / r.width().max(1e-6);
|
||||
let zy = (area_h - my * 2.0).max(1.0) / r.height().max(1e-6);
|
||||
self.zoom = zx.min(zy).clamp(Self::MIN_ZOOM, max_zoom);
|
||||
// The rect's centre lands at screen y = area_h / 2, the page centre `(vh - area_h) / 2` below it.
|
||||
self.cx = r.center().x;
|
||||
self.cy = r.center().y + (self.vh - area_h) / 2.0 / self.zoom;
|
||||
}
|
||||
/// The zoom from which the pixel grid shows (400%).
|
||||
pub const PIXEL_GRID_ZOOM: f64 = 4.0;
|
||||
/// Whether the pixel grid draws: it's on and the canvas is zoomed in to 400% or more.
|
||||
|
||||
@@ -9,7 +9,7 @@ fn board_schema() -> Schema {
|
||||
|
||||
/// [`board_schema`] over another base schema.
|
||||
fn board_schema_of(base: &str) -> Schema {
|
||||
Schema::parse(&base.replace(
|
||||
Schema::parse(&base.replace("enum ShapeWithTextType SQUARE ELLIPSE", "enum ShapeWithTextType SQUARE ROUNDED_RECTANGLE ELLIPSE DIAMOND TRIANGLE_UP TRIANGLE_DOWN PARALLELOGRAM_RIGHT PARALLELOGRAM_LEFT TRAPEZOID PENTAGON HEXAGON OCTAGON STAR PLUS ARROW_LEFT ARROW_RIGHT CHEVRON SPEECH_BUBBLE ENG_DATABASE DOCUMENT_SINGLE PREDEFINED_PROCESS MANUAL_INPUT INTERNAL_STORAGE ENG_QUEUE ENG_FILE ENG_FOLDER SHIELD DOCUMENT_MULTIPLE SUMMING_JUNCTION OR").replace(
|
||||
"\nmessage Blob ",
|
||||
", GeneratedData nodeGenerationData, GeneratedData derivedImmutableFrameData, string textAlignHorizontal, string textAlignVertical\nmessage GeneratedData NodeChange[] overrides, uint version\nmessage Blob ",
|
||||
))
|
||||
@@ -549,3 +549,174 @@ fn a_fig_sticky_stays_a_design_frame() {
|
||||
assert!(frame.board.is_none());
|
||||
assert_eq!(frame.children.len(), 3);
|
||||
}
|
||||
|
||||
/// `board_node("SHAPE_WITH_TEXT")` of one FigJam kind.
|
||||
fn shape_node(kind: &'static str) -> Kv<'static> {
|
||||
let mut layer = board_node("SHAPE_WITH_TEXT");
|
||||
set(&mut layer, "shapeWithTextType", e(kind));
|
||||
layer
|
||||
}
|
||||
|
||||
/// On a whiteboard a diamond is a native shape: FigCraft draws its outline and its text sits inside.
|
||||
#[test]
|
||||
fn a_jam_diamond_is_a_native_shape_drawn_by_figcraft() {
|
||||
let (doc, warnings) = jam(shape_node("DIAMOND"));
|
||||
let frame = named(&doc, "Board object");
|
||||
assert_eq!(frame.board, Some(figcraft_doc::BoardItem::Shape { shape: figcraft_doc::BoardShape::Diamond }));
|
||||
assert!(frame.fills.is_empty());
|
||||
assert_eq!((frame.width, frame.height), (240.0, 240.0));
|
||||
assert_eq!(frame.layout.as_ref().expect("shape auto layout").padding, [0.25 * 240.0; 4]);
|
||||
assert_eq!(
|
||||
(frame.child_layout.sizing_h, frame.child_layout.sizing_v),
|
||||
(figcraft_doc::Sizing::Fixed, figcraft_doc::Sizing::Fixed),
|
||||
"a fixed box, as a shape made here: it must not hug its text"
|
||||
);
|
||||
assert_eq!(frame.children.len(), 2, "the outline and the text: {warnings:?}");
|
||||
let outline = doc.node(frame.children[0]).unwrap();
|
||||
let NodeKind::Vector { network } = &outline.kind else { panic!("{:?}", outline.kind) };
|
||||
assert_eq!(*network, figcraft_doc::VectorNetwork::from_path(&figcraft_doc::BoardShape::Diamond.path(240.0, 240.0)));
|
||||
assert_eq!(outline.fills[0].solid_color().unwrap().to_rgba8(), [255, 191, 64, 255]);
|
||||
assert!(outline.child_layout.absolute);
|
||||
assert_eq!(outline.constraints.horizontal, figcraft_doc::HConstraint::Scale);
|
||||
assert_eq!(outline.constraints.vertical, figcraft_doc::VConstraint::Scale);
|
||||
let label = doc.node(frame.children[1]).unwrap().kind.text().unwrap();
|
||||
assert_eq!(label.characters, "Olá\nIdea");
|
||||
assert_eq!(label.align_h, figcraft_doc::TextAlignH::Center);
|
||||
}
|
||||
|
||||
/// A shape past the importer's size cap is drawn at the capped size, so its outline stays inside
|
||||
/// its frame.
|
||||
#[test]
|
||||
fn a_jam_shape_past_the_size_cap_draws_its_outline_at_the_cap() {
|
||||
let mut layer = shape_node("DIAMOND");
|
||||
set(&mut layer, "size", xy(2_000_000.0, 2_000_000.0));
|
||||
let (doc, warnings) = jam(layer);
|
||||
let frame = named(&doc, "Board object");
|
||||
assert_eq!(frame.board, Some(figcraft_doc::BoardItem::Shape { shape: figcraft_doc::BoardShape::Diamond }), "{warnings:?}");
|
||||
assert_eq!((frame.width, frame.height), (1e6, 1e6));
|
||||
let outline = doc.node(frame.children[0]).unwrap();
|
||||
let NodeKind::Vector { network } = &outline.kind else { panic!("{:?}", outline.kind) };
|
||||
assert_eq!(*network, figcraft_doc::VectorNetwork::from_path(&figcraft_doc::BoardShape::Diamond.path(1e6, 1e6)));
|
||||
}
|
||||
|
||||
/// 23 of FigJam's 30 shape kinds have a FigCraft outline; the other 7 stay frames and say which.
|
||||
#[test]
|
||||
fn every_figjam_shape_kind_maps_or_stays_a_frame() {
|
||||
let kinds = [
|
||||
"SQUARE",
|
||||
"ROUNDED_RECTANGLE",
|
||||
"ELLIPSE",
|
||||
"DIAMOND",
|
||||
"TRIANGLE_UP",
|
||||
"TRIANGLE_DOWN",
|
||||
"PARALLELOGRAM_RIGHT",
|
||||
"PARALLELOGRAM_LEFT",
|
||||
"TRAPEZOID",
|
||||
"PENTAGON",
|
||||
"HEXAGON",
|
||||
"OCTAGON",
|
||||
"STAR",
|
||||
"PLUS",
|
||||
"ARROW_LEFT",
|
||||
"ARROW_RIGHT",
|
||||
"CHEVRON",
|
||||
"SPEECH_BUBBLE",
|
||||
"ENG_DATABASE",
|
||||
"DOCUMENT_SINGLE",
|
||||
"PREDEFINED_PROCESS",
|
||||
"MANUAL_INPUT",
|
||||
"INTERNAL_STORAGE",
|
||||
"ENG_QUEUE",
|
||||
"ENG_FILE",
|
||||
"ENG_FOLDER",
|
||||
"SHIELD",
|
||||
"DOCUMENT_MULTIPLE",
|
||||
"SUMMING_JUNCTION",
|
||||
"OR",
|
||||
];
|
||||
assert_eq!(kinds.len(), 30);
|
||||
let mut mapped = 0;
|
||||
for kind in kinds {
|
||||
let table = super::map::board_shape(kind);
|
||||
let (doc, warnings) = jam(shape_node(kind));
|
||||
let frame = named(&doc, "Board object");
|
||||
if let Some(shape) = table {
|
||||
mapped += 1;
|
||||
assert_eq!(frame.board, Some(figcraft_doc::BoardItem::Shape { shape }), "{kind}");
|
||||
} else {
|
||||
assert!(frame.board.is_none(), "{kind}");
|
||||
assert!(warnings.iter().any(|w| w.contains(kind) && w.contains("no FigCraft outline")), "{kind}: {warnings:?}");
|
||||
}
|
||||
}
|
||||
assert_eq!(mapped, 23);
|
||||
}
|
||||
|
||||
/// A square keeps the paints and weight the file gave it, as read.
|
||||
#[test]
|
||||
fn a_square_keeps_its_paints_and_weight() {
|
||||
let mut layer = shape_node("SQUARE");
|
||||
let background =
|
||||
record(0, vec![("fillPaints", arr(vec![solid(1.0, 1.0, 1.0)])), ("strokePaints", arr(vec![solid(0.5, 0.5, 0.5)])), ("strokeWeight", f(4.0))]);
|
||||
set(&mut layer, "nodeGenerationData", o(vec![("overrides", arr(vec![background, record(1, text("Olá", 16.0))]))]));
|
||||
let (doc, _) = jam(layer);
|
||||
let frame = named(&doc, "Board object");
|
||||
assert_eq!(frame.board, Some(figcraft_doc::BoardItem::Shape { shape: figcraft_doc::BoardShape::Rectangle }));
|
||||
let outline = doc.node(frame.children[0]).unwrap();
|
||||
assert_eq!(outline.fills[0].solid_color().unwrap().to_rgba8(), [255, 255, 255, 255]);
|
||||
assert_eq!(outline.strokes[0].solid_color().unwrap().to_rgba8(), [128, 128, 128, 255]);
|
||||
assert_eq!(outline.stroke.weight, 4.0);
|
||||
}
|
||||
|
||||
/// A shape record that isn't complete keeps today's generated layers and no board item.
|
||||
#[test]
|
||||
fn a_damaged_shape_record_keeps_the_generated_layers() {
|
||||
let mut cases = Vec::new();
|
||||
let mut a = shape_node("DIAMOND");
|
||||
set(&mut a, "derivedImmutableFrameData", o(vec![("version", u(2))]));
|
||||
cases.push(a);
|
||||
let mut b = shape_node("DIAMOND");
|
||||
set(&mut b, "nodeGenerationData", o(vec![("overrides", arr(vec![record(1, text("Olá", 16.0))]))]));
|
||||
cases.push(b);
|
||||
let mut c = shape_node("DIAMOND");
|
||||
let background = record(0, vec![("fillPaints", arr(vec![solid(1.0, 1.0, 1.0)]))]);
|
||||
set(&mut c, "nodeGenerationData", o(vec![("overrides", arr(vec![background]))]));
|
||||
cases.push(c);
|
||||
for (i, layer) in cases.into_iter().enumerate() {
|
||||
let (as_fig, fig_warnings) = imported(layer.clone());
|
||||
let (doc, warnings) = jam(layer);
|
||||
let frame = named(&doc, "Board object");
|
||||
assert!(frame.board.is_none(), "case {i}");
|
||||
assert_eq!(frame.children.len(), named(&as_fig, "Board object").children.len(), "case {i}: the generated layers, as in a .fig");
|
||||
let sorted = |mut w: Vec<String>| {
|
||||
w.sort();
|
||||
w
|
||||
};
|
||||
assert_eq!(sorted(warnings), sorted(fig_warnings), "case {i}: today's warnings");
|
||||
}
|
||||
}
|
||||
|
||||
/// A shape with no text yet is still a native shape (an empty one).
|
||||
#[test]
|
||||
fn a_jam_shape_without_text_is_still_a_native_shape() {
|
||||
let mut layer = shape_node("SQUARE");
|
||||
let background = record(0, vec![("fillPaints", arr(vec![solid(1.0, 1.0, 1.0)]))]);
|
||||
set(&mut layer, "nodeGenerationData", o(vec![("overrides", arr(vec![background, record(1, text("", 16.0))]))]));
|
||||
let (doc, _) = jam(layer);
|
||||
let frame = named(&doc, "Board object");
|
||||
assert_eq!(frame.board, Some(figcraft_doc::BoardItem::Shape { shape: figcraft_doc::BoardShape::Rectangle }));
|
||||
assert_eq!(doc.node(frame.children[1]).unwrap().kind.text().unwrap().characters, "");
|
||||
}
|
||||
|
||||
/// Blank generated text must not hide text the outer node still carries (#1397): on a whiteboard
|
||||
/// too, such a shape keeps the generated layers.
|
||||
#[test]
|
||||
fn a_jam_shape_whose_text_only_the_outer_node_carries_keeps_it() {
|
||||
let mut layer = shape_node("SQUARE");
|
||||
set(&mut layer, "textData", o(vec![("characters", s("Outer saved text"))]));
|
||||
let background = record(0, vec![("fillPaints", arr(vec![solid(1.0, 1.0, 1.0)]))]);
|
||||
set(&mut layer, "nodeGenerationData", o(vec![("overrides", arr(vec![background, record(1, text(" ", 24.0))]))]));
|
||||
let (doc, _) = jam(layer);
|
||||
let frame = named(&doc, "Board object");
|
||||
assert!(frame.board.is_none(), "the generated layers keep the outer text");
|
||||
assert!(frame.children.iter().filter_map(|id| doc.node(*id)?.kind.text()).any(|t| t.characters == "Outer saved text"));
|
||||
}
|
||||
|
||||
@@ -71,7 +71,7 @@ const AUX: u32 = 2;
|
||||
pub(super) const SCHEMA: &str = "
|
||||
enum MessageType JOIN_START=0 NODE_CHANGES=1
|
||||
enum NodePhase CREATED=0 REMOVED=1
|
||||
enum NodeType NONE=0 DOCUMENT=1 CANVAS=2 GROUP=3 FRAME=4 BOOLEAN_OPERATION=5 VECTOR=6 STAR=7 LINE=8 ELLIPSE=9 RECTANGLE=10 REGULAR_POLYGON=11 ROUNDED_RECTANGLE=12 TEXT=13 SLICE=14 SYMBOL=15 INSTANCE=16 SECTION=25 VARIABLE=28 VARIABLE_SET=31
|
||||
enum NodeType NONE=0 DOCUMENT=1 CANVAS=2 GROUP=3 FRAME=4 BOOLEAN_OPERATION=5 VECTOR=6 STAR=7 LINE=8 ELLIPSE=9 RECTANGLE=10 REGULAR_POLYGON=11 ROUNDED_RECTANGLE=12 TEXT=13 SLICE=14 SYMBOL=15 INSTANCE=16 SECTION=25 VARIABLE=28 VARIABLE_SET=31 TEXT_PATH=41
|
||||
enum BlendMode PASS_THROUGH=0 NORMAL=1 DARKEN=2 MULTIPLY=3 LINEAR_BURN=4 COLOR_BURN=5 LIGHTEN=6 SCREEN=7 LINEAR_DODGE=8 COLOR_DODGE=9 OVERLAY=10 SOFT_LIGHT=11 HARD_LIGHT=12 DIFFERENCE=13 EXCLUSION=14 HUE=15 SATURATION=16 COLOR=17 LUMINOSITY=18
|
||||
enum PaintType SOLID=0 GRADIENT_LINEAR=1 GRADIENT_RADIAL=2 GRADIENT_ANGULAR=3 GRADIENT_DIAMOND=4 IMAGE=5
|
||||
enum ImageScaleMode STRETCH=0 FIT=1 FILL=2 TILE=3
|
||||
@@ -151,6 +151,7 @@ message TextLineData LineType lineType=1, int styleId=10, int indentationLevel=2
|
||||
message TextData string characters=1, uint[] characterStyleIDs=2, NodeChange[] styleOverrideTable=3, TextLineData[] lines=12
|
||||
message Path WindingRule windingRule=1, uint commandsBlob=2, uint styleID=3
|
||||
message VectorData uint vectorNetworkBlob=1, Vector normalizedSize=2, NodeChange[] styleOverrideTable=3
|
||||
message TextPathStart float tValue=1, bool forward=2
|
||||
message ArcData float startingAngle=1, float endingAngle=2, float innerRadius=3
|
||||
message OptionalVector Vector value=1
|
||||
message LayoutGrid LayoutGridType type=1, Axis axis=2, bool visible=3, int numSections=4, float offset=5, float sectionSize=6, float gutterSize=7, Color color=8, LayoutGridPattern pattern=9, VariableData numSectionsVar=10, VariableData offsetVar=11, VariableData sectionSizeVar=12, VariableData gutterSizeVar=13
|
||||
@@ -190,7 +191,7 @@ message GridTrackSizingFunction GridTrackSizingType type=1, float value=2
|
||||
message GridTrackSize GridTrackSizingFunction minSizing=1, GridTrackSizingFunction maxSizing=2
|
||||
message GUIDGridTrackSizeMapEntry GUID id=1, GridTrackSize trackSize=2
|
||||
message GUIDGridTrackSizeMap GUIDGridTrackSizeMapEntry[] entries=1
|
||||
message NodeChange GUID guid=1, NodePhase phase=2, ParentIndex parentIndex=3, NodeType type=4, string name=5, bool visible=6, bool locked=7, float opacity=8, BlendMode blendMode=9, Vector size=11, Matrix transform=12, bool mask=16, MaskType maskType=317, float backgroundOpacity=19, bool backgroundEnabled=15, bool internalOnly=142, string description=318, StyleType styleType=163, string sortPosition=320, StyleId styleIdForFill=332, StyleId styleIdForStrokeFill=333, StyleId styleIdForText=334, StyleId styleIdForEffect=335, StyleId styleIdForGrid=336, VariableDataMap variableConsumptionMap=307, VariableModeBySetMap variableModeBySetMap=316, VariableSetMode[] variableSetModes=312, VariableSetID variableSetID=313, VariableResolvedDataType variableResolvedType=314, VariableDataValues variableDataValues=315, VariableScope[] variableScopes=353, DocumentColorProfile documentColorProfile=349, Paint[] fillPaints=38, Paint[] strokePaints=39, float strokeWeight=26, StrokeAlign strokeAlign=29, StrokeJoin strokeJoin=31, StrokeCap strokeCap=30, float[] dashPattern=13, float miterLimit=25, bool borderStrokeWeightsIndependent=299, float borderTopWeight=295, float borderRightWeight=298, float borderBottomWeight=296, float borderLeftWeight=297, Effect[] effects=43, float cornerRadius=20, float cornerSmoothing=160, bool rectangleCornerRadiiIndependent=149, float rectangleTopLeftCornerRadius=145, float rectangleTopRightCornerRadius=146, float rectangleBottomRightCornerRadius=148, float rectangleBottomLeftCornerRadius=147, ConstraintType horizontalConstraint=28, ConstraintType verticalConstraint=37, bool frameMaskDisabled=115, bool resizeToFit=117, bool isStateGroup=225, StateGroupPropertyValueOrder[] stateGroupPropertyValueOrders=238, bool sectionContentsHidden=283, Color backgroundColor=50, StackMode stackMode=105, float stackSpacing=107, float stackCounterSpacing=324, StackWrap stackWrap=323, StackCounterAlignContent stackCounterAlignContent=343, float stackHorizontalPadding=209, float stackVerticalPadding=210, float stackPaddingRight=233, float stackPaddingBottom=234, StackJustify stackPrimaryAlignItems=230, StackAlign stackCounterAlignItems=231, StackSize stackPrimarySizing=229, StackSize stackCounterSizing=221, bool bordersTakeSpace=294, bool stackReverseZIndex=271, float gridColumnGap=438, float gridRowGap=437, GUIDPositionMap gridColumns=436, GUIDPositionMap gridRows=435, GUIDGridTrackSizeMap gridColumnsSizing=474, GUIDGridTrackSizeMap gridRowsSizing=475, float stackChildPrimaryGrow=232, StackCounterAlign stackChildAlignSelf=236, StackPositioning stackPositioning=269, OptionalVector minSize=325, OptionalVector maxSize=326, GUID gridColumnAnchor=440, GUID gridRowAnchor=439, uint gridColumnSpan=442, uint gridRowSpan=441, LayoutGrid[] layoutGrids=47, ExportSettings[] exportSettings=45, TextData textData=42, FontName fontName=41, float fontSize=21, Number lineHeight=40, Number letterSpacing=165, TextCase textCase=34, TextDecoration textDecoration=35, TextAlignHorizontal textAlignHorizontal=32, TextAlignVertical textAlignVertical=33, TextAutoResize textAutoResize=46, TextTruncation textTruncation=280, int maxLines=351, float paragraphSpacing=23, float paragraphIndent=22, float listSpacing=264, LeadingTrim leadingTrim=322, bool hangingPunctuation=337, bool hangingList=339, Hyperlink hyperlink=223, bool autoRename=14, bool fontVariantCommonLigatures=127, bool fontVariantContextualLigatures=128, string fontVersion=202, uint textUserLayoutVersion=203, uint textExplicitLayoutVersion=396, uint textBidiVersion=279, float textTracking=27, bool textDecorationSkipInk=412, EmojiImageSet emojiImageSet=391, uint styleID=49, Path[] fillGeometry=51, Path[] strokeGeometry=52, VectorData vectorData=48, VectorMirror handleMirroring=44, uint count=10, float starInnerScale=24, ArcData arcData=195, BooleanOperation booleanOperation=36, string symbolDescription=144, VariableWidthPoint[] variableWidthPoints=447, PluginData[] pluginData=204, SymbolData symbolData=113, NodeChange[] derivedSymbolData=125, GUID overriddenSymbolID=143, ComponentPropDef[] componentPropDefs=266, ComponentPropRef[] componentPropRefs=267, ComponentPropAssignment[] componentPropAssignments=268, VariantPropSpec[] variantPropSpecs=483, VariableDataMap parameterConsumptionMap=445, GUIDPath guidPath=111, PrototypeInteraction[] prototypeInteractions=226, PrototypeStartingPoint prototypeStartingPoint=249, ScrollDirection scrollDirection=159, ScrollBehavior scrollBehavior=186, OverlayPositionType overlayPositionType=198, OverlayBackgroundInteraction overlayBackgroundInteraction=200, OverlayBackgroundAppearance overlayBackgroundAppearance=201, Color prototypeBackgroundColor=141
|
||||
message NodeChange GUID guid=1, NodePhase phase=2, ParentIndex parentIndex=3, NodeType type=4, string name=5, bool visible=6, bool locked=7, float opacity=8, BlendMode blendMode=9, Vector size=11, Matrix transform=12, bool mask=16, MaskType maskType=317, float backgroundOpacity=19, bool backgroundEnabled=15, bool internalOnly=142, string description=318, StyleType styleType=163, string sortPosition=320, StyleId styleIdForFill=332, StyleId styleIdForStrokeFill=333, StyleId styleIdForText=334, StyleId styleIdForEffect=335, StyleId styleIdForGrid=336, VariableDataMap variableConsumptionMap=307, VariableModeBySetMap variableModeBySetMap=316, VariableSetMode[] variableSetModes=312, VariableSetID variableSetID=313, VariableResolvedDataType variableResolvedType=314, VariableDataValues variableDataValues=315, VariableScope[] variableScopes=353, DocumentColorProfile documentColorProfile=349, Paint[] fillPaints=38, Paint[] strokePaints=39, float strokeWeight=26, StrokeAlign strokeAlign=29, StrokeJoin strokeJoin=31, StrokeCap strokeCap=30, float[] dashPattern=13, float miterLimit=25, bool borderStrokeWeightsIndependent=299, float borderTopWeight=295, float borderRightWeight=298, float borderBottomWeight=296, float borderLeftWeight=297, Effect[] effects=43, float cornerRadius=20, float cornerSmoothing=160, bool rectangleCornerRadiiIndependent=149, float rectangleTopLeftCornerRadius=145, float rectangleTopRightCornerRadius=146, float rectangleBottomRightCornerRadius=148, float rectangleBottomLeftCornerRadius=147, ConstraintType horizontalConstraint=28, ConstraintType verticalConstraint=37, bool frameMaskDisabled=115, bool resizeToFit=117, bool isStateGroup=225, StateGroupPropertyValueOrder[] stateGroupPropertyValueOrders=238, bool sectionContentsHidden=283, Color backgroundColor=50, StackMode stackMode=105, float stackSpacing=107, float stackCounterSpacing=324, StackWrap stackWrap=323, StackCounterAlignContent stackCounterAlignContent=343, float stackHorizontalPadding=209, float stackVerticalPadding=210, float stackPaddingRight=233, float stackPaddingBottom=234, StackJustify stackPrimaryAlignItems=230, StackAlign stackCounterAlignItems=231, StackSize stackPrimarySizing=229, StackSize stackCounterSizing=221, bool bordersTakeSpace=294, bool stackReverseZIndex=271, float gridColumnGap=438, float gridRowGap=437, GUIDPositionMap gridColumns=436, GUIDPositionMap gridRows=435, GUIDGridTrackSizeMap gridColumnsSizing=474, GUIDGridTrackSizeMap gridRowsSizing=475, float stackChildPrimaryGrow=232, StackCounterAlign stackChildAlignSelf=236, StackPositioning stackPositioning=269, OptionalVector minSize=325, OptionalVector maxSize=326, GUID gridColumnAnchor=440, GUID gridRowAnchor=439, uint gridColumnSpan=442, uint gridRowSpan=441, LayoutGrid[] layoutGrids=47, ExportSettings[] exportSettings=45, TextData textData=42, FontName fontName=41, float fontSize=21, Number lineHeight=40, Number letterSpacing=165, TextCase textCase=34, TextDecoration textDecoration=35, TextAlignHorizontal textAlignHorizontal=32, TextAlignVertical textAlignVertical=33, TextAutoResize textAutoResize=46, TextTruncation textTruncation=280, int maxLines=351, float paragraphSpacing=23, float paragraphIndent=22, float listSpacing=264, LeadingTrim leadingTrim=322, bool hangingPunctuation=337, bool hangingList=339, Hyperlink hyperlink=223, bool autoRename=14, bool fontVariantCommonLigatures=127, bool fontVariantContextualLigatures=128, string fontVersion=202, uint textUserLayoutVersion=203, uint textExplicitLayoutVersion=396, uint textBidiVersion=279, float textTracking=27, bool textDecorationSkipInk=412, EmojiImageSet emojiImageSet=391, uint styleID=49, Path[] fillGeometry=51, Path[] strokeGeometry=52, VectorData vectorData=48, TextPathStart textPathStart=432, VectorMirror handleMirroring=44, uint count=10, float starInnerScale=24, ArcData arcData=195, BooleanOperation booleanOperation=36, string symbolDescription=144, VariableWidthPoint[] variableWidthPoints=447, PluginData[] pluginData=204, SymbolData symbolData=113, NodeChange[] derivedSymbolData=125, GUID overriddenSymbolID=143, ComponentPropDef[] componentPropDefs=266, ComponentPropRef[] componentPropRefs=267, ComponentPropAssignment[] componentPropAssignments=268, VariantPropSpec[] variantPropSpecs=483, VariableDataMap parameterConsumptionMap=445, GUIDPath guidPath=111, PrototypeInteraction[] prototypeInteractions=226, PrototypeStartingPoint prototypeStartingPoint=249, ScrollDirection scrollDirection=159, ScrollBehavior scrollBehavior=186, OverlayPositionType overlayPositionType=198, OverlayBackgroundInteraction overlayBackgroundInteraction=200, OverlayBackgroundAppearance overlayBackgroundAppearance=201, Color prototypeBackgroundColor=141
|
||||
struct Blob byte[] bytes
|
||||
message Message MessageType type=1, uint sessionID=2, NodeChange[] nodeChanges=4, Blob[] blobs=6
|
||||
";
|
||||
|
||||
@@ -74,6 +74,11 @@ impl<'d> Exporter<'d> {
|
||||
}
|
||||
_ => None,
|
||||
};
|
||||
// A text on a path is its own layer kind, written only when its path fields were built.
|
||||
let on_path = match &n.kind {
|
||||
NodeKind::Text(td) => self.text_path(n, td, nested),
|
||||
_ => None,
|
||||
};
|
||||
let ty = match &n.kind {
|
||||
NodeKind::Page { .. } | NodeKind::Frame | NodeKind::Group | NodeKind::ComponentSet { .. } => "FRAME",
|
||||
NodeKind::Instance { .. } if main.is_none() => "FRAME",
|
||||
@@ -84,6 +89,7 @@ impl<'d> Exporter<'d> {
|
||||
NodeKind::Star { .. } => "STAR",
|
||||
NodeKind::Line => "LINE",
|
||||
NodeKind::Vector { .. } => "VECTOR",
|
||||
NodeKind::Text(_) if on_path.is_some() => "TEXT_PATH",
|
||||
NodeKind::Text(_) => "TEXT",
|
||||
NodeKind::BooleanOp { .. } => "BOOLEAN_OPERATION",
|
||||
NodeKind::Component { .. } => "SYMBOL",
|
||||
@@ -107,7 +113,16 @@ impl<'d> Exporter<'d> {
|
||||
NodeKind::Polygon { count } => f.push(("count", u(*count))),
|
||||
NodeKind::Star { count, inner_ratio } => f.extend([("count", u(*count)), ("starInnerScale", fl(*inner_ratio))]),
|
||||
NodeKind::Vector { network } => self.vector(n, network, f),
|
||||
NodeKind::Text(td) => self.text(td, &n.fills, f),
|
||||
NodeKind::Text(td) => {
|
||||
self.text(td, &n.fills, f);
|
||||
if let Some(path) = on_path {
|
||||
// Text on a path has no box to align in: it is written as top, which is how it draws.
|
||||
if let Some(entry) = f.iter_mut().find(|(k, _)| *k == "textAlignVertical") {
|
||||
entry.1 = e("TOP");
|
||||
}
|
||||
f.extend(path);
|
||||
}
|
||||
}
|
||||
NodeKind::BooleanOp { op } => {
|
||||
let name = match op {
|
||||
BoolOp::Union => "UNION",
|
||||
|
||||
@@ -173,9 +173,6 @@ impl<'d> Exporter<'d> {
|
||||
if styles.clone().any(|st| unsupported_decoration_look(st) || !st.variations.is_empty()) {
|
||||
self.warn("text decoration looks and variable font settings were left out");
|
||||
}
|
||||
if td.path.is_some() {
|
||||
self.warn("text on a path was written as plain text");
|
||||
}
|
||||
if !td.features.is_empty() {
|
||||
self.warn("OpenType features were left out");
|
||||
}
|
||||
@@ -374,4 +371,236 @@ impl<'d> Exporter<'d> {
|
||||
self.blobs.insert(bytes, i);
|
||||
Some(i)
|
||||
}
|
||||
|
||||
/// The fields of a text on a path (its start and its path as a vector network), or `None` when the text stays plain text
|
||||
/// (with the warning that says why). `nested`: for an instance's override row, which follows its main's layer.
|
||||
pub(super) fn text_path(&mut self, n: &Node, td: &TextData, nested: bool) -> Option<Fields> {
|
||||
let doc = self.doc;
|
||||
let own = text_path_net(td, n.width, n.height);
|
||||
let main = if nested { n.source.and_then(|s| doc.node(s)) } else { None };
|
||||
if let Some(main) = main {
|
||||
let main_ok = matches!(&main.kind, NodeKind::Text(m) if text_path_net(m, main.width, main.height).is_ok());
|
||||
if main_ok != own.is_ok() {
|
||||
// An override can't take its layer off the main's path. So an instance text of
|
||||
// more than one line, on a main that is on a path, stays on that path in the file:
|
||||
// say so rather than the general mismatch (FigCraft's import reads it as plain text).
|
||||
let lines = main_ok && matches!(own, Err(TEXT_PATH_LINES));
|
||||
self.warn(if lines { TEXT_PATH_INSTANCE_LINES } else { TEXT_PATH_INSTANCE });
|
||||
return None;
|
||||
}
|
||||
}
|
||||
let tp = td.path.as_deref()?;
|
||||
let made = match own {
|
||||
Ok(made) => made,
|
||||
Err(why) => {
|
||||
self.warn(why);
|
||||
return None;
|
||||
}
|
||||
};
|
||||
let Some(index) = self.blob(network::encode(&made.net)) else {
|
||||
self.warn(TEXT_PATH_CANT);
|
||||
return None;
|
||||
};
|
||||
if made.later_parts {
|
||||
self.warn(TEXT_PATH_PARTS);
|
||||
}
|
||||
Some(vec![
|
||||
("textPathStart", o(vec![("tValue", fl(made.t)), ("forward", b(!tp.flip))])),
|
||||
("vectorData", o(vec![("vectorNetworkBlob", u(index)), ("normalizedSize", xy(n.width, n.height))])),
|
||||
])
|
||||
}
|
||||
}
|
||||
|
||||
/// The style id the format gives the segment a text on a path starts on.
|
||||
const TEXT_PATH_MARK: u32 = 0x01ff_ffff;
|
||||
const TEXT_PATH_LINES: &str = "text on a path with more than one line was written as plain text";
|
||||
const TEXT_PATH_CANT: &str = "text on a path the format can't hold was written as plain text";
|
||||
const TEXT_PATH_PARTS: &str = "the parts of a text's path after the first were left out";
|
||||
const TEXT_PATH_INSTANCE: &str =
|
||||
"text on a path in an instance but not in its main component, or the other way round, was written as the main has it";
|
||||
const TEXT_PATH_INSTANCE_LINES: &str =
|
||||
"an instance's text of more than one line stays on its main component's text path in the file, as an override can't take it off";
|
||||
|
||||
/// A text's path as the format holds it: one chain (or cycle) of a vector network with the
|
||||
/// segment the text starts on marked, and the start as that segment's own parameter.
|
||||
struct PathNet {
|
||||
net: network::Network,
|
||||
t: f64,
|
||||
later_parts: bool,
|
||||
}
|
||||
|
||||
/// The tangent-to-control-point cubic of a network segment, as the import reads it.
|
||||
fn net_cubic(net: &network::Network, s: &network::Segment) -> Option<(figcraft_doc::geom::kurbo::CubicBez, bool)> {
|
||||
use figcraft_doc::geom::kurbo::CubicBez;
|
||||
let (a, b) = (net.vertices.get(s.a)?, net.vertices.get(s.b)?);
|
||||
let line = s.ta == (0.0, 0.0) && s.tb == (0.0, 0.0);
|
||||
let cubic = CubicBez::new((a.x, a.y), (a.x + s.ta.0, a.y + s.ta.1), (b.x + s.tb.0, b.y + s.tb.1), (b.x, b.y));
|
||||
Some((cubic, line))
|
||||
}
|
||||
|
||||
/// The length of a segment, as the import measures it.
|
||||
fn net_length(net: &network::Network, s: &network::Segment) -> f64 {
|
||||
use figcraft_doc::geom::kurbo::{Line, ParamCurveArclen};
|
||||
match net_cubic(net, s) {
|
||||
Some((c, true)) => Line::new(c.p0, c.p3).arclen(1e-9),
|
||||
Some((c, false)) => c.arclen(1e-9),
|
||||
None => 0.0,
|
||||
}
|
||||
}
|
||||
|
||||
/// The part of a path (a move and what follows it) as a chain of the network, and whether it is
|
||||
/// a cycle; `None` without a segment longer than a billionth.
|
||||
fn path_chain(part: &[figcraft_doc::geom::kurbo::PathEl]) -> Option<(network::Network, bool)> {
|
||||
use figcraft_doc::geom::kurbo::{PathEl, Point, QuadBez};
|
||||
let r = |x: f64| f64::from(finite(x) as f32);
|
||||
let rp = |p: Point| (r(p.x), r(p.y));
|
||||
let mut net = network::Network::default();
|
||||
let mut closed = false;
|
||||
let mut cur = (0.0, 0.0);
|
||||
let add = |net: &mut network::Network, c1: Option<(f64, f64)>, c2: Option<(f64, f64)>, end: (f64, f64)| {
|
||||
let Some(last) = net.vertices.last() else { return };
|
||||
let (a, index) = ((last.x, last.y), net.vertices.len() - 1);
|
||||
let tangent = |c: Option<(f64, f64)>, from: (f64, f64)| c.map_or((0.0, 0.0), |c| (r(c.0 - from.0), r(c.1 - from.1)));
|
||||
let seg = network::Segment { style: 0, a: index, ta: tangent(c1, a), b: index + 1, tb: tangent(c2, end) };
|
||||
net.vertices.push(network::Vertex { style: 0, x: end.0, y: end.1 });
|
||||
if net_length(net, &seg) > 1e-9 {
|
||||
net.segments.push(seg);
|
||||
} else {
|
||||
net.vertices.pop();
|
||||
}
|
||||
};
|
||||
for el in part {
|
||||
match el {
|
||||
PathEl::MoveTo(p) => {
|
||||
cur = rp(*p);
|
||||
net.vertices.push(network::Vertex { style: 0, x: cur.0, y: cur.1 });
|
||||
}
|
||||
PathEl::LineTo(p) => {
|
||||
cur = rp(*p);
|
||||
add(&mut net, None, None, cur);
|
||||
}
|
||||
PathEl::QuadTo(c, p) => {
|
||||
let q = QuadBez::new(Point::new(cur.0, cur.1), Point::new(r(c.x), r(c.y)), Point::new(r(p.x), r(p.y))).raise();
|
||||
cur = rp(*p);
|
||||
add(&mut net, Some((q.p1.x, q.p1.y)), Some((q.p2.x, q.p2.y)), cur);
|
||||
}
|
||||
PathEl::CurveTo(a, b, p) => {
|
||||
cur = rp(*p);
|
||||
// The control points are not rounded on their own: the format holds each as its offset from the end
|
||||
// point, and taken from the point as read that is the offset the file had.
|
||||
add(&mut net, Some((finite(a.x), finite(a.y))), Some((finite(b.x), finite(b.y))), cur);
|
||||
}
|
||||
PathEl::ClosePath => closed = true,
|
||||
}
|
||||
}
|
||||
if net.segments.is_empty() {
|
||||
return None;
|
||||
}
|
||||
let first = net.vertices.first().map(|v| (v.x, v.y))?;
|
||||
let last = net.vertices.last().map(|v| (v.x, v.y))?;
|
||||
let near = |p: (f64, f64), q: (f64, f64)| (p.0 - q.0).hypot(p.1 - q.1) <= 1e-6;
|
||||
let mut cycle = false;
|
||||
if closed || near(last, first) {
|
||||
if near(last, first) {
|
||||
// The last segment ends on the first vertex. A single segment stays an open chain of
|
||||
// two vertices at one place: the import refuses a segment from a vertex to itself.
|
||||
if net.segments.len() > 1 {
|
||||
net.vertices.pop();
|
||||
if let Some(s) = net.segments.last_mut() {
|
||||
s.b = 0;
|
||||
s.tb = (r(last.0 + s.tb.0 - first.0), r(last.1 + s.tb.1 - first.1));
|
||||
cycle = true;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
net.segments.push(network::Segment { style: 0, a: net.vertices.len() - 1, ta: (0.0, 0.0), b: 0, tb: (0.0, 0.0) });
|
||||
cycle = true;
|
||||
}
|
||||
}
|
||||
Some((net, cycle))
|
||||
}
|
||||
|
||||
/// A text on a path as the format holds it, or the warning for why it stays plain text.
|
||||
fn text_path_net(td: &TextData, w: f64, h: f64) -> Result<PathNet, &'static str> {
|
||||
use figcraft_doc::geom::kurbo::{ParamCurveArclen, PathEl};
|
||||
let Some(tp) = td.path.as_deref() else { return Err(TEXT_PATH_CANT) };
|
||||
if td.characters.contains(['\n', '\r']) {
|
||||
return Err(TEXT_PATH_LINES);
|
||||
}
|
||||
let path = tp.path();
|
||||
let mut parts: Vec<Vec<PathEl>> = Vec::new();
|
||||
for el in path.elements() {
|
||||
if matches!(el, PathEl::MoveTo(_)) {
|
||||
parts.push(Vec::new());
|
||||
}
|
||||
if let Some(part) = parts.last_mut() {
|
||||
part.push(*el);
|
||||
}
|
||||
}
|
||||
let mut chains = parts.iter().filter_map(|p| path_chain(p));
|
||||
let (mut net, cycle) = chains.next().ok_or(TEXT_PATH_CANT)?;
|
||||
let later_parts = chains.next().is_some();
|
||||
if net.vertices.len() + net.segments.len() > MAX_NETWORK {
|
||||
return Err(TEXT_PATH_CANT);
|
||||
}
|
||||
// The import scales the coordinates by size over normalized size, which are the same number
|
||||
// here; an axis of no extent holds nothing but zeros.
|
||||
let size = |x: f64| f64::from(finite(x) as f32);
|
||||
for (extent, axis) in [(size(w), 0), (size(h), 1)] {
|
||||
let at = |p: (f64, f64)| if axis == 0 { p.0 } else { p.1 };
|
||||
let flat = net.vertices.iter().all(|v| at((v.x, v.y)) == 0.0) && net.segments.iter().all(|s| at(s.ta) == 0.0 && at(s.tb) == 0.0);
|
||||
if extent < 0.0 || (extent <= 1e-9 && (extent != 0.0 || !flat)) {
|
||||
return Err(TEXT_PATH_CANT);
|
||||
}
|
||||
}
|
||||
let lengths: Vec<f64> = net.segments.iter().map(|s| net_length(&net, s)).collect();
|
||||
let total: f64 = lengths.iter().sum();
|
||||
if !total.is_finite() || total <= 1e-10 {
|
||||
return Err(TEXT_PATH_CANT);
|
||||
}
|
||||
// The path the import builds from it must be one the text renderer can measure.
|
||||
let mut shape = figcraft_doc::geom::BezPath::new();
|
||||
for (i, s) in net.segments.iter().enumerate() {
|
||||
let Some((c, line)) = net_cubic(&net, s) else { return Err(TEXT_PATH_CANT) };
|
||||
if i == 0 {
|
||||
shape.move_to(c.p0);
|
||||
}
|
||||
if line {
|
||||
shape.line_to(c.p3);
|
||||
} else {
|
||||
shape.curve_to(c.p1, c.p2, c.p3);
|
||||
}
|
||||
}
|
||||
if cycle {
|
||||
shape.close_path();
|
||||
}
|
||||
let measured = figcraft_doc::geom::measure::polylines(&shape);
|
||||
if measured.as_ref().and_then(|l| l.first()).is_none_or(|l| l.length() <= 1e-9) {
|
||||
return Err(TEXT_PATH_CANT);
|
||||
}
|
||||
// The start, by length, as a parameter of the segment it falls on.
|
||||
let start = tp.start();
|
||||
let at = (if tp.flip { 1.0 - start } else { start }) * total;
|
||||
let mut before = 0.0;
|
||||
let mut k = lengths.len().saturating_sub(1);
|
||||
for (i, len) in lengths.iter().enumerate() {
|
||||
if before + len >= at {
|
||||
k = i;
|
||||
break;
|
||||
}
|
||||
before += len;
|
||||
}
|
||||
if k + 1 == lengths.len() && before + lengths[k] < at {
|
||||
before = total - lengths[k];
|
||||
}
|
||||
let local = (at - before).clamp(0.0, lengths[k]);
|
||||
let t = match net.segments.get(k).and_then(|s| net_cubic(&net, s)) {
|
||||
Some((_, true)) | None => local / lengths[k],
|
||||
Some((c, false)) => c.inv_arclen(local, 1e-9),
|
||||
};
|
||||
let t = if t.is_finite() { t.clamp(0.0, 1.0) } else { 0.0 };
|
||||
if let Some(s) = net.segments.get_mut(k) {
|
||||
s.style = TEXT_PATH_MARK;
|
||||
}
|
||||
Ok(PathNet { net, t, later_parts })
|
||||
}
|
||||
|
||||
@@ -4,7 +4,7 @@
|
||||
|
||||
use craft_fig::rest::{self, Geometry, RouteEnd, Routing, SavedRuns, Side};
|
||||
use figcraft_doc::geom::{Point, measure};
|
||||
use figcraft_doc::{ConnectorPath, VectorNetwork};
|
||||
use figcraft_doc::{BoardShape, ConnectorPath, VectorNetwork};
|
||||
use serde_json::Value;
|
||||
|
||||
use super::kiwi::Kv;
|
||||
@@ -72,12 +72,175 @@ pub(super) fn to_rest(msg: &Kv, name: &str, max_nodes: usize) -> (Value, Vec<Str
|
||||
/// Map a FigJam whiteboard's stickies as native board items when `board` is true.
|
||||
pub(super) fn to_rest_for(msg: &Kv, name: &str, max_nodes: usize, board: bool) -> (Value, Vec<String>, Vec<Option<VectorNetwork>>) {
|
||||
let options = rest::Options { max_nodes, geometry: &FigGeometry, outlined_stroke: Some(super::export::STASH), board };
|
||||
let mapped = rest::to_rest(msg, name, &options);
|
||||
let mut mapped = rest::to_rest(msg, name, &options);
|
||||
// Each network passes the importer's own checks, as the JSON's `vectorNetwork` does.
|
||||
let networks = mapped.networks.into_iter().map(|n| serde_json::to_value(n?).ok().and_then(|v| crate::rest::network(&v))).collect();
|
||||
let networks: Vec<Option<VectorNetwork>> =
|
||||
mapped.networks.into_iter().map(|n| serde_json::to_value(n?).ok().and_then(|v| crate::rest::network(&v))).collect();
|
||||
if board {
|
||||
native_board_shapes(msg, &mut mapped.json, &mut mapped.warnings);
|
||||
}
|
||||
(mapped.json, mapped.warnings, networks)
|
||||
}
|
||||
|
||||
/// FigJam shapes whose generated records are complete are native board items in FigCraft. The
|
||||
/// shared mapper owns the neutral generated layers; this adapter supplies only FigCraft's board
|
||||
/// shape model, outline, and layout semantics.
|
||||
fn native_board_shapes(msg: &Kv, json: &mut Value, warnings: &mut Vec<String>) {
|
||||
let Some(changes) = msg.get("nodeChanges") else { return };
|
||||
for node in changes.list() {
|
||||
if node.get("type").and_then(Kv::str) != Some("SHAPE_WITH_TEXT") {
|
||||
continue;
|
||||
}
|
||||
let Some(guid) = node.get("guid") else { continue };
|
||||
let Some(origin) = guid
|
||||
.get("sessionID")
|
||||
.and_then(Kv::f64)
|
||||
.zip(guid.get("localID").and_then(Kv::f64))
|
||||
.map(|(session, local)| format!("{}:{}", session as u64, local as u64))
|
||||
else {
|
||||
continue;
|
||||
};
|
||||
let kind = node.get("shapeWithTextType").and_then(Kv::str).unwrap_or("SQUARE");
|
||||
let Some(shape) = board_shape(kind) else {
|
||||
warnings.push(format!("shape with text kind {} has no FigCraft outline; kept as a frame", crate::rest::props::clip_str(kind)));
|
||||
continue;
|
||||
};
|
||||
// An outer text fallback means the generated body was absent or invalid. Keep the shared
|
||||
// mapper's editable generated layers in that case, matching the older FigJam adapter.
|
||||
if node.get("textData").and_then(|t| t.get("characters")).and_then(Kv::str).is_some_and(|s| !s.trim().is_empty()) {
|
||||
continue;
|
||||
}
|
||||
let Some(rest_node) = find_origin_mut(json, &origin) else { continue };
|
||||
let Some(children) = rest_node.get("children").and_then(Value::as_array) else { continue };
|
||||
let empty_body = generated_empty_body(node);
|
||||
let has_generated_outline = !children.is_empty() && children[0]["type"] == "VECTOR";
|
||||
let has_generated_label = children.len() == 2 && children[1]["type"] == "TEXT";
|
||||
if !has_generated_outline || !(has_generated_label || (children.len() == 1 && empty_body)) {
|
||||
continue;
|
||||
}
|
||||
let (Some(width), Some(height)) = (
|
||||
rest_node.get("size").and_then(|s| s.get("x")).and_then(Value::as_f64),
|
||||
rest_node.get("size").and_then(|s| s.get("y")).and_then(Value::as_f64),
|
||||
) else {
|
||||
continue;
|
||||
};
|
||||
if !(width.is_finite() && height.is_finite() && width > 0.0 && height > 0.0) {
|
||||
continue;
|
||||
}
|
||||
let (width, height) = (width.min(crate::rest::props::MAX_SIZE), height.min(crate::rest::props::MAX_SIZE));
|
||||
let Some(network) = serde_json::to_value(VectorNetwork::from_path(&shape.path(width, height))).ok() else { continue };
|
||||
|
||||
rest_node["board"] = serde_json::json!({"type": "shape", "shape": shape.id()});
|
||||
rest_node["fills"] = serde_json::json!([]);
|
||||
rest_node["strokes"] = serde_json::json!([]);
|
||||
rest_node["clipsContent"] = serde_json::json!(false);
|
||||
rest_node["layoutMode"] = serde_json::json!("VERTICAL");
|
||||
rest_node["primaryAxisAlignItems"] = serde_json::json!("CENTER");
|
||||
rest_node["counterAxisAlignItems"] = serde_json::json!("CENTER");
|
||||
rest_node["primaryAxisSizingMode"] = serde_json::json!("FIXED");
|
||||
rest_node["counterAxisSizingMode"] = serde_json::json!("FIXED");
|
||||
let [top, right, bottom, left] = shape.text_insets();
|
||||
rest_node["paddingTop"] = serde_json::json!(top * height);
|
||||
rest_node["paddingRight"] = serde_json::json!(right * width);
|
||||
rest_node["paddingBottom"] = serde_json::json!(bottom * height);
|
||||
rest_node["paddingLeft"] = serde_json::json!(left * width);
|
||||
|
||||
let Some(children) = rest_node.get_mut("children").and_then(Value::as_array_mut) else { continue };
|
||||
if children.len() == 1 {
|
||||
children.push(serde_json::json!({
|
||||
"id": format!("{origin};generated1"),
|
||||
"type": "TEXT",
|
||||
"name": "",
|
||||
"characters": "",
|
||||
"size": {"x": width, "y": height},
|
||||
"relativeTransform": [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0]],
|
||||
"style": {"textAutoResize": "HEIGHT", "textAlignHorizontal": "CENTER"},
|
||||
"layoutSizingHorizontal": "FILL"
|
||||
}));
|
||||
}
|
||||
let outline = &mut children[0];
|
||||
outline["name"] = serde_json::json!("Outline");
|
||||
outline["vectorNetwork"] = network;
|
||||
outline["size"] = serde_json::json!({"x": width, "y": height});
|
||||
outline["relativeTransform"] = serde_json::json!([[1.0, 0.0, 0.0], [0.0, 1.0, 0.0]]);
|
||||
outline["layoutPositioning"] = serde_json::json!("ABSOLUTE");
|
||||
outline["constraints"] = serde_json::json!({"horizontal": "SCALE", "vertical": "SCALE"});
|
||||
outline.as_object_mut().map(|o| o.remove("cornerRadius"));
|
||||
|
||||
let label = &mut children[1];
|
||||
label["layoutSizingHorizontal"] = serde_json::json!("FILL");
|
||||
if let Some(style) = label.get_mut("style").and_then(Value::as_object_mut) {
|
||||
style.insert("textAutoResize".into(), serde_json::json!("HEIGHT"));
|
||||
style.insert("textAlignHorizontal".into(), serde_json::json!("CENTER"));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The shared snapshot mapper omits a generated text child whose characters are empty. FigCraft
|
||||
/// still keeps that empty child on a native shape, matching its prior mapper behavior.
|
||||
fn generated_empty_body(node: &Kv) -> bool {
|
||||
fn record<'a, 's>(node: &'a Kv<'s>, field: &str) -> Option<&'a Kv<'s>> {
|
||||
node.get(field)?.get("overrides")?.list().iter().find(|record| {
|
||||
let Some(guids) = record.get("guidPath").and_then(|path| path.get("guids")).map(Kv::list) else { return false };
|
||||
if guids.len() != 1 {
|
||||
return false;
|
||||
}
|
||||
let session = guids[0].get("sessionID").and_then(Kv::f64);
|
||||
let local = guids[0].get("localID").and_then(Kv::f64);
|
||||
session == Some(40_000_000.0) && local == Some(1.0)
|
||||
})
|
||||
}
|
||||
let bounds = node.get("derivedImmutableFrameData");
|
||||
let version = bounds.and_then(|v| v.get("version")).and_then(Kv::f64);
|
||||
if version != Some(1.0) {
|
||||
return false;
|
||||
}
|
||||
let Some(style) = record(node, "nodeGenerationData") else { return false };
|
||||
let Some(_) = record(node, "derivedImmutableFrameData") else { return false };
|
||||
style.get("textData").and_then(|v| v.get("characters")).and_then(Kv::str) == Some("")
|
||||
}
|
||||
|
||||
fn find_origin_mut<'a>(value: &'a mut Value, origin: &str) -> Option<&'a mut Value> {
|
||||
if value.get(craft_fig::rest::FIG_SOURCE_FIELD).and_then(|s| s.get("origin")).and_then(Value::as_str) == Some(origin) {
|
||||
return Some(value);
|
||||
}
|
||||
match value {
|
||||
Value::Object(fields) => fields.values_mut().find_map(|child| find_origin_mut(child, origin)),
|
||||
Value::Array(items) => items.iter_mut().find_map(|child| find_origin_mut(child, origin)),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
/// FigJam's `shapeWithTextType` values that have a corresponding FigCraft board outline.
|
||||
pub(super) fn board_shape(kind: &str) -> Option<BoardShape> {
|
||||
Some(match kind {
|
||||
"SQUARE" => BoardShape::Rectangle,
|
||||
"ROUNDED_RECTANGLE" => BoardShape::RoundedRectangle,
|
||||
"ELLIPSE" => BoardShape::Ellipse,
|
||||
"DIAMOND" => BoardShape::Diamond,
|
||||
"TRIANGLE_UP" => BoardShape::Triangle,
|
||||
"TRIANGLE_DOWN" => BoardShape::TriangleDown,
|
||||
"PARALLELOGRAM_RIGHT" => BoardShape::ParallelogramRight,
|
||||
"PARALLELOGRAM_LEFT" => BoardShape::ParallelogramLeft,
|
||||
"TRAPEZOID" => BoardShape::Trapezoid,
|
||||
"PENTAGON" => BoardShape::Pentagon,
|
||||
"HEXAGON" => BoardShape::Hexagon,
|
||||
"OCTAGON" => BoardShape::Octagon,
|
||||
"STAR" => BoardShape::Star,
|
||||
"PLUS" => BoardShape::Plus,
|
||||
"ARROW_LEFT" => BoardShape::ArrowLeft,
|
||||
"ARROW_RIGHT" => BoardShape::ArrowRight,
|
||||
"CHEVRON" => BoardShape::Chevron,
|
||||
"SPEECH_BUBBLE" => BoardShape::SpeechBubble,
|
||||
"ENG_DATABASE" => BoardShape::Database,
|
||||
"DOCUMENT_SINGLE" => BoardShape::Document,
|
||||
"PREDEFINED_PROCESS" => BoardShape::PredefinedProcess,
|
||||
"MANUAL_INPUT" => BoardShape::ManualInput,
|
||||
"INTERNAL_STORAGE" => BoardShape::InternalStorage,
|
||||
_ => return None,
|
||||
})
|
||||
}
|
||||
|
||||
/// REST importer warnings reworded for a `.fig` import (`None`: drop it).
|
||||
pub(super) fn adapt_warning(w: String) -> Option<String> {
|
||||
if w.contains("geometry=paths") {
|
||||
|
||||
@@ -83,8 +83,11 @@ fn blob() -> Vec<u8> {
|
||||
}
|
||||
|
||||
fn canvas() -> Vec<u8> {
|
||||
canvas_of(message(true))
|
||||
}
|
||||
|
||||
fn canvas_of(message: Kv<'static>) -> Vec<u8> {
|
||||
let schema = super::kiwi::Schema::parse(SCHEMA).unwrap();
|
||||
let message = message(true);
|
||||
let message = super::kiwi::encode::message(&schema, schema.find("Message").unwrap(), &message).unwrap();
|
||||
let mut out = b"fig-kiwi\0\0\0\0".to_vec();
|
||||
for raw in [super::kiwi::encode::schema(&schema), message] {
|
||||
@@ -262,3 +265,379 @@ fn a_text_on_a_path_in_a_scaled_instance_has_its_path_scaled() {
|
||||
assert_eq!(path_of("Main"), "M0,0 L100,0");
|
||||
assert_eq!(path_of("Half"), "M0,0 L50,0");
|
||||
}
|
||||
|
||||
// The `.fig` export writes text on a path.
|
||||
|
||||
use figcraft_doc::geom::kurbo::PathEl;
|
||||
use figcraft_doc::{Document, NodeId, TextAlignV};
|
||||
|
||||
const W1: &str = "text on a path with more than one line was written as plain text";
|
||||
const W2: &str = "text on a path the format can't hold was written as plain text";
|
||||
const W3: &str = "the parts of a text's path after the first were left out";
|
||||
const W4: &str = "text on a path in an instance but not in its main component, or the other way round, was written as the main has it";
|
||||
const W4_LINES: &str =
|
||||
"an instance's text of more than one line stays on its main component's text path in the file, as an override can't take it off";
|
||||
const MARK: u32 = 0x01ff_ffff;
|
||||
|
||||
/// What an export wrote: its warnings, the layer records and the blobs.
|
||||
struct Written {
|
||||
warnings: Vec<String>,
|
||||
records: Vec<Kv<'static>>,
|
||||
blobs: Vec<Vec<u8>>,
|
||||
}
|
||||
|
||||
impl Written {
|
||||
fn of(doc: &Document) -> (Vec<u8>, Written) {
|
||||
let (bytes, warnings) = super::export(doc, None).unwrap();
|
||||
let archive = super::Archive::open(&bytes).unwrap();
|
||||
let (schema, message) = super::decode_canvas(&archive.canvas).unwrap();
|
||||
let schema: &'static super::kiwi::Schema = Box::leak(Box::new(schema));
|
||||
let msg = schema.decode_message(schema.find("Message").unwrap(), &message).unwrap();
|
||||
let records = msg.get("nodeChanges").unwrap().list().to_vec();
|
||||
let blobs = msg
|
||||
.get("blobs")
|
||||
.map(|b| b.list().iter().filter_map(|x| x.get("bytes").and_then(Kv::bytes).map(<[u8]>::to_vec)).collect())
|
||||
.unwrap_or_default();
|
||||
(bytes, Written { warnings, records, blobs })
|
||||
}
|
||||
|
||||
fn record(&self, name: &str) -> &Kv<'static> {
|
||||
self.records.iter().find(|r| r.get("name").and_then(Kv::str) == Some(name)).unwrap_or_else(|| panic!("no record {name}"))
|
||||
}
|
||||
|
||||
/// The network in the blob a record's `vectorData` names.
|
||||
fn network(&self, record: &Kv<'static>) -> super::network::Network {
|
||||
let i = record.get("vectorData").unwrap().get("vectorNetworkBlob").and_then(Kv::f64).unwrap() as usize;
|
||||
super::network::decode(self.blobs.get(i).unwrap()).unwrap()
|
||||
}
|
||||
|
||||
fn warned(&self, text: &str) -> bool {
|
||||
self.warnings.iter().any(|w| w == text)
|
||||
}
|
||||
}
|
||||
|
||||
fn ty<'a>(r: &'a Kv<'static>) -> &'a str {
|
||||
r.get("type").and_then(Kv::str).unwrap()
|
||||
}
|
||||
|
||||
fn start_of(r: &Kv<'static>) -> (f64, bool) {
|
||||
let s = r.get("textPathStart").unwrap_or_else(|| panic!("no textPathStart"));
|
||||
(s.get("tValue").and_then(Kv::f64).unwrap(), s.get("forward").and_then(Kv::bool).unwrap())
|
||||
}
|
||||
|
||||
/// A page holding one text per `(name, characters, d, start, flip, width, height)`.
|
||||
fn doc_of(texts: &[(&str, &str, &str, f64, bool, f64, f64)]) -> Document {
|
||||
let mut doc = Document::new("paths");
|
||||
let page = doc.first_page().unwrap();
|
||||
for (name, chars, d, start, flip, w, h) in texts {
|
||||
let id = doc.create(page, NodeKind::Text(Default::default()), name, 0.0, 0.0, *w, *h).unwrap();
|
||||
let td = doc.node_mut(id).unwrap().kind.text_mut().unwrap();
|
||||
td.characters = (*chars).into();
|
||||
if !d.is_empty() || !chars.is_empty() {
|
||||
td.path = Some(Box::new(TextPath { d: (*d).into(), start: *start, flip: *flip }));
|
||||
}
|
||||
}
|
||||
doc
|
||||
}
|
||||
|
||||
fn text_of<'a>(doc: &'a Document, name: &str) -> &'a figcraft_doc::TextData {
|
||||
let node = doc.nodes().find(|n| n.name == name).unwrap_or_else(|| panic!("no layer {name}"));
|
||||
let NodeKind::Text(td) = &node.kind else { panic!("{name} is not text") };
|
||||
td
|
||||
}
|
||||
|
||||
fn elements(d: &str) -> Vec<(char, Vec<(f64, f64)>)> {
|
||||
figcraft_doc::geom::svg_path(d)
|
||||
.unwrap()
|
||||
.elements()
|
||||
.iter()
|
||||
.map(|el| match el {
|
||||
PathEl::MoveTo(p) => ('M', vec![(p.x, p.y)]),
|
||||
PathEl::LineTo(p) => ('L', vec![(p.x, p.y)]),
|
||||
PathEl::QuadTo(a, b) => ('Q', vec![(a.x, a.y), (b.x, b.y)]),
|
||||
PathEl::CurveTo(a, b, c) => ('C', vec![(a.x, a.y), (b.x, b.y), (c.x, c.y)]),
|
||||
PathEl::ClosePath => ('Z', vec![]),
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
fn same_path(a: &str, b: &str) {
|
||||
let (x, y) = (elements(a), elements(b));
|
||||
assert_eq!(x.len(), y.len(), "{a} / {b}");
|
||||
for ((ka, pa), (kb, pb)) in x.iter().zip(&y) {
|
||||
assert_eq!(ka, kb, "{a} / {b}");
|
||||
for (p, q) in pa.iter().zip(pb) {
|
||||
assert!((p.0 - q.0).abs() < 1e-3 && (p.1 - q.1).abs() < 1e-3, "{a} / {b}");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn no_text_path_warning(warnings: &[String]) {
|
||||
assert!(!warnings.iter().any(|w| w.contains("text path") || w.contains("text off its path")), "{warnings:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_text_on_a_path_survives_a_fig_export() {
|
||||
let (doc, _) = super::import(&canvas(), "Text path").unwrap();
|
||||
let (bytes, warnings) = super::export(&doc, None).unwrap();
|
||||
assert!(!warnings.iter().any(|w| w.contains("text on a path")), "{warnings:?}");
|
||||
let (_, w) = Written::of(&doc);
|
||||
let r = w.record("alpha path");
|
||||
assert_eq!(ty(r), "TEXT_PATH");
|
||||
assert_eq!(start_of(r), (0.5, true));
|
||||
assert_eq!(r.get("textAlignVertical").and_then(Kv::str), Some("TOP"));
|
||||
let normalized = r.get("vectorData").unwrap().get("normalizedSize").unwrap();
|
||||
let size = r.get("size").unwrap();
|
||||
for k in ["x", "y"] {
|
||||
assert_eq!(normalized.get(k).and_then(Kv::f64), size.get(k).and_then(Kv::f64));
|
||||
}
|
||||
assert_eq!((size.get("x").and_then(Kv::f64), size.get("y").and_then(Kv::f64)), (Some(100.0), Some(0.0)));
|
||||
let net = w.network(r);
|
||||
assert_eq!(net.vertices.iter().map(|v| (v.x, v.y)).collect::<Vec<_>>(), [(0.0, 0.0), (100.0, 0.0)]);
|
||||
assert_eq!(net.segments.len(), 1);
|
||||
assert_eq!((net.segments[0].style, net.segments[0].ta, net.segments[0].tb), (MARK, (0.0, 0.0), (0.0, 0.0)));
|
||||
assert!(net.regions.is_empty());
|
||||
let (back, import_warnings) = super::import(&bytes, "Back").unwrap();
|
||||
no_text_path_warning(&import_warnings);
|
||||
let td = text_of(&back, "alpha path");
|
||||
assert_eq!(td.path.as_deref(), Some(&TextPath { d: "M0,0 L100,0".into(), start: 0.5, flip: false }));
|
||||
assert_eq!(td.characters, "alpha");
|
||||
assert_eq!((td.runs.len(), td.runs[0].start, td.runs[0].end), (1, 3, 5));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_start_is_written_by_length_from_either_side() {
|
||||
const CURVE: &str = "M0,82.5 C70,-27.5 230,-27.5 300,82.5 C370,192.5 530,192.5 600,82.5";
|
||||
let mut doc = doc_of(&[
|
||||
("far", "alpha", CURVE, 0.7490379757, false, 600.0, 165.0),
|
||||
("near", "alpha", CURVE, 0.004744078, false, 600.0, 165.0),
|
||||
("flipped", "alpha", "M0,0 L600,0", 0.16013986, true, 600.0, 0.0),
|
||||
]);
|
||||
let page = doc.first_page().unwrap();
|
||||
doc.create(page, NodeKind::Text(Default::default()), "plain", 0.0, 0.0, 50.0, 20.0).unwrap();
|
||||
let (bytes, w) = Written::of(&doc);
|
||||
let marked = |name: &str| -> (usize, f64, bool) {
|
||||
let r = w.record(name);
|
||||
let net = w.network(r);
|
||||
let at: Vec<usize> = net.segments.iter().enumerate().filter(|(_, s)| s.style == MARK).map(|(i, _)| i).collect();
|
||||
assert_eq!(at.len(), 1, "{name}");
|
||||
let (t, forward) = start_of(r);
|
||||
(at[0], t, forward)
|
||||
};
|
||||
let (i, t, forward) = marked("far");
|
||||
assert_eq!((i, forward), (1, true));
|
||||
assert!((t - 0.49800667).abs() < 1e-5, "{t}");
|
||||
let (i, t, forward) = marked("near");
|
||||
assert_eq!((i, forward), (0, true));
|
||||
assert!((t - 0.0086954795).abs() < 1e-5, "{t}");
|
||||
assert!((t - 0.009488156).abs() > 5e-4, "{t}");
|
||||
let (i, t, forward) = marked("flipped");
|
||||
assert_eq!((i, forward), (0, false));
|
||||
assert!((t - 0.83986014).abs() < 1e-6, "{t}");
|
||||
let plain = w.record("plain");
|
||||
assert_eq!(ty(plain), "TEXT");
|
||||
assert!(plain.get("textPathStart").is_none() && plain.get("vectorData").is_none());
|
||||
let (back, _) = super::import(&bytes, "Back").unwrap();
|
||||
for (name, d, start, flip) in
|
||||
[("far", CURVE, 0.7490379757, false), ("near", CURVE, 0.004744078, false), ("flipped", "M0,0 L600,0", 0.16013986, true)]
|
||||
{
|
||||
let path = text_of(&back, name).path.as_deref().unwrap_or_else(|| panic!("{name} lost its path"));
|
||||
same_path(&path.d, d);
|
||||
assert!((path.start - start).abs() < 1e-6, "{name}: {}", path.start);
|
||||
assert_eq!(path.flip, flip, "{name}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_closed_path_is_written_as_a_cycle() {
|
||||
let doc = doc_of(&[("square", "alpha", "M0,0 L100,0 L100,100 L0,100 Z", 0.3, false, 100.0, 100.0)]);
|
||||
let (bytes, w) = Written::of(&doc);
|
||||
let r = w.record("square");
|
||||
let net = w.network(r);
|
||||
assert_eq!((net.vertices.len(), net.segments.len()), (4, 4));
|
||||
assert_eq!(net.segments.iter().map(|s| (s.a, s.b)).collect::<Vec<_>>(), [(0, 1), (1, 2), (2, 3), (3, 0)]);
|
||||
assert_eq!(net.segments.iter().map(|s| s.style).collect::<Vec<_>>(), [0, MARK, 0, 0]);
|
||||
assert!((start_of(r).0 - 0.2).abs() < 1e-6);
|
||||
let come_back = |bytes: &[u8]| {
|
||||
let (back, warnings) = super::import(bytes, "Back").unwrap();
|
||||
no_text_path_warning(&warnings);
|
||||
text_of(&back, "square").path.as_deref().unwrap().clone()
|
||||
};
|
||||
let once = come_back(&bytes);
|
||||
same_path(&once.d, "M100,0 L100,100 L0,100 L0,0 L100,0 Z");
|
||||
assert!((once.start - 0.05).abs() < 1e-6, "{}", once.start);
|
||||
let (back, _) = super::import(&bytes, "Back").unwrap();
|
||||
let (again, _) = super::export(&back, None).unwrap();
|
||||
let twice = come_back(&again);
|
||||
same_path(&twice.d, &once.d);
|
||||
assert!((twice.start - once.start).abs() < 1e-6);
|
||||
|
||||
let open_end = doc_of(&[("tri", "alpha", "M0,0 L100,0 L100,100 L0,0", 0.5, false, 100.0, 100.0)]);
|
||||
let (_, w) = Written::of(&open_end);
|
||||
let net = w.network(w.record("tri"));
|
||||
assert_eq!(net.vertices.len(), 3);
|
||||
assert_eq!(net.segments.iter().map(|s| (s.a, s.b)).collect::<Vec<_>>(), [(0, 1), (1, 2), (2, 0)]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn paths_the_format_cant_hold_fall_back_with_their_own_warning() {
|
||||
let plain = |doc: &Document, warning: &str| {
|
||||
let (bytes, w) = Written::of(doc);
|
||||
assert!(w.warned(warning), "{:?}", w.warnings);
|
||||
let r = w.record("t");
|
||||
assert_eq!(ty(r), "TEXT");
|
||||
assert!(r.get("textPathStart").is_none() && r.get("vectorData").is_none());
|
||||
let (back, warnings) = super::import(&bytes, "Back").unwrap();
|
||||
assert!(text_of(&back, "t").path.is_none());
|
||||
assert!(!warnings.iter().any(|x| x.contains("text path")), "{warnings:?}");
|
||||
};
|
||||
plain(&doc_of(&[("t", "al\npha", "M0,0 L100,0", 0.5, false, 100.0, 0.0)]), W1);
|
||||
plain(&doc_of(&[("t", "alpha", "M0,5 L100,5", 0.5, false, 100.0, 0.0)]), W2);
|
||||
let mut empty = doc_of(&[("t", "alpha", "", 0.5, false, 100.0, 20.0)]);
|
||||
let id = empty.nodes().find(|n| n.name == "t").unwrap().id;
|
||||
empty.node_mut(id).unwrap().kind.text_mut().unwrap().path = Some(Box::new(TextPath { d: String::new(), start: 0.5, flip: false }));
|
||||
plain(&empty, W2);
|
||||
|
||||
// Vertical alignment: written as top, still on its path.
|
||||
let mut middle = doc_of(&[("t", "alpha", "M0,0 L100,0", 0.5, false, 100.0, 0.0)]);
|
||||
let id = middle.nodes().find(|n| n.name == "t").unwrap().id;
|
||||
middle.node_mut(id).unwrap().kind.text_mut().unwrap().align_v = TextAlignV::Middle;
|
||||
let (bytes, w) = Written::of(&middle);
|
||||
assert!(!w.warnings.iter().any(|x| x.contains("text on a path")), "{:?}", w.warnings);
|
||||
assert_eq!(w.record("t").get("textAlignVertical").and_then(Kv::str), Some("TOP"));
|
||||
let (back, _) = super::import(&bytes, "Back").unwrap();
|
||||
assert!(text_of(&back, "t").path.is_some());
|
||||
|
||||
// Several parts: the first.
|
||||
let (bytes, w) = Written::of(&doc_of(&[("t", "alpha", "M0,0 L100,0 M0,50 L100,50", 0.5, false, 100.0, 50.0)]));
|
||||
assert!(w.warned(W3), "{:?}", w.warnings);
|
||||
let (back, _) = super::import(&bytes, "Back").unwrap();
|
||||
let path = text_of(&back, "t").path.as_deref().unwrap();
|
||||
same_path(&path.d, "M0,0 L100,0");
|
||||
assert!((path.start - 0.5).abs() < 1e-6);
|
||||
|
||||
// A zero-length segment is dropped.
|
||||
let (bytes, w) = Written::of(&doc_of(&[("t", "alpha", "M0,0 L0,0 L100,0", 0.5, false, 100.0, 0.0)]));
|
||||
assert!(!w.warnings.iter().any(|x| x.contains("text on a path")), "{:?}", w.warnings);
|
||||
let (back, _) = super::import(&bytes, "Back").unwrap();
|
||||
same_path(&text_of(&back, "t").path.as_deref().unwrap().d, "M0,0 L100,0");
|
||||
|
||||
// A closed path of one segment.
|
||||
let (bytes, w) = Written::of(&doc_of(&[("t", "alpha", "M0,0 C100,-100 -100,-100 0,0 Z", 0.5, false, 100.0, 100.0)]));
|
||||
assert!(!w.warnings.iter().any(|x| x.contains("text on a path")), "{:?}", w.warnings);
|
||||
let (back, _) = super::import(&bytes, "Back").unwrap();
|
||||
let els = elements(&text_of(&back, "t").path.as_deref().unwrap().d);
|
||||
assert_eq!(els.first().map(|e| e.1[0]), Some((0.0, 0.0)));
|
||||
let last = els.iter().rev().find(|e| e.0 != 'Z').unwrap();
|
||||
assert_eq!(last.1.last().copied(), Some((0.0, 0.0)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_instance_layer_on_a_path_survives_a_fig_export() {
|
||||
let (doc, _) = super::import(&canvas_of(scaled_instance_message()), "Scaled path").unwrap();
|
||||
let (bytes, warnings) = super::export(&doc, None).unwrap();
|
||||
assert!(!warnings.iter().any(|w| w.contains("text on a path")), "{warnings:?}");
|
||||
let (back, _) = super::import(&bytes, "Back").unwrap();
|
||||
let path_of = |doc: &Document, parent: &str| {
|
||||
let parent = doc.nodes().find(|n| n.name == parent).unwrap();
|
||||
let node = doc.node(parent.children[0]).unwrap();
|
||||
let NodeKind::Text(text) = &node.kind else { panic!("expected text") };
|
||||
text.path.as_deref().map(|p| p.d.clone())
|
||||
};
|
||||
assert_eq!(path_of(&back, "Main").as_deref(), Some("M0,0 L100,0"));
|
||||
assert_eq!(path_of(&back, "Half").as_deref(), Some("M0,0 L50,0"));
|
||||
|
||||
// A layer in an instance that isn't on a path where its main's layer is: it comes back on the main's path.
|
||||
let off = |parent: &str| {
|
||||
let mut doc = doc.clone();
|
||||
let id: NodeId = doc.nodes().find(|n| n.name == parent).unwrap().children[0];
|
||||
doc.node_mut(id).unwrap().kind.text_mut().unwrap().path = None;
|
||||
doc
|
||||
};
|
||||
let (bytes, w) = Written::of(&off("Half"));
|
||||
assert!(w.warned(W4), "{:?}", w.warnings);
|
||||
let (back, _) = super::import(&bytes, "Back").unwrap();
|
||||
assert_eq!(path_of(&back, "Half").as_deref(), Some("M0,0 L50,0"));
|
||||
|
||||
// An instance's text of two lines on a main that is on a path: the override can't leave the
|
||||
// path, so the warning names that case, not the general mismatch.
|
||||
let mut two = doc.clone();
|
||||
let id: NodeId = two.nodes().find(|n| n.name == "Half").unwrap().children[0];
|
||||
two.node_mut(id).unwrap().kind.text_mut().unwrap().characters = "al\npha".into();
|
||||
let (_, w) = Written::of(&two);
|
||||
assert!(w.warned(W4_LINES), "{:?}", w.warnings);
|
||||
assert!(!w.warned(W4), "{:?}", w.warnings);
|
||||
|
||||
// The other way round: the main's layer is plain text, and so is the instance's.
|
||||
let (bytes, w) = Written::of(&off("Main"));
|
||||
assert!(w.warned(W4), "{:?}", w.warnings);
|
||||
assert_eq!(ty(w.record("arc")), "TEXT");
|
||||
let (back, _) = super::import(&bytes, "Back").unwrap();
|
||||
assert_eq!((path_of(&back, "Main"), path_of(&back, "Half")), (None, None));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_schema_numbers_text_on_a_path() {
|
||||
let s = super::kiwi::Schema::parse(super::export::SCHEMA).unwrap();
|
||||
let def = |n: &str| s.defs.iter().find(|d| d.name == n).unwrap();
|
||||
assert_eq!(def("NodeType").fields.iter().find(|x| x.name == "TEXT_PATH").map(|x| x.value), Some(41));
|
||||
assert_eq!(def("NodeChange").fields.iter().find(|x| x.name == "textPathStart").map(|x| x.value), Some(432));
|
||||
let start = def("TextPathStart");
|
||||
assert!(matches!(start.kind, super::kiwi::Kind::Message));
|
||||
let fields: Vec<_> = start.fields.iter().map(|x| (x.name.as_str(), x.value)).collect();
|
||||
assert_eq!(fields, [("tValue", 1), ("forward", 2)]);
|
||||
}
|
||||
|
||||
/// A text on a path of two curves whose coordinates 32-bit floats hold while their control points (a point plus its
|
||||
/// tangent) need more digits, as the curves of a saved file do.
|
||||
fn uneven_curve_canvas() -> Vec<u8> {
|
||||
let mut blob = Vec::new();
|
||||
let u32le = |out: &mut Vec<u8>, n: u32| out.extend_from_slice(&n.to_le_bytes());
|
||||
let f32le = |out: &mut Vec<u8>, n: f32| out.extend_from_slice(&n.to_le_bytes());
|
||||
for n in [3, 2, 0] {
|
||||
u32le(&mut blob, n);
|
||||
}
|
||||
for (x, y) in [(0.1, 82.3), (300.7, 82.9), (600.3, 81.7)] {
|
||||
u32le(&mut blob, 0);
|
||||
f32le(&mut blob, x);
|
||||
f32le(&mut blob, y);
|
||||
}
|
||||
for (style, a, ta, b, tb) in [(0, 0, (70.7, -110.3), 1, (-70.9, -110.1)), (MARK, 1, (70.3, 110.7), 2, (-70.1, 110.9))] {
|
||||
u32le(&mut blob, style);
|
||||
u32le(&mut blob, a);
|
||||
f32le(&mut blob, ta.0);
|
||||
f32le(&mut blob, ta.1);
|
||||
u32le(&mut blob, b);
|
||||
f32le(&mut blob, tb.0);
|
||||
f32le(&mut blob, tb.1);
|
||||
}
|
||||
let identity = o(vec![("m00", f(1.0)), ("m01", f(0.0)), ("m02", f(0.0)), ("m10", f(0.0)), ("m11", f(1.0)), ("m12", f(0.0))]);
|
||||
let text = node(
|
||||
2,
|
||||
Some(1),
|
||||
"TEXT_PATH",
|
||||
vec![
|
||||
("name", s("curve")),
|
||||
("size", point(600.5, 221.25)),
|
||||
("transform", identity),
|
||||
("textData", o(vec![("characters", s("alpha"))])),
|
||||
("fontSize", f(24.0)),
|
||||
("fontName", o(vec![("family", s("Inter")), ("style", s("Regular"))])),
|
||||
("textPathStart", o(vec![("tValue", f(0.4)), ("forward", Kv::Bool(true))])),
|
||||
("vectorData", o(vec![("vectorNetworkBlob", u(0)), ("normalizedSize", point(600.5, 221.25))])),
|
||||
],
|
||||
);
|
||||
let nodes = vec![node(0, None, "DOCUMENT", vec![]), node(1, Some(0), "CANVAS", vec![]), text];
|
||||
canvas_of(o(vec![("nodeChanges", a(nodes)), ("blobs", a(vec![o(vec![("bytes", Kv::Bytes(blob))])]))]))
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_curve_read_from_a_file_is_written_back_as_it_was() {
|
||||
let (doc, _) = super::import(&uneven_curve_canvas(), "Curve").unwrap();
|
||||
let read = text_of(&doc, "curve").path.as_deref().unwrap().clone();
|
||||
let (bytes, _) = super::export(&doc, None).unwrap();
|
||||
let (back, warnings) = super::import(&bytes, "Back").unwrap();
|
||||
no_text_path_warning(&warnings);
|
||||
// The file holds a control point as its offset from the end point: taken from the point as read, it is the same offset.
|
||||
assert_eq!(text_of(&back, "curve").path.as_deref(), Some(&read));
|
||||
}
|
||||
|
||||
@@ -13,7 +13,7 @@ use serde_json::Value;
|
||||
use super::Ctx;
|
||||
|
||||
/// Largest width/height/stroke/radius/spacing value taken from the file.
|
||||
pub(super) const MAX_SIZE: f64 = 1e6;
|
||||
pub(crate) const MAX_SIZE: f64 = 1e6;
|
||||
/// Largest coordinate taken from the file.
|
||||
pub(super) const MAX_COORD: f64 = 1e7;
|
||||
/// Most entries read from any one list (paints, effects, dashes, grids…).
|
||||
|
||||
@@ -376,9 +376,19 @@ fn font_bytes_load_into_the_db() {
|
||||
let families = load_font_bytes(f.bytes.to_vec());
|
||||
assert_eq!(families.len(), 1);
|
||||
assert!(families.iter().all(|f| has_family(f)));
|
||||
let faces = db().read().unwrap().face_count();
|
||||
// The global face count can grow here when another test finishes the concurrent system
|
||||
// font scan. Count explicitly loaded faces from this family so the idempotency assertion
|
||||
// stays isolated from unrelated installed fonts.
|
||||
let loaded_faces = || {
|
||||
let db = db().read().unwrap();
|
||||
families
|
||||
.iter()
|
||||
.map(|family| db.faces.iter().filter(|face| face.loaded > 0 && face.family.eq_ignore_ascii_case(family)).count())
|
||||
.collect::<Vec<_>>()
|
||||
};
|
||||
let faces = loaded_faces();
|
||||
assert_eq!(load_font_bytes(f.bytes.to_vec()), families);
|
||||
assert_eq!(db().read().unwrap().face_count(), faces);
|
||||
assert_eq!(loaded_faces(), faces);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -1889,6 +1889,7 @@ name = "English"
|
||||
"set-variable actions without a value were skipped" = "set-variable actions without a value were skipped"
|
||||
"set-variable-mode actions on collections or modes that aren't in the variables JSON were skipped" = "set-variable-mode actions on collections or modes that aren't in the variables JSON were skipped"
|
||||
"shape generated outline is missing or damaged; using its rectangle" = "shape generated outline is missing or damaged; using its rectangle"
|
||||
"shape with text layers import as frames with their text" = "shape with text layers import as frames with their text"
|
||||
"slot content assignment target is missing or is not slot content" = "slot content assignment target is missing or is not slot content"
|
||||
"slot content assignment uses the empty GUID sentinel and was skipped" = "slot content assignment uses the empty GUID sentinel and was skipped"
|
||||
"slot layers without a matching slot property were imported as frames" = "slot layers without a matching slot property were imported as frames"
|
||||
|
||||
@@ -379,6 +379,12 @@ impl FigApp {
|
||||
let worker = self.worker.take();
|
||||
let mut worker = worker.unwrap_or_else(|| render_worker::Worker::new(ctx.clone()));
|
||||
canvas::show(self, ui, &mut worker);
|
||||
// The strip the floating bottom toolbar covers, for Zoom to selection (0 when it's hidden).
|
||||
let inset =
|
||||
if !hidden && mobile.is_none() { f64::from(self.canvas.rect.max.y - toolbar::pill_rect(self.canvas.rect, 0.0).min.y) } else { 0.0 };
|
||||
if let Ok(ds) = self.session.ds_mut() {
|
||||
ds.view.bottom_inset = inset;
|
||||
}
|
||||
self.worker = Some(worker);
|
||||
if !hidden && mobile.is_none() {
|
||||
ui.scope_builder(egui::UiBuilder::new().id_salt("toolbar"), |ui| {
|
||||
|
||||
@@ -90,7 +90,14 @@ fn shift_digits_zoom() {
|
||||
press(&mut u, Key::Num2, Modifiers::SHIFT);
|
||||
assert!(zoom(&u) > fit, "Shift+2 fits the smaller selection");
|
||||
let v = &u.app.session.ds().unwrap().view;
|
||||
assert_eq!((v.cx, v.cy), (110.0, 40.0), "centred on it");
|
||||
// Centred in the canvas above the bottom toolbar: the page centre sits half the toolbar's strip lower.
|
||||
// The strip is the canvas's bottom edge less the pill's top, worked out here, not read back.
|
||||
let strip = f64::from(u.app.canvas.rect.max.y - crate::toolbar::pill_rect(u.app.canvas.rect, 0.0).min.y);
|
||||
assert!(strip > 20.0 && strip < 200.0, "the pill is a toolbar's height: {strip}");
|
||||
assert!((v.bottom_inset - strip).abs() < 1e-3, "the app gives the engine the pill's strip: {} vs {strip}", v.bottom_inset);
|
||||
let expect_cy = 40.0 + strip / 2.0 / v.zoom;
|
||||
assert_eq!(v.cx, 110.0, "centred on it");
|
||||
assert!((v.cy - expect_cy).abs() < 1e-9, "centred above the toolbar: {} vs {expect_cy}", v.cy);
|
||||
// `+` and `-` step the zoom.
|
||||
let z = zoom(&u);
|
||||
press(&mut u, Key::Minus, Modifiers::NONE);
|
||||
@@ -201,3 +208,16 @@ fn shortcuts_panel_does_not_show_on_the_home_screen() {
|
||||
u.frame(vec![]);
|
||||
assert!(!u.app.ui.shortcuts_panel, "the panel closes on the home screen");
|
||||
}
|
||||
|
||||
/// The strip the bottom toolbar covers is given to the engine while the toolbar shows and is zero
|
||||
/// when the interface is hidden.
|
||||
#[test]
|
||||
fn the_toolbar_strip_is_zero_when_the_interface_is_hidden() {
|
||||
let (mut u, _, _) = setup();
|
||||
u.frame(vec![]);
|
||||
u.frame(vec![]);
|
||||
assert!(u.app.session.ds().unwrap().view.bottom_inset > 0.0, "shown");
|
||||
u.app.session.ds_mut().unwrap().view.ui_hidden = true;
|
||||
u.frame(vec![]);
|
||||
assert_eq!(u.app.session.ds().unwrap().view.bottom_inset, 0.0, "hidden");
|
||||
}
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# Boards parity
|
||||
|
||||
> **Last reviewed:** 2026-10-24 · **Last updated:** 2026-11-12 · **Change:** minor (a sticky has a text-size menu in the contextual bar, Small 16, Medium 24, Large 40, Extra large 64 and Huge 96, with Small the default (an earlier reading of 18 did not reproduce); `board.setStyle {fontSize}` sizes stickies and the sticky tool remembers the last size for new ones; the note grows taller at Huge and shrinks back, as measured in FigJam's web app, 2026-11-12; resizing a board table by height changes its rows, not blank space below them: a bottom or top edge grows the last row, a corner shares the change over every row, and a table keeps at least 40 per cell, measured in FigJam's web app, 2026-11-09 (#2172); a `.jam` file's stickies come in as native board stickies, with their colour, text and author kept and the size as saved (#1808); a sticky's text stays 18 and the note grows taller instead of the text shrinking, as measured in FigJam's web app (#2157); mind maps, first step: a first node with three children on curved branches, laid out again after every edit (`board.mindMap`, `board.mindMapAdd`, #2226); a `.jam` elbowed connector saved with its path keeps it on import instead of being routed again (#1910); a "+" handle dragged carries the preview: the next shape is made where it is let go, or a connector joins the object it is let go on (#1919); a connector attached to a side starts 4 pt outside the border, so its stroke never lies on the fill (#1916); a connector end moved with Cmd/Ctrl held goes on any part of an object, and stays there as the object moves or resizes; a connector end dropped along a side of a shape attaches to that side (#1708); a board connector's path can be reshaped by dragging its path handles (#1710); boards have 16 more shapes (arrows, polygons, star, plus and flowchart symbols), in pickers that lay them out in a grid; a board keeps earlier votes' results, listed newest first in Results and deleted one at a time; a connector's bar sets its start and end points, dashes, weight and any colour (#1596); cells copied from a spreadsheet paste onto a board as a table; Shift+Cmd/Ctrl+Enter on a selected board shape adds the next shape already joined to it, and goes on typing (#1597); "+" handles beside a selected sticky or shape make the next one, joined by a connector (#1597); a FigJam `.jam` file opens as a board (#1342); board grid settings: dots, lines, graph paper or none, spacing, size and contrast; the connector tool shows the connector it will make while dragging, ends snapping to attach points (#1387); templates and tables; facilitation: a shared timer and voting sessions; the dot grid, dragging a connector's end to re-attach it, curved connectors, elbows that go around what they join) · **Target:** the incumbent's whiteboard product (behaviour from its public help centre)
|
||||
> **Last reviewed:** 2026-10-24 · **Last updated:** 2026-11-12 · **Change:** minor (a `.jam` file's shapes with text come in as native board shapes for the 23 kinds FigCraft draws, the other 7 as frames (#1808); a sticky has a text-size menu in the contextual bar, Small 16, Medium 24, Large 40, Extra large 64 and Huge 96, with Small the default (an earlier reading of 18 did not reproduce); `board.setStyle {fontSize}` sizes stickies and the sticky tool remembers the last size for new ones; the note grows taller at Huge and shrinks back, as measured in FigJam's web app, 2026-11-12; resizing a board table by height changes its rows, not blank space below them: a bottom or top edge grows the last row, a corner shares the change over every row, and a table keeps at least 40 per cell, measured in FigJam's web app, 2026-11-09 (#2172); a `.jam` file's stickies come in as native board stickies, with their colour, text and author kept and the size as saved (#1808); a sticky's text stays 18 and the note grows taller instead of the text shrinking, as measured in FigJam's web app (#2157); mind maps, first step: a first node with three children on curved branches, laid out again after every edit (`board.mindMap`, `board.mindMapAdd`, #2226); a `.jam` elbowed connector saved with its path keeps it on import instead of being routed again (#1910); a "+" handle dragged carries the preview: the next shape is made where it is let go, or a connector joins the object it is let go on (#1919); a connector attached to a side starts 4 pt outside the border, so its stroke never lies on the fill (#1916); a connector end moved with Cmd/Ctrl held goes on any part of an object, and stays there as the object moves or resizes; a connector end dropped along a side of a shape attaches to that side (#1708); a board connector's path can be reshaped by dragging its path handles (#1710); boards have 16 more shapes (arrows, polygons, star, plus and flowchart symbols), in pickers that lay them out in a grid; a board keeps earlier votes' results, listed newest first in Results and deleted one at a time; a connector's bar sets its start and end points, dashes, weight and any colour (#1596); cells copied from a spreadsheet paste onto a board as a table; Shift+Cmd/Ctrl+Enter on a selected board shape adds the next shape already joined to it, and goes on typing (#1597); "+" handles beside a selected sticky or shape make the next one, joined by a connector (#1597); a FigJam `.jam` file opens as a board (#1342); board grid settings: dots, lines, graph paper or none, spacing, size and contrast; the connector tool shows the connector it will make while dragging, ends snapping to attach points (#1387); templates and tables; facilitation: a shared timer and voting sessions; the dot grid, dragging a connector's end to re-attach it, curved connectors, elbows that go around what they join) · **Target:** the incumbent's whiteboard product (behaviour from its public help centre)
|
||||
|
||||
**Breadth ~47%, ready ~29% (estimated, erring low).** A board is a FigCraft file of its own kind
|
||||
(`file.newBoard`) with a dot grid on the page, sticky notes, shapes with text, connectors that
|
||||
@@ -66,7 +66,7 @@ all end with the same geometry.
|
||||
| Audio and huddles | missing | |
|
||||
| AI features (summaries, sorting stickies, generating boards) | missing | |
|
||||
| Grid on the page | done | the canvas render draws it after the page colour and before the layers (`figcraft_render::Dots`), so objects cover it. Dots by default, or lines, graph paper (a strong line every 2–12 cells over fainter ones, like Japanese section paper) or none; spacing (4–512), mark size and contrast are settings kept with the preferences (`board.grid`; Preferences ▸ Board grid). Zoomed out it thins out (dots and lines by halves, graph paper down to its strong lines) until the marks are at least 14 points apart (10 for lines), the marks the next step drops fading out first; dots stay about a point and a half across on screen (1 to 3 points), scaled by the size setting. Dark marks on a light page, light ones on a dark page, from the theme's ink; written straight into the image, no allocation per mark, a crossing of two lines blended once; never in exports. FigCraft's own settings: the incumbent's board grid has none |
|
||||
| `.jam` import and export | **partial**: a `.jam` opens as a board, best effort (#1342): its stickies come in as native stickies (their colour, text and author kept; size as saved), its shapes with text as frames with their generated layers and its connectors as vectors, not yet as native board objects (an elbowed connector keeps the path it was saved with, #1910); no export | see [`file-format-parity.md`](file-format-parity.md) |
|
||||
| `.jam` import and export | **partial**: a `.jam` opens as a board, best effort (#1342): its stickies come in as native stickies (their colour, text and author kept; size as saved), its shapes with text as native shapes for the 23 kinds FigCraft draws (the file's paints and weight kept, the outline FigCraft's own; the 7 others stay frames with their generated layers) and its connectors as vectors, not yet as native board objects (an elbowed connector keeps the path it was saved with, #1910); no export | see [`file-format-parity.md`](file-format-parity.md) |
|
||||
|
||||
## Revision history
|
||||
|
||||
@@ -77,6 +77,7 @@ all end with the same geometry.
|
||||
| 2026-11-09 | patch | M12, #2157: a sticky's text is 18 and stays 18 (measured in FigJam's web app: ten lines, then a long paragraph, never changed it; the note kept its width and grew taller). The normalize pass no longer resets a sticky's text to a size by its length (24 down to 11 before), so stickies in saved files keep their size. Size presets (Small to Huge) are still missing. Tests: `a_new_sticky_starts_at_18`, `a_sticky_keeps_its_text_size_as_text_is_added`, `a_sticky_saved_with_another_text_size_keeps_it` |
|
||||
| 2026-11-10 | minor | M12, #2226 (step 1 of 4): mind maps in the document and engine. A mind map node is a board object of its own (`BoardItem::MindNode`: text with no box) and a branch is a connector marked `branch`; the map's shape is read from its branches. `board.mindMap` places a first node with three children and `board.mindMapAdd` adds a child or a sibling, each one undo step. The normalize pass lays a touched map out again from its first node (`board::settle_mind_maps`, `figcraft_doc::mind_layout`): 88 between columns, 48 between siblings, each stack centred on its parent, numbers from a FigJam file saved and decoded. Tests: `board_mindmap_tests` in doc (five) and engine (eight). Numbers unchanged (no toolbar entry yet). |
|
||||
| 2026-11-03 | minor | M12, #1919: as the quick create help says ("Click to select and create the next shape in that direction, or drag the preview to any location on your board"; "A new shape is created with a connector and its text field active"), a "+" beside the selected sticky or shape can be dragged: the preview follows the pointer and, let go on empty board, the next one is made there, centred on the pointer, and joined by a connector leaving by the handle's side and arriving by the side facing it (`board.addConnected` gains `at: [x, y]`, a point of the page placed in the parent's coordinates); let go on another sticky or shape, inside a section or frame too (`board::sticky_or_shape_at`), a connector joins the two instead (`board.connector`), that object outlined while the pointer is over it; let go off the canvas or over the toolbar, nothing, and the bar above the selection stays away meanwhile, as for any drag. The click is as before. A shape picker on drop and choosing the connector type are not done (the help doesn't describe them). Tests: `board_connect_tests` (the drag ones), engine `board_connected_tests::the_next_one_goes_where_it_is_dropped`. Numbers unchanged. |
|
||||
| 2026-11-12 | minor | M9, #1808: `.jam` import: a FigJam shape with text comes in as a native board shape (`BoardItem::Shape`) for the 23 kinds FigCraft draws (square, rounded rectangle, ellipse, diamond, triangles, parallelograms, trapezoid, pentagon, hexagon, octagon, star, plus, arrows, chevron, speech bubble, database, document, predefined process, manual input, internal storage). The frame is empty and a fixed size, as a shape made here, with centred auto layout and the kind's text insets; it holds an `Outline` vector drawn by FigCraft (`BoardShape::path`, so FigJam's 3 pt corner on a square is lost, and `board.setShape` and resizing treat it as FigCraft's own) with the file's paints, weight and dashes as read, and the text, centred. The 7 kinds FigCraft has no outline for (ENG_QUEUE, ENG_FILE, ENG_FOLDER, SHIELD, DOCUMENT_MULTIPLE, SUMMING_JUNCTION, OR) stay frames with their generated layers and a warning naming the kind; so does a shape whose generated records are damaged, or whose generated text is blank while the outer layer still carries text (#1397), and the same shape in a `.fig`; a shape with no text at all is still native, with an empty text layer. Tests: `board_import_tests.rs` (six). Numbers unchanged. |
|
||||
| 2026-11-10 | minor | M9, #1808: a `.jam` sticky imports as a native board sticky (`BoardItem::Sticky`): its frame keeps the saved size (240 pt, not FigCraft's 200), place, opacity and shadows, the saved colour is kept as it is (not snapped to the board colours), the note and the author line are its text layers, and it lays out like one made here (vertical, space between, hugging the height down to the saved size, the saved inset as padding). The importer reads a `board` field on the REST JSON (a FigCraft extension) for this; a sticky whose generated records are damaged, or the same sticky in a `.fig`, keeps the generated layers as before. Shapes, connectors, stamps and tables are unchanged; the note's text keeps the file's size until it is edited. Tests: `board_import_tests.rs` (native sticky, no author, damaged records, `.fig` unchanged), `import_regression_tests.rs` (the `board` field and junk values). Numbers unchanged. |
|
||||
| 2026-11-04 | minor | M12, #1916: a connector end attached to a side starts 4 pt outside the border (`board_route::END_GAP`), as FigJam's do (the issue's screenshots: the line starts a few pixels outside, with a round cap), so the stroke never lies on the fill; elbows leaving one side share their first run along its normal, curves leave tangent to it and straight ones fan out from the same point; the `.jam` importer's routes, re-attached ends, path handles and labels follow the route's points; an end placed by hand with Cmd/Ctrl held keeps its exact point. Tests: `board_route_tests` (three). Numbers unchanged. |
|
||||
| 2026-11-04 | patch | M6, #1910: a `.jam` elbowed connector saved with its path (FigJam's `connectorControlPoints`) keeps it on import: the points become the `ConnectorPath::Runs` a connector reshaped by hand has and the line is walked along them, so a connector drawn around a layer stays around it; one whose points don't make a path from its ends' sides is routed as before. Still a vector, not a native board object. Details in [`file-format-parity.md`](file-format-parity.md). |
|
||||
|
||||
File diff suppressed because one or more lines are too long
+4
-3
File diff suppressed because one or more lines are too long
Reference in New Issue
Block a user