Merge pull request #2324 from TrevorBrown-dev/feat/fig-export-text-path

M6: .fig export writes text on a path (#2323)
This commit is contained in:
BFlat
2026-11-13 23:36:56 +07:00
committed by GitHub
5 changed files with 635 additions and 10 deletions
+3 -2
View File
@@ -72,7 +72,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
@@ -152,6 +152,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
@@ -191,7 +192,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
";
+16 -1
View File
@@ -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",
+232 -3
View File
@@ -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 })
}
+380 -1
View File
@@ -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));
}
File diff suppressed because one or more lines are too long