mirror of
https://github.com/storytold/figcraft.git
synced 2026-10-24 18:36:44 -06:00
2478 lines
124 KiB
Rust
2478 lines
124 KiB
Rust
//! Export to `.fig` (experimental, best effort), from the same public format knowledge as the
|
|
//! import: the inverse of its mapping ([`super::map`]).
|
|
//!
|
|
//! The file is the zip the import reads: `canvas.fig` (the fig-kiwi header, then the binary schema
|
|
//! and the message, each a raw-deflate chunk), `meta.json`, an optional `thumbnail.png` and
|
|
//! `images/<hash>`. The schema travels in the file, so it describes only the fields written here
|
|
//! ([`SCHEMA`]). The message lists one node change per layer (its id, its parent and its position
|
|
//! among the siblings, then its fields), parents first, plus blobs (vector networks and outlines).
|
|
//! Instances are written as their main, the fields they and their layers override (by id path) and
|
|
//! what follows from those (derived data: sizes, places, outlines), like the files the import
|
|
//! reads. Shared styles, variable collections and variables are nodes of their own on a hidden
|
|
//! page; layers, paints, effects and layout grids name the ones they use. What the format can't
|
|
//! carry yet (Dev Mode data, comments, …) is left out and listed in the warnings. Round trips
|
|
//! through our own importer are tested, and written files were opened in other software
|
|
//! (`docs/file-format-parity.md` says what was checked); other apps may not open every file.
|
|
|
|
use std::collections::BTreeMap;
|
|
use std::io::Write;
|
|
use std::sync::Arc;
|
|
|
|
use figcraft_doc::color::{BlendMode, Color, GradientKind, ImageScaleMode, Paint, PaintKind};
|
|
use figcraft_doc::geom::kurbo::PathEl;
|
|
use figcraft_doc::geom::{Affine, BezPath};
|
|
use figcraft_doc::proto::{
|
|
Action, Direction, Easing, GAMEPAD_BUTTONS, Interaction, KeyMods, Overflow, OverlayPosition, ScrollPosition, Transition, Trigger,
|
|
};
|
|
use figcraft_doc::{
|
|
AutoLayout, BoolOp, ContentAlign, CrossAlign, Document, EffectKind, ExportSize, GridAlign, GridKind, HConstraint, LayoutMode, LetterSpacing,
|
|
LineHeight, ListStyle, MainAlign, MaskType, Node, NodeId, NodeKind, NoiseMode, PropDef, Sizing, StrokeAlign, StrokeCap, StrokeJoin, StyleKind,
|
|
TextAlignH, TextAlignV, TextAutoResize, TextCase, TextData, TextDecoration, TextStyle, VConstraint, VariableType, VariableValue, VectorNetwork,
|
|
WindingRule,
|
|
};
|
|
use serde_json::Value;
|
|
|
|
use super::kiwi::{Kv, Schema, encode};
|
|
use super::network;
|
|
use crate::FormatError;
|
|
|
|
/// Most layers written, and deepest nesting followed (the import's limits).
|
|
const MAX_NODES: usize = crate::rest::MAX_NODES;
|
|
const MAX_DEPTH: usize = 256;
|
|
/// Largest `canvas.fig` and image written (what the import reads).
|
|
const MAX_CANVAS: u64 = super::MAX_CANVAS;
|
|
const MAX_IMAGE: u64 = super::MAX_IMAGE;
|
|
/// Largest whole file written.
|
|
const MAX_FILE: u64 = 2 * 1024 * 1024 * 1024;
|
|
/// Most characters of one text layer, and vertices + segments + loop entries of one vector
|
|
/// network (what the import reads).
|
|
const MAX_CHARS: usize = 1 << 20;
|
|
const MAX_NETWORK: usize = 200_000;
|
|
/// Largest magnitude written for a float (the format stores 32-bit floats).
|
|
const MAX_FLOAT: f64 = 1e30;
|
|
/// The version number in the `canvas.fig` header.
|
|
const VERSION: u32 = 101;
|
|
/// Session ids of the GUIDs: layers, and grid tracks and component properties.
|
|
const LAYERS: u32 = 1;
|
|
const AUX: u32 = 2;
|
|
|
|
/// The schema written into every file: `enum Name A=value …`, `struct Name type field, …` (every
|
|
/// field, in order) and `message Name type field=id, …`, with the names, kinds and numbers the
|
|
/// format gives them. Only what the export writes.
|
|
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 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
|
|
enum WindingRule NONZERO=0 ODD=1
|
|
enum StrokeAlign CENTER=0 INSIDE=1 OUTSIDE=2
|
|
enum StrokeCap NONE=0 ROUND=1 SQUARE=2 ARROW_LINES=3 ARROW_EQUILATERAL=4 TRIANGLE_FILLED=6 DIAMOND_FILLED=5 CIRCLE_FILLED=14
|
|
enum StrokeJoin MITER=0 BEVEL=1 ROUND=2
|
|
enum ConstraintType MIN=0 CENTER=1 MAX=2 STRETCH=3 SCALE=4
|
|
enum StackMode NONE=0 HORIZONTAL=1 VERTICAL=2 GRID=3
|
|
enum StackAlign MIN=0 CENTER=1 MAX=2 BASELINE=3
|
|
enum StackJustify MIN=0 CENTER=1 MAX=2 SPACE_EVENLY=3 SPACE_BETWEEN=4 SPACE_AROUND=5
|
|
enum StackCounterAlign MIN=0 CENTER=1 MAX=2 STRETCH=3 AUTO=4 BASELINE=5
|
|
enum StackSize FIXED=0 RESIZE_TO_FIT=1
|
|
enum StackWrap NO_WRAP=0 WRAP=1
|
|
enum StackCounterAlignContent AUTO=0 SPACE_BETWEEN=1
|
|
enum StackPositioning AUTO=0 ABSOLUTE=1
|
|
enum EffectType INNER_SHADOW=0 DROP_SHADOW=1 FOREGROUND_BLUR=2 BACKGROUND_BLUR=3 NOISE=7 GRAIN=6 GLASS=8
|
|
enum BlurOpType NORMAL=0 PROGRESSIVE=1
|
|
enum NoiseType MONOTONE=1 DUOTONE=2 MULTITONE=0
|
|
enum TextAlignHorizontal LEFT=0 CENTER=1 RIGHT=2 JUSTIFIED=3
|
|
enum TextAlignVertical TOP=0 CENTER=1 BOTTOM=2
|
|
enum TextAutoResize NONE=0 WIDTH_AND_HEIGHT=1 HEIGHT=2
|
|
enum TextTruncation DISABLED=0 ENDING=1
|
|
enum TextCase ORIGINAL=0 UPPER=1 LOWER=2 TITLE=3 SMALL_CAPS=4
|
|
enum TextDecoration NONE=0 UNDERLINE=1 STRIKETHROUGH=2
|
|
enum NumberUnits RAW=0 PIXELS=1 PERCENT=2
|
|
enum LineType PLAIN=0 ORDERED_LIST=1 UNORDERED_LIST=2
|
|
enum SourceDirectionality AUTO=0 LTR=1 RTL=2
|
|
enum DocumentColorProfile LEGACY=0 SRGB=1 DISPLAY_P3=2
|
|
enum EmojiImageSet APPLE=0 NOTO=1
|
|
enum MaskType ALPHA=0 OUTLINE=1 LUMINANCE=2
|
|
enum VariableResolvedDataType BOOLEAN=0 FLOAT=1 STRING=2 COLOR=4 SYMBOL_ID=6 TEXT_DATA=8
|
|
enum VectorMirror NONE=0 ANGLE=1 ANGLE_AND_LENGTH=2
|
|
enum BooleanOperation UNION=0 INTERSECT=1 SUBTRACT=2 XOR=3
|
|
enum LayoutGridType MIN=0 CENTER=1 STRETCH=2 MAX=3
|
|
enum LayoutGridPattern STRIPES=0 GRID=1
|
|
enum Axis X=0 Y=1
|
|
enum ImageType PNG=0 JPEG=1 SVG=2 PDF=3
|
|
enum ExportConstraintType CONTENT_SCALE=0 CONTENT_WIDTH=1 CONTENT_HEIGHT=2
|
|
enum ComponentPropType BOOL=0 TEXT=1 INSTANCE_SWAP=3 VARIANT=4
|
|
enum VariableField MISSING=0 CORNER_RADIUS=1 PARAGRAPH_SPACING=2 PARAGRAPH_INDENT=3 STROKE_WEIGHT=4 STACK_SPACING=5 STACK_PADDING_LEFT=6 STACK_PADDING_TOP=7 STACK_PADDING_RIGHT=8 STACK_PADDING_BOTTOM=9 VISIBLE=10 TEXT_DATA=11 WIDTH=12 HEIGHT=13 RECTANGLE_TOP_LEFT_CORNER_RADIUS=14 RECTANGLE_TOP_RIGHT_CORNER_RADIUS=15 RECTANGLE_BOTTOM_LEFT_CORNER_RADIUS=16 RECTANGLE_BOTTOM_RIGHT_CORNER_RADIUS=17 BORDER_TOP_WEIGHT=18 BORDER_BOTTOM_WEIGHT=19 BORDER_LEFT_WEIGHT=20 BORDER_RIGHT_WEIGHT=21 STACK_COUNTER_SPACING=23 MIN_WIDTH=24 MAX_WIDTH=25 MIN_HEIGHT=26 MAX_HEIGHT=27 FONT_FAMILY=28 FONT_STYLE=29 OPACITY=31 FONT_SIZE=32 LETTER_SPACING=34 LINE_HEIGHT=36 OVERRIDDEN_SYMBOL_ID=37
|
|
enum VariableDataType BOOLEAN=0 FLOAT=1 STRING=2 ALIAS=3 COLOR=4 PROP_REF=13
|
|
enum VariableScope ALL_SCOPES=0 TEXT_CONTENT=1 CORNER_RADIUS=2 WIDTH_HEIGHT=3 GAP=4 ALL_FILLS=5 FRAME_FILL=6 SHAPE_FILL=7 TEXT_FILL=8 STROKE=9 STROKE_FLOAT=10 EFFECT_FLOAT=11 EFFECT_COLOR=12 OPACITY=13 FONT_STYLE=14 FONT_FAMILY=15 FONT_SIZE=16 LINE_HEIGHT=17 LETTER_SPACING=18 PARAGRAPH_SPACING=19 PARAGRAPH_INDENT=20
|
|
enum StyleType NONE=0 FILL=1 STROKE=2 TEXT=3 EFFECT=4 EXPORT=5 GRID=6
|
|
enum InteractionType ON_CLICK=0 DRAG=9 ON_HOVER=4 ON_PRESS=7 MOUSE_IN=2 MOUSE_OUT=3 MOUSE_DOWN=5 MOUSE_UP=6 AFTER_TIMEOUT=1 ON_KEY_DOWN=10
|
|
enum TriggerDevice KEYBOARD=0 UNKNOWN_CONTROLLER=1
|
|
enum ConnectionType NONE=0 INTERNAL_NODE=1 URL=2 BACK=3 CLOSE=4
|
|
enum NavigationType NAVIGATE=0 OVERLAY=1 SWAP=2 SWAP_STATE=3 SCROLL_TO=4
|
|
enum TransitionType INSTANT_TRANSITION=0 DISSOLVE=1 SMART_ANIMATE=24 SLIDE_FROM_LEFT=3 SLIDE_FROM_RIGHT=4 SLIDE_FROM_TOP=5 SLIDE_FROM_BOTTOM=6 PUSH_FROM_LEFT=7 PUSH_FROM_RIGHT=8 PUSH_FROM_TOP=9 PUSH_FROM_BOTTOM=10 MOVE_FROM_LEFT=11 MOVE_FROM_RIGHT=12 MOVE_FROM_TOP=13 MOVE_FROM_BOTTOM=14 SLIDE_OUT_TO_LEFT=15 SLIDE_OUT_TO_RIGHT=16 SLIDE_OUT_TO_TOP=17 SLIDE_OUT_TO_BOTTOM=18 MOVE_OUT_TO_LEFT=19 MOVE_OUT_TO_RIGHT=20 MOVE_OUT_TO_TOP=21 MOVE_OUT_TO_BOTTOM=22
|
|
enum EasingType IN_CUBIC=0 OUT_CUBIC=1 INOUT_CUBIC=2 LINEAR=3 IN_BACK_CUBIC=4 OUT_BACK_CUBIC=5 INOUT_BACK_CUBIC=6 CUSTOM_CUBIC=7 GENTLE_SPRING=9
|
|
enum ScrollDirection NONE=0 HORIZONTAL=1 VERTICAL=2 BOTH=3
|
|
enum ScrollBehavior SCROLLS=0 FIXED_WHEN_CHILD_OF_SCROLLING_FRAME=1 STICKY_SCROLLS=2
|
|
enum OverlayPositionType CENTER=0 TOP_LEFT=1 TOP_CENTER=2 TOP_RIGHT=3 BOTTOM_LEFT=4 BOTTOM_CENTER=5 BOTTOM_RIGHT=6 MANUAL=7
|
|
enum OverlayBackgroundInteraction NONE=0 CLOSE_ON_CLICK_OUTSIDE=1
|
|
enum OverlayBackgroundType NONE=0 SOLID_COLOR=1
|
|
struct GUID uint sessionID, uint localID
|
|
struct Color float r, float g, float b, float a
|
|
struct Vector float x, float y
|
|
struct Matrix float m00, float m01, float m02, float m10, float m11, float m12
|
|
struct ColorStop Color color, float position
|
|
struct ParentIndex GUID guid, string position
|
|
message Image byte[] hash=1, string name=2
|
|
message VariableWidthPoint float position=1, float ascent=2, float descent=3
|
|
message PluginData string pluginID=1, string value=2, string key=3
|
|
message StyleId GUID guid=1
|
|
message VariableID GUID guid=1
|
|
message VariableSetID GUID guid=1
|
|
message ColorStopVar Color color=1, VariableData colorVar=2, float position=3
|
|
message Paint PaintType type=1, Color color=2, float opacity=3, bool visible=4, BlendMode blendMode=5, ColorStop[] stops=6, Matrix transform=7, Image image=8, ImageScaleMode imageScaleMode=10, float rotation=11, float scale=12, VariableData colorVar=21, ColorStopVar[] stopsVar=23
|
|
message Effect EffectType type=1, Color color=2, Vector offset=3, float radius=4, bool visible=5, BlendMode blendMode=6, float spread=7, bool showShadowBehindNode=8, BlurOpType blurOpType=19, float startRadius=21, Vector startOffset=20, Vector endOffset=28, NoiseType noiseType=26, Vector noiseSize=22, float density=25, float opacity=27, Color secondaryColor=24, bool clipToShape=23, VariableData radiusVar=9, VariableData colorVar=10, VariableData spreadVar=11, VariableData xVar=12, VariableData yVar=13, VariableData startRadiusVar=45
|
|
struct FontName string family, string style, string postscript
|
|
struct Number float value, NumberUnits units
|
|
message Hyperlink string url=1
|
|
message TextLineData LineType lineType=1, int styleId=10, int indentationLevel=2, SourceDirectionality sourceDirectionality=9, int listStartOffset=7, bool isFirstLineOfList=8
|
|
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 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
|
|
struct ExportConstraint ExportConstraintType type, float value
|
|
message ExportSettings string suffix=1, ImageType imageType=2, ExportConstraint constraint=3
|
|
message GUIDPath GUID[] guids=1
|
|
message SymbolData GUID symbolID=1, NodeChange[] symbolOverrides=2, float uniformScaleFactor=3
|
|
message ComponentPropValue bool boolValue=1, TextData textValue=2, GUID guidValue=3
|
|
message ComponentPropDef GUID id=1, string name=2, ComponentPropValue initialValue=3, ComponentPropType type=6
|
|
message ComponentPropAssignment GUID defID=1, ComponentPropValue value=2
|
|
message PropRefValue GUID defId=1
|
|
message VariableAnyValue bool boolValue=1, string textValue=2, float floatValue=3, VariableID alias=4, Color colorValue=5, PropRefValue propRefValue=13
|
|
message VariableData VariableAnyValue value=1, VariableDataType dataType=2, VariableResolvedDataType resolvedDataType=3
|
|
message VariableDataMapEntry uint nodeField=1, VariableData variableData=2, VariableField variableField=3
|
|
message VariableDataMap VariableDataMapEntry[] entries=1
|
|
message VariableModeBySetMapEntry VariableSetID variableSetID=1, GUID variableModeID=2
|
|
message VariableModeBySetMap VariableModeBySetMapEntry[] entries=1
|
|
message VariableSetMode GUID id=1, string name=2, string sortPosition=3
|
|
message VariableDataValuesEntry GUID modeID=1, VariableData variableData=2
|
|
message VariableDataValues VariableDataValuesEntry[] entries=1
|
|
message KeyTrigger int[] keyCodes=1, TriggerDevice triggerDevice=2
|
|
message PrototypeEvent InteractionType interactionType=1, float transitionTimeout=6, KeyTrigger keyTrigger=4
|
|
message PrototypeAction GUID transitionNodeID=1, TransitionType transitionType=2, float transitionDuration=3, EasingType easingType=4, float[] easingFunction=12, ConnectionType connectionType=7, Vector overlayRelativePosition=9, NavigationType navigationType=10, string connectionURL=8, bool transitionPreserveScroll=11
|
|
message PrototypeInteraction PrototypeEvent event=2, PrototypeAction[] actions=3
|
|
message PrototypeStartingPoint string name=1, string position=3
|
|
message OverlayBackgroundAppearance OverlayBackgroundType backgroundType=1, Color backgroundColor=2
|
|
message GUIDPositionMapEntry GUID id=1, string position=2
|
|
message GUIDPositionMap GUIDPositionMapEntry[] 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, 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, 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, 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, ComponentPropAssignment[] componentPropAssignments=268, 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
|
|
struct Blob byte[] bytes
|
|
message Message MessageType type=1, uint sessionID=2, NodeChange[] nodeChanges=4, Blob[] blobs=6
|
|
";
|
|
|
|
/// Write `doc` as a `.fig` file, with `thumbnail` (a PNG) when given. Returns the bytes and the
|
|
/// warnings about what was left out or approximated.
|
|
pub fn export(doc: &Document, thumbnail: Option<&[u8]>) -> Result<(Vec<u8>, Vec<String>), FormatError> {
|
|
let mut x = Exporter::new(doc);
|
|
let message = x.message();
|
|
let fail = |e: super::kiwi::KiwiError| FormatError::Io(format!(".fig export: {e}"));
|
|
let schema = Schema::parse(SCHEMA).map_err(fail)?;
|
|
let root = schema.find("Message").ok_or_else(|| FormatError::Io(".fig export: the schema has no Message".into()))?;
|
|
let body = encode::message(&schema, root, &message).map_err(fail)?;
|
|
let canvas = canvas(&encode::schema(&schema), &body)?;
|
|
let background = doc.pages.first().and_then(|p| doc.node(*p)).and_then(|p| match &p.kind {
|
|
NodeKind::Page { background, .. } => Some(*background),
|
|
_ => None,
|
|
});
|
|
let bytes = archive(&doc.name, background.unwrap_or(Color::WHITE), &canvas, &x.files, thumbnail)?;
|
|
Ok((bytes, x.warnings))
|
|
}
|
|
|
|
fn too_large() -> FormatError {
|
|
FormatError::Io("the document is too large for a .fig file".into())
|
|
}
|
|
|
|
/// `canvas.fig`: the magic, the version and the two deflated chunks, each after its length.
|
|
fn canvas(schema: &[u8], message: &[u8]) -> Result<Vec<u8>, FormatError> {
|
|
let mut out = b"fig-kiwi".to_vec();
|
|
out.extend_from_slice(&VERSION.to_le_bytes());
|
|
for chunk in [schema, message] {
|
|
let mut z = flate2::write::DeflateEncoder::new(Vec::new(), flate2::Compression::default());
|
|
z.write_all(chunk).map_err(crate::io_err)?;
|
|
let c = z.finish().map_err(crate::io_err)?;
|
|
let len = u32::try_from(c.len()).map_err(|_| too_large())?;
|
|
out.extend_from_slice(&len.to_le_bytes());
|
|
out.extend_from_slice(&c);
|
|
}
|
|
if out.len() as u64 > MAX_CANVAS {
|
|
return Err(too_large());
|
|
}
|
|
Ok(out)
|
|
}
|
|
|
|
/// The zip around `canvas.fig`.
|
|
fn archive(
|
|
name: &str,
|
|
background: Color,
|
|
canvas: &[u8],
|
|
images: &[(String, Arc<Vec<u8>>)],
|
|
thumbnail: Option<&[u8]>,
|
|
) -> Result<Vec<u8>, FormatError> {
|
|
let mut buf = std::io::Cursor::new(Vec::new());
|
|
{
|
|
let mut z = zip::ZipWriter::new(&mut buf);
|
|
let stored = zip::write::SimpleFileOptions::default().compression_method(zip::CompressionMethod::Stored);
|
|
crate::put(&mut z, "canvas.fig", stored, canvas)?;
|
|
if let Some(t) = thumbnail {
|
|
crate::put(&mut z, "thumbnail.png", stored, t)?;
|
|
}
|
|
let mut client = serde_json::json!({"background_color": {"r": background.r, "g": background.g, "b": background.b, "a": background.a}});
|
|
// A PNG says its size right after its signature and header chunk name.
|
|
let be = |at: usize| thumbnail.and_then(|t| t.get(at..at + 4)).and_then(|b| b.try_into().ok()).map(u32::from_be_bytes);
|
|
if let (Some(w), Some(h)) = (be(16), be(20)) {
|
|
client["thumbnail_size"] = serde_json::json!({"width": w, "height": h});
|
|
}
|
|
let meta = serde_json::to_vec(&serde_json::json!({"client_meta": client, "file_name": name})).map_err(crate::io_err)?;
|
|
crate::put(&mut z, "meta.json", crate::json_options(), &meta)?;
|
|
let mut total = canvas.len() as u64;
|
|
for (hash, bytes) in images {
|
|
total += bytes.len() as u64;
|
|
if total > MAX_FILE {
|
|
return Err(too_large());
|
|
}
|
|
crate::put(&mut z, &format!("images/{hash}"), stored, bytes)?;
|
|
}
|
|
z.finish().map_err(crate::io_err)?;
|
|
}
|
|
Ok(buf.into_inner())
|
|
}
|
|
|
|
type Fields = Vec<(&'static str, Kv<'static>)>;
|
|
|
|
fn o(f: Fields) -> Kv<'static> {
|
|
Kv::Object(f)
|
|
}
|
|
fn arr(v: Vec<Kv<'static>>) -> Kv<'static> {
|
|
Kv::Array(v)
|
|
}
|
|
/// A float the format can hold: finite (non-finite values become 0) and within range.
|
|
fn fl(x: f64) -> Kv<'static> {
|
|
Kv::Float(if x.is_finite() { x.clamp(-MAX_FLOAT, MAX_FLOAT) as f32 } else { 0.0 })
|
|
}
|
|
fn u(x: u32) -> Kv<'static> {
|
|
Kv::Uint(u64::from(x))
|
|
}
|
|
fn int(x: i64) -> Kv<'static> {
|
|
Kv::Int(x.clamp(i64::from(i32::MIN), i64::from(i32::MAX)))
|
|
}
|
|
fn e(name: &'static str) -> Kv<'static> {
|
|
Kv::Enum(name)
|
|
}
|
|
fn s(x: &str) -> Kv<'static> {
|
|
Kv::Str(x.to_string())
|
|
}
|
|
fn b(x: bool) -> Kv<'static> {
|
|
Kv::Bool(x)
|
|
}
|
|
fn guid(session: u32, local: u32) -> Kv<'static> {
|
|
o(vec![("sessionID", u(session)), ("localID", u(local))])
|
|
}
|
|
fn xy(x: f64, y: f64) -> Kv<'static> {
|
|
o(vec![("x", fl(x)), ("y", fl(y))])
|
|
}
|
|
fn color(c: Color) -> Kv<'static> {
|
|
o(vec![("r", fl(c.r.into())), ("g", fl(c.g.into())), ("b", fl(c.b.into())), ("a", fl(c.a.into()))])
|
|
}
|
|
fn matrix(m: Affine) -> Kv<'static> {
|
|
let [a, b, c, d, e, f] = m.as_coeffs();
|
|
o(vec![("m00", fl(a)), ("m01", fl(c)), ("m02", fl(e)), ("m10", fl(b)), ("m11", fl(d)), ("m12", fl(f))])
|
|
}
|
|
/// What the document and its pages say besides their names: left out, a reader takes them as
|
|
/// hidden and fully transparent, and draws nothing below them.
|
|
fn root_fields() -> Fields {
|
|
vec![
|
|
("visible", b(true)),
|
|
("opacity", fl(1.0)),
|
|
("transform", matrix(Affine::IDENTITY)),
|
|
("strokeWeight", fl(0.0)),
|
|
("strokeAlign", e("CENTER")),
|
|
("strokeJoin", e("BEVEL")),
|
|
]
|
|
}
|
|
/// A finite coordinate (vector network blobs store raw floats).
|
|
fn finite(x: f64) -> f64 {
|
|
if x.is_finite() { x.clamp(-MAX_FLOAT, MAX_FLOAT) } else { 0.0 }
|
|
}
|
|
|
|
/// A position string that sorts as child `i` does among its siblings (fixed width, printable).
|
|
fn position(i: usize) -> String {
|
|
let mut out = [0u8; 4];
|
|
let mut v = i;
|
|
for c in out.iter_mut().rev() {
|
|
*c = b'!' + (v % 94) as u8;
|
|
v /= 94;
|
|
}
|
|
String::from_utf8_lossy(&out).into_owned()
|
|
}
|
|
|
|
/// The format's name of a blend mode: the one the import reads back as `m`.
|
|
fn blend_name(m: BlendMode) -> &'static str {
|
|
const NAMES: [&str; 19] = [
|
|
"PASS_THROUGH",
|
|
"NORMAL",
|
|
"DARKEN",
|
|
"MULTIPLY",
|
|
"LINEAR_BURN",
|
|
"COLOR_BURN",
|
|
"LIGHTEN",
|
|
"SCREEN",
|
|
"LINEAR_DODGE",
|
|
"COLOR_DODGE",
|
|
"OVERLAY",
|
|
"SOFT_LIGHT",
|
|
"HARD_LIGHT",
|
|
"DIFFERENCE",
|
|
"EXCLUSION",
|
|
"HUE",
|
|
"SATURATION",
|
|
"COLOR",
|
|
"LUMINOSITY",
|
|
];
|
|
NAMES.into_iter().find(|n| crate::rest::props::blend_mode(n) == Some(m)).unwrap_or("NORMAL")
|
|
}
|
|
|
|
fn cap_name(c: StrokeCap) -> &'static str {
|
|
match c {
|
|
StrokeCap::None => "NONE",
|
|
StrokeCap::Round => "ROUND",
|
|
StrokeCap::Square => "SQUARE",
|
|
StrokeCap::LineArrow => "ARROW_LINES",
|
|
StrokeCap::TriangleArrow | StrokeCap::ReversedTriangle => "ARROW_EQUILATERAL",
|
|
StrokeCap::CircleFilled => "CIRCLE_FILLED",
|
|
StrokeCap::DiamondFilled => "DIAMOND_FILLED",
|
|
}
|
|
}
|
|
|
|
fn join_name(j: StrokeJoin) -> &'static str {
|
|
match j {
|
|
StrokeJoin::Miter => "MITER",
|
|
StrokeJoin::Bevel => "BEVEL",
|
|
StrokeJoin::Round => "ROUND",
|
|
}
|
|
}
|
|
|
|
/// A geometry blob (the import's `svg_path` reads it): commands `0` close, `1` move, `2` line,
|
|
/// `3` quadratic, `4` cubic, each followed by its points as little-endian `f32` pairs.
|
|
fn path_blob(p: &BezPath) -> Vec<u8> {
|
|
let mut out = Vec::new();
|
|
let mut put = |cmd: u8, pts: &[figcraft_doc::geom::Point]| {
|
|
out.push(cmd);
|
|
for q in pts {
|
|
out.extend_from_slice(&(finite(q.x) as f32).to_le_bytes());
|
|
out.extend_from_slice(&(finite(q.y) as f32).to_le_bytes());
|
|
}
|
|
};
|
|
for el in p.elements() {
|
|
match *el {
|
|
PathEl::MoveTo(a) => put(1, &[a]),
|
|
PathEl::LineTo(a) => put(2, &[a]),
|
|
PathEl::QuadTo(a, c) => put(3, &[a, c]),
|
|
PathEl::CurveTo(a, c, d) => put(4, &[a, c, d]),
|
|
PathEl::ClosePath => put(0, &[]),
|
|
}
|
|
}
|
|
out
|
|
}
|
|
|
|
/// Settings an overlay's destination carries.
|
|
struct Overlay {
|
|
position: OverlayPosition,
|
|
close_on_outside: bool,
|
|
background: Option<Color>,
|
|
}
|
|
|
|
struct Exporter<'d> {
|
|
doc: &'d Document,
|
|
/// Layer → local id of its GUID (session [`LAYERS`]).
|
|
ids: BTreeMap<NodeId, u32>,
|
|
nodes: Vec<Kv<'static>>,
|
|
/// Blob bytes → index (identical blobs are written once).
|
|
blobs: BTreeMap<Vec<u8>, u32>,
|
|
blob_bytes: u64,
|
|
/// Image key → its hash (lowercase hex) once written, `None` when its bytes aren't there.
|
|
images: BTreeMap<String, Option<String>>,
|
|
/// `images/<hash>` members.
|
|
files: Vec<(String, Arc<Vec<u8>>)>,
|
|
/// Component property (name, type) → local id of its definition's GUID (session [`AUX`]).
|
|
defs: BTreeMap<(String, &'static str), u32>,
|
|
/// Grid tracks of written grid frames: (columns, rows) local ids (session [`AUX`]).
|
|
tracks: BTreeMap<NodeId, (Vec<u32>, Vec<u32>)>,
|
|
aux: u32,
|
|
overlays: BTreeMap<NodeId, Overlay>,
|
|
/// Flow starting points: layer → (order, name).
|
|
starts: BTreeMap<NodeId, (usize, String)>,
|
|
/// Shared styles, variable collections and variables → local id of their node's GUID (session
|
|
/// [`LAYERS`], after the layers'), and (collection, mode) → local id of the mode's GUID
|
|
/// (session [`AUX`]).
|
|
style_ids: BTreeMap<&'d str, u32>,
|
|
set_ids: BTreeMap<&'d str, u32>,
|
|
var_ids: BTreeMap<&'d str, u32>,
|
|
mode_ids: BTreeMap<(&'d str, &'d str), u32>,
|
|
warnings: Vec<String>,
|
|
}
|
|
|
|
/// The variables bound to one layer, as the fields that carry them: paints by (fills?, index),
|
|
/// gradient stops by (fills?, paint, stop), effect and layout grid fields by (index, field), and
|
|
/// the entries of the layer's own map.
|
|
#[derive(Default)]
|
|
struct Bound {
|
|
paints: BTreeMap<(bool, usize), Kv<'static>>,
|
|
stops: BTreeMap<(bool, usize, usize), Kv<'static>>,
|
|
effects: BTreeMap<(usize, &'static str), Kv<'static>>,
|
|
grids: BTreeMap<(usize, &'static str), Kv<'static>>,
|
|
entries: Vec<Kv<'static>>,
|
|
}
|
|
|
|
impl<'d> Exporter<'d> {
|
|
fn new(doc: &'d Document) -> Self {
|
|
Self {
|
|
doc,
|
|
ids: BTreeMap::new(),
|
|
nodes: Vec::new(),
|
|
blobs: BTreeMap::new(),
|
|
blob_bytes: 0,
|
|
images: BTreeMap::new(),
|
|
files: Vec::new(),
|
|
defs: BTreeMap::new(),
|
|
tracks: BTreeMap::new(),
|
|
aux: 0,
|
|
overlays: BTreeMap::new(),
|
|
starts: BTreeMap::new(),
|
|
style_ids: BTreeMap::new(),
|
|
set_ids: BTreeMap::new(),
|
|
var_ids: BTreeMap::new(),
|
|
mode_ids: BTreeMap::new(),
|
|
warnings: Vec::new(),
|
|
}
|
|
}
|
|
|
|
fn warn(&mut self, w: &str) {
|
|
if !self.warnings.iter().any(|x| x == w) {
|
|
self.warnings.push(w.to_string());
|
|
}
|
|
}
|
|
|
|
fn next_aux(&mut self) -> u32 {
|
|
self.aux += 1;
|
|
self.aux
|
|
}
|
|
|
|
fn guid_of(&self, id: NodeId) -> Option<Kv<'static>> {
|
|
self.ids.get(&id).map(|l| guid(LAYERS, *l))
|
|
}
|
|
|
|
/// The message: the document, its pages and their layers, and the blobs.
|
|
fn message(&mut self) -> Kv<'static> {
|
|
let doc = self.doc;
|
|
self.assign();
|
|
let profile = if doc.color_profile == figcraft_doc::color::ColorProfile::DisplayP3 { "DISPLAY_P3" } else { "SRGB" };
|
|
let mut root: Fields = vec![("guid", guid(0, 0)), ("phase", e("CREATED")), ("type", e("DOCUMENT")), ("name", s(&doc.name))];
|
|
root.extend(root_fields());
|
|
root.push(("documentColorProfile", e(profile)));
|
|
self.nodes.push(o(root));
|
|
for (i, p) in doc.pages.iter().enumerate() {
|
|
self.emit(*p, guid(0, 0), i, None, 0);
|
|
}
|
|
self.assets(doc.pages.len());
|
|
if !doc.comments.is_empty() {
|
|
self.warn("comments were left out");
|
|
}
|
|
let mut blobs: Vec<(u32, Vec<u8>)> = std::mem::take(&mut self.blobs).into_iter().map(|(bytes, i)| (i, bytes)).collect();
|
|
blobs.sort_by_key(|x| x.0);
|
|
o(vec![
|
|
("type", e("NODE_CHANGES")),
|
|
("sessionID", u(0)),
|
|
("nodeChanges", arr(std::mem::take(&mut self.nodes))),
|
|
("blobs", arr(blobs.into_iter().map(|(_, bytes)| o(vec![("bytes", Kv::Bytes(bytes))])).collect())),
|
|
])
|
|
}
|
|
|
|
/// GUIDs for every layer (pages first, then depth-first), component property definitions,
|
|
/// flow starting points and overlay settings, before anything refers to them.
|
|
fn assign(&mut self) {
|
|
let doc = self.doc;
|
|
let mut stack: Vec<NodeId> = doc.pages.iter().rev().copied().collect();
|
|
while let Some(id) = stack.pop() {
|
|
let Some(n) = doc.node(id) else { continue };
|
|
if self.ids.len() >= MAX_NODES {
|
|
self.warn("the document has more layers than a .fig file is read with; the rest were left out");
|
|
break;
|
|
}
|
|
let local = u32::try_from(self.ids.len() + 1).unwrap_or(u32::MAX);
|
|
self.ids.insert(id, local);
|
|
// An instance's layers aren't written (its main says them), so nothing may refer to them.
|
|
let mirrored = matches!(&n.kind, NodeKind::Instance { component, .. } if doc.node(*component).is_some_and(|c| matches!(c.kind, NodeKind::Component { .. })));
|
|
if !mirrored {
|
|
stack.extend(n.children.iter().rev());
|
|
}
|
|
match &n.kind {
|
|
NodeKind::Component { props, .. } => {
|
|
for (name, d) in props {
|
|
if let Some(ty) = prop_type(d) {
|
|
let key = (name.clone(), ty);
|
|
if !self.defs.contains_key(&key) {
|
|
let id = self.next_aux();
|
|
self.defs.insert(key, id);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
NodeKind::Page { flows, .. } => {
|
|
for (i, f) in flows.iter().enumerate() {
|
|
self.starts.entry(f.start).or_insert((i, f.name.clone()));
|
|
}
|
|
}
|
|
_ => {}
|
|
}
|
|
for a in n.interactions.iter().flat_map(|it| figcraft_doc::proto::walk(&it.actions)) {
|
|
if let Action::OpenOverlay { dest, position, close_on_outside, background, .. } = a {
|
|
let o = Overlay { position: *position, close_on_outside: *close_on_outside, background: *background };
|
|
match self.overlays.get(dest) {
|
|
Some(old) if (old.position, old.close_on_outside, old.background) != (o.position, o.close_on_outside, o.background) => {
|
|
self.warn("overlays opened with different settings keep the first one's");
|
|
}
|
|
Some(_) => {}
|
|
None => {
|
|
self.overlays.insert(*dest, o);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// The page that holds styles and variables takes the next id, then their nodes.
|
|
let mut next = u32::try_from(self.ids.len() + 1).unwrap_or(u32::MAX);
|
|
let mut node = || {
|
|
next = next.saturating_add(1);
|
|
next
|
|
};
|
|
for st in &doc.styles {
|
|
self.style_ids.entry(st.id.as_str()).or_insert_with(&mut node);
|
|
}
|
|
for c in &doc.variables.collections {
|
|
self.set_ids.entry(c.id.as_str()).or_insert_with(&mut node);
|
|
}
|
|
for v in &doc.variables.variables {
|
|
if self.set_ids.contains_key(v.collection.as_str()) {
|
|
self.var_ids.entry(v.id.as_str()).or_insert_with(&mut node);
|
|
}
|
|
}
|
|
for c in &doc.variables.collections {
|
|
for m in &c.modes {
|
|
if !self.mode_ids.contains_key(&(c.id.as_str(), m.id.as_str())) {
|
|
let id = self.next_aux();
|
|
self.mode_ids.insert((c.id.as_str(), m.id.as_str()), id);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// The hidden page after the `pages` real ones that holds the shared styles, the variable
|
|
/// collections and the variables, each a node of its own.
|
|
fn assets(&mut self, pages: usize) {
|
|
let doc = self.doc;
|
|
if self.style_ids.is_empty() && self.set_ids.is_empty() {
|
|
return;
|
|
}
|
|
let page = u32::try_from(self.ids.len() + 1).unwrap_or(u32::MAX);
|
|
let mut f: Fields = vec![
|
|
("guid", guid(LAYERS, page)),
|
|
("phase", e("CREATED")),
|
|
("parentIndex", o(vec![("guid", guid(0, 0)), ("position", s(&position(pages)))])),
|
|
("type", e("CANVAS")),
|
|
("name", s("Internal Only Canvas")),
|
|
];
|
|
f.extend(root_fields().into_iter().map(|(k, v)| if k == "visible" { (k, b(false)) } else { (k, v) }));
|
|
f.push(("internalOnly", b(true)));
|
|
self.nodes.push(o(f));
|
|
let mut index = 0usize;
|
|
let mut head = |local: u32, ty: &'static str, name: &str| -> Fields {
|
|
index += 1;
|
|
vec![
|
|
("guid", guid(LAYERS, local)),
|
|
("phase", e("CREATED")),
|
|
("parentIndex", o(vec![("guid", guid(LAYERS, page)), ("position", s(&position(index)))])),
|
|
("type", e(ty)),
|
|
("name", s(name)),
|
|
("sortPosition", s(&position(index))),
|
|
]
|
|
};
|
|
for st in &doc.styles {
|
|
let Some(&local) = self.style_ids.get(st.id.as_str()) else { continue };
|
|
// A sample layer that shows the style: a square for paints and effects, a frame for
|
|
// grids, two letters for text.
|
|
let (ty, kind) = match &st.kind {
|
|
StyleKind::Paint { .. } => ("ROUNDED_RECTANGLE", "FILL"),
|
|
StyleKind::Effect { .. } => ("ROUNDED_RECTANGLE", "EFFECT"),
|
|
StyleKind::Grid { .. } => ("FRAME", "GRID"),
|
|
StyleKind::Text { .. } => ("TEXT", "TEXT"),
|
|
};
|
|
let mut f = head(local, ty, &st.name);
|
|
f.extend([
|
|
("styleType", e(kind)),
|
|
("visible", b(true)),
|
|
("opacity", fl(1.0)),
|
|
("size", xy(100.0, 100.0)),
|
|
("transform", matrix(Affine::IDENTITY)),
|
|
("strokeWeight", fl(0.0)),
|
|
("strokeAlign", e("INSIDE")),
|
|
("strokeJoin", e("MITER")),
|
|
]);
|
|
if !st.description.is_empty() {
|
|
f.push(("description", s(&st.description)));
|
|
}
|
|
// The style's variable bindings ride on its sample layer, as a layer's do.
|
|
let none = if st.bound.is_empty() {
|
|
Bound::default()
|
|
} else {
|
|
let mut sample = Node::new(NodeId(0), NodeKind::Rectangle, "", 0.0, 0.0);
|
|
if let StyleKind::Text { style } = &st.kind {
|
|
sample.kind = NodeKind::Text(TextData { style: style.as_text_style(), ..TextData::new("Ag") });
|
|
}
|
|
sample.bound.clone_from(&st.bound);
|
|
self.bound(&sample)
|
|
};
|
|
let entries = none.entries.clone();
|
|
if !entries.is_empty() {
|
|
f.push(("variableConsumptionMap", o(vec![("entries", arr(entries))])));
|
|
}
|
|
match &st.kind {
|
|
StyleKind::Paint { paints } => f.push(("fillPaints", self.paints(paints, true, &none))),
|
|
StyleKind::Effect { effects } => {
|
|
let list = effects.iter().enumerate().map(|(i, x)| self.effect(x, i, &none)).collect();
|
|
f.extend([("fillPaints", arr(Vec::new())), ("effects", arr(list))]);
|
|
}
|
|
StyleKind::Grid { grids } => {
|
|
let list = grids.iter().enumerate().map(|(i, g)| layout_grid(g, i, &none)).collect();
|
|
f.extend([("fillPaints", arr(Vec::new())), ("layoutGrids", arr(list))]);
|
|
}
|
|
StyleKind::Text { style } => {
|
|
let td = TextData { style: style.as_text_style(), ..TextData::new("Ag") };
|
|
let fills = [Paint::solid(Color::BLACK)];
|
|
f.push(("fillPaints", self.paints(style.fills.as_deref().unwrap_or(&fills), true, &none)));
|
|
self.text(&td, &fills, &mut f);
|
|
}
|
|
}
|
|
self.nodes.push(o(f));
|
|
}
|
|
for c in &doc.variables.collections {
|
|
let Some(&local) = self.set_ids.get(c.id.as_str()) else { continue };
|
|
let mut f = head(local, "VARIABLE_SET", &c.name);
|
|
let modes = c.modes.iter().enumerate().filter_map(|(i, m)| {
|
|
let id = self.mode_ids.get(&(c.id.as_str(), m.id.as_str()))?;
|
|
Some(o(vec![("id", guid(AUX, *id)), ("name", s(&m.name)), ("sortPosition", s(&position(i)))]))
|
|
});
|
|
f.push(("variableSetModes", arr(modes.collect())));
|
|
self.nodes.push(o(f));
|
|
if c.extends.is_some() {
|
|
self.warn("extended variable collections were written as collections of their own");
|
|
}
|
|
}
|
|
for v in &doc.variables.variables {
|
|
let ids = (self.var_ids.get(v.id.as_str()), self.set_ids.get(v.collection.as_str()));
|
|
let (Some(&local), Some(&set), Some(c)) = (ids.0, ids.1, doc.variables.collections.iter().find(|c| c.id == v.collection)) else {
|
|
self.warn("variables whose collection isn't in the document were left out");
|
|
continue;
|
|
};
|
|
let resolved = resolved_type(v.kind);
|
|
let mut values = Vec::new();
|
|
for m in &c.modes {
|
|
let (Some(mode), Some(val)) = (self.mode_ids.get(&(c.id.as_str(), m.id.as_str())), v.values.get(&m.id)) else { continue };
|
|
let (ty, value) = match val {
|
|
VariableValue::Color(x) => ("COLOR", ("colorValue", color(*x))),
|
|
VariableValue::Number(x) => ("FLOAT", ("floatValue", fl(*x))),
|
|
// NULs can't be stored in a string.
|
|
VariableValue::String(x) => ("STRING", ("textValue", s(&x.replace('\0', "")))),
|
|
VariableValue::Boolean(x) => ("BOOLEAN", ("boolValue", b(*x))),
|
|
VariableValue::Alias(a) => match self.var_ids.get(a.as_str()) {
|
|
Some(t) => ("ALIAS", ("alias", o(vec![("guid", guid(LAYERS, *t))]))),
|
|
None => {
|
|
self.warn("variable aliases to variables that aren't in the document were left out");
|
|
continue;
|
|
}
|
|
},
|
|
};
|
|
let data = o(vec![("value", o(vec![value])), ("dataType", e(ty)), ("resolvedDataType", e(resolved))]);
|
|
values.push(o(vec![("modeID", guid(AUX, *mode)), ("variableData", data)]));
|
|
}
|
|
let mut f = head(local, "VARIABLE", &v.name);
|
|
f.extend([
|
|
("variableSetID", o(vec![("guid", guid(LAYERS, set))])),
|
|
("variableResolvedType", e(resolved)),
|
|
("variableDataValues", o(vec![("entries", arr(values))])),
|
|
]);
|
|
if !v.description.is_empty() {
|
|
f.push(("description", s(&v.description)));
|
|
}
|
|
if let Some(scopes) = &v.scopes {
|
|
let known: Vec<Kv> = scopes.iter().filter_map(|sc| scope_name(sc)).map(e).collect();
|
|
if known.len() < scopes.len() {
|
|
self.warn("variable scopes the format has no name for were left out");
|
|
}
|
|
f.push(("variableScopes", arr(known)));
|
|
}
|
|
if v.hidden_from_publishing || !v.code_syntax.is_empty() || v.extends.is_some() {
|
|
self.warn("variables' publishing, code syntax and inheritance settings were left out");
|
|
}
|
|
self.nodes.push(o(f));
|
|
}
|
|
}
|
|
|
|
/// A reference to variable `var` (its id or name) as variable data.
|
|
fn alias(&mut self, var: &str) -> Option<Kv<'static>> {
|
|
let found = self.doc.variables.get(var).and_then(|v| Some((v.kind, *self.var_ids.get(v.id.as_str())?)));
|
|
let Some((kind, local)) = found else {
|
|
self.warn("bindings to variables that aren't in the document were written as their values");
|
|
return None;
|
|
};
|
|
Some(o(vec![
|
|
("value", o(vec![("alias", o(vec![("guid", guid(LAYERS, local))]))])),
|
|
("dataType", e("ALIAS")),
|
|
("resolvedDataType", e(resolved_type(kind))),
|
|
]))
|
|
}
|
|
|
|
/// Layer `n`'s variable bindings, sorted into the fields that carry them. What the format has
|
|
/// no field for stays as the value the layer already shows, with a warning.
|
|
fn bound(&mut self, n: &Node) -> Bound {
|
|
const BAKED: &str = "variables bound to properties the format has no field for were written as their values";
|
|
let mut out = Bound::default();
|
|
for (key, var) in &n.bound {
|
|
let parts: Vec<&str> = key.split('/').collect();
|
|
let index = |i: &str| i.parse::<usize>().ok().filter(|_| i.bytes().all(|c| c.is_ascii_digit()));
|
|
let fields: &[&'static str] = match (parts.as_slice(), key.as_str()) {
|
|
(_, "fill" | "fills" | "fills/0" | "stroke") => {
|
|
if let Some(a) = self.alias(var) {
|
|
out.paints.insert((key != "stroke", 0), a);
|
|
}
|
|
continue;
|
|
}
|
|
([list @ ("fills" | "strokes"), i, "color"], _) => {
|
|
if let (Some(i), Some(a)) = (index(i), self.alias(var)) {
|
|
out.paints.insert((*list == "fills", i), a);
|
|
}
|
|
continue;
|
|
}
|
|
([list @ ("fills" | "strokes"), i, "stops", j, "color"], _) => {
|
|
if let (Some(i), Some(j), Some(a)) = (index(i), index(j), self.alias(var)) {
|
|
out.stops.insert((*list == "fills", i, j), a);
|
|
}
|
|
continue;
|
|
}
|
|
([list @ ("effects" | "layoutGrids"), i, field], _) => {
|
|
let names: &[&'static str] = if *list == "effects" {
|
|
&["color", "radius", "spread", "offsetX", "offsetY", "startRadius"]
|
|
} else {
|
|
&["size", "count", "gutter", "offset"]
|
|
};
|
|
match (index(i), names.iter().find(|f| *f == field)) {
|
|
(Some(i), Some(name)) => {
|
|
if let Some(a) = self.alias(var) {
|
|
if *list == "effects" { &mut out.effects } else { &mut out.grids }.insert((i, *name), a);
|
|
}
|
|
}
|
|
_ => self.warn(BAKED),
|
|
}
|
|
continue;
|
|
}
|
|
(_, "width") => &["WIDTH"],
|
|
(_, "height") => &["HEIGHT"],
|
|
(_, "gap") => &["STACK_SPACING"],
|
|
(_, "crossGap") => &["STACK_COUNTER_SPACING"],
|
|
(_, "paddingLeft") => &["STACK_PADDING_LEFT"],
|
|
(_, "paddingTop") => &["STACK_PADDING_TOP"],
|
|
(_, "paddingRight") => &["STACK_PADDING_RIGHT"],
|
|
(_, "paddingBottom") => &["STACK_PADDING_BOTTOM"],
|
|
(_, "paddingHorizontal") => &["STACK_PADDING_LEFT", "STACK_PADDING_RIGHT"],
|
|
(_, "paddingVertical") => &["STACK_PADDING_TOP", "STACK_PADDING_BOTTOM"],
|
|
(_, "padding") => &["STACK_PADDING_LEFT", "STACK_PADDING_TOP", "STACK_PADDING_RIGHT", "STACK_PADDING_BOTTOM"],
|
|
(_, "cornerRadius") => &[
|
|
"CORNER_RADIUS",
|
|
"RECTANGLE_TOP_LEFT_CORNER_RADIUS",
|
|
"RECTANGLE_TOP_RIGHT_CORNER_RADIUS",
|
|
"RECTANGLE_BOTTOM_LEFT_CORNER_RADIUS",
|
|
"RECTANGLE_BOTTOM_RIGHT_CORNER_RADIUS",
|
|
],
|
|
(_, "topLeftRadius") => &["RECTANGLE_TOP_LEFT_CORNER_RADIUS"],
|
|
(_, "topRightRadius") => &["RECTANGLE_TOP_RIGHT_CORNER_RADIUS"],
|
|
(_, "bottomLeftRadius") => &["RECTANGLE_BOTTOM_LEFT_CORNER_RADIUS"],
|
|
(_, "bottomRightRadius") => &["RECTANGLE_BOTTOM_RIGHT_CORNER_RADIUS"],
|
|
(_, "opacity") => &["OPACITY"],
|
|
(_, "visible") => &["VISIBLE"],
|
|
(_, "characters") => &["TEXT_DATA"],
|
|
(_, "strokeWeight") => &["STROKE_WEIGHT"],
|
|
(_, "strokeTopWeight") => &["BORDER_TOP_WEIGHT"],
|
|
(_, "strokeRightWeight") => &["BORDER_RIGHT_WEIGHT"],
|
|
(_, "strokeBottomWeight") => &["BORDER_BOTTOM_WEIGHT"],
|
|
(_, "strokeLeftWeight") => &["BORDER_LEFT_WEIGHT"],
|
|
(_, "minWidth") => &["MIN_WIDTH"],
|
|
(_, "maxWidth") => &["MAX_WIDTH"],
|
|
(_, "minHeight") => &["MIN_HEIGHT"],
|
|
(_, "maxHeight") => &["MAX_HEIGHT"],
|
|
(_, "fontSize") => &["FONT_SIZE"],
|
|
(_, "fontFamily") => &["FONT_FAMILY"],
|
|
(_, "fontStyle") => &["FONT_STYLE"],
|
|
(_, "letterSpacing") => &["LETTER_SPACING"],
|
|
(_, "lineHeight") => &["LINE_HEIGHT"],
|
|
(_, "paragraphSpacing") => &["PARAGRAPH_SPACING"],
|
|
(_, "paragraphIndent") => &["PARAGRAPH_INDENT"],
|
|
_ => {
|
|
self.warn(BAKED);
|
|
continue;
|
|
}
|
|
};
|
|
// Each entry names the bound property and the number of the layer field that holds it.
|
|
for field in fields {
|
|
if let Some(a) = self.alias(var) {
|
|
let mut entry: Fields = node_field(field).into_iter().map(|id| ("nodeField", u(id))).collect();
|
|
entry.extend([("variableData", a), ("variableField", e(field))]);
|
|
out.entries.push(o(entry));
|
|
}
|
|
}
|
|
}
|
|
out
|
|
}
|
|
|
|
/// Write layer `id` (child `index` of the layer with GUID `parent_guid`) and its subtree.
|
|
fn emit(&mut self, id: NodeId, parent_guid: Kv<'static>, index: usize, parent: Option<&Node>, depth: usize) {
|
|
let doc = self.doc;
|
|
let (Some(&local), Some(n)) = (self.ids.get(&id), doc.node(id)) else { return };
|
|
if depth > MAX_DEPTH {
|
|
self.warn("layers nested deeper than 256 levels were left out");
|
|
return;
|
|
}
|
|
let mut f: Fields = vec![
|
|
("guid", guid(LAYERS, local)),
|
|
("phase", e("CREATED")),
|
|
("parentIndex", o(vec![("guid", parent_guid), ("position", s(&position(index)))])),
|
|
];
|
|
let children = if let NodeKind::Page { background, guides, prototype, .. } = &n.kind {
|
|
f.extend([("type", e("CANVAS")), ("name", s(&n.name))]);
|
|
f.extend(root_fields());
|
|
f.extend([("backgroundColor", color(*background)), ("backgroundOpacity", fl(background.a.into())), ("backgroundEnabled", b(true))]);
|
|
if !guides.is_empty() {
|
|
self.warn("ruler guides were left out");
|
|
}
|
|
if *prototype != Default::default() {
|
|
self.warn("prototype device settings were left out");
|
|
}
|
|
self.modes(n, &mut f);
|
|
true
|
|
} else {
|
|
self.layer(n, parent, &mut f, false)
|
|
};
|
|
self.nodes.push(o(f));
|
|
if children {
|
|
for (i, c) in n.children.iter().enumerate() {
|
|
self.emit(*c, guid(LAYERS, local), i, Some(n), depth + 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// The fields of layer `n` (whose parent is `parent`). `nested`: for an instance's override
|
|
/// (no type, no instance or component data). Returns whether its children are written as
|
|
/// layers (an instance's come from its main).
|
|
fn layer(&mut self, n: &Node, parent: Option<&Node>, f: &mut Fields, nested: bool) -> bool {
|
|
let doc = self.doc;
|
|
if let Some((outline, original)) = outlined(n) {
|
|
// The format's variable width is the same on both sides of the path: a stroke wider on
|
|
// one side is written as the area it paints, with the stroke itself kept as plugin data
|
|
// (which the import puts back).
|
|
self.warn("strokes wider on one side of their path were written as filled outlines (the stroke itself is kept for FigCraft)");
|
|
let children = self.layer(&outline, parent, f, nested);
|
|
f.push(("pluginData", arr(vec![o(vec![("pluginID", s(STASH.0)), ("value", s(&original)), ("key", s(STASH.1))])])));
|
|
return children;
|
|
}
|
|
let main = match &n.kind {
|
|
NodeKind::Instance { component, .. } => {
|
|
let found = self.ids.contains_key(component) && doc.node(*component).is_some_and(|c| matches!(c.kind, NodeKind::Component { .. }));
|
|
if !found && !nested {
|
|
self.warn("instances of components that aren't in the file were written as frames");
|
|
}
|
|
found.then_some(*component)
|
|
}
|
|
_ => None,
|
|
};
|
|
let ty = match &n.kind {
|
|
NodeKind::Page { .. } | NodeKind::Frame | NodeKind::Group | NodeKind::ComponentSet { .. } => "FRAME",
|
|
NodeKind::Instance { .. } if main.is_none() => "FRAME",
|
|
NodeKind::Section { .. } => "SECTION",
|
|
NodeKind::Rectangle => "ROUNDED_RECTANGLE",
|
|
NodeKind::Ellipse { .. } => "ELLIPSE",
|
|
NodeKind::Polygon { .. } => "REGULAR_POLYGON",
|
|
NodeKind::Star { .. } => "STAR",
|
|
NodeKind::Line => "LINE",
|
|
NodeKind::Vector { .. } => "VECTOR",
|
|
NodeKind::Text(_) => "TEXT",
|
|
NodeKind::BooleanOp { .. } => "BOOLEAN_OPERATION",
|
|
NodeKind::Component { .. } => "SYMBOL",
|
|
NodeKind::Instance { .. } => "INSTANCE",
|
|
NodeKind::Slice => "SLICE",
|
|
};
|
|
if !nested {
|
|
f.push(("type", e(ty)));
|
|
}
|
|
f.push(("name", s(&n.name)));
|
|
self.common(n, parent, f);
|
|
match &n.kind {
|
|
NodeKind::Group => f.push(("resizeToFit", b(true))),
|
|
NodeKind::Section { contents_hidden } => f.push(("sectionContentsHidden", b(*contents_hidden))),
|
|
NodeKind::Ellipse { start, sweep, inner } => {
|
|
f.push(("arcData", o(vec![("startingAngle", fl(*start)), ("endingAngle", fl(start + sweep)), ("innerRadius", fl(*inner))])))
|
|
}
|
|
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::BooleanOp { op } => {
|
|
let name = match op {
|
|
BoolOp::Union => "UNION",
|
|
BoolOp::Subtract => "SUBTRACT",
|
|
BoolOp::Intersect => "INTERSECT",
|
|
BoolOp::Exclude => "XOR",
|
|
};
|
|
f.push(("booleanOperation", e(name)));
|
|
if n.children.iter().filter_map(|c| doc.node(*c)).any(|c| c.bool_op.is_some()) {
|
|
self.warn("boolean groups whose layers combine in different ways use the group's operation");
|
|
}
|
|
}
|
|
NodeKind::Component { description, props } if !nested => {
|
|
let defs: Vec<Kv> = props.iter().filter_map(|(name, d)| self.prop_def(name, d)).collect();
|
|
if !defs.is_empty() {
|
|
f.push(("componentPropDefs", arr(defs)));
|
|
}
|
|
if props.values().any(|d| matches!(d, PropDef::Slot { .. })) {
|
|
self.warn("slot properties were left out");
|
|
}
|
|
if !description.is_empty() {
|
|
f.push(("symbolDescription", s(description)));
|
|
}
|
|
}
|
|
NodeKind::ComponentSet { description } if !nested => {
|
|
f.push(("isStateGroup", b(true)));
|
|
if !description.is_empty() {
|
|
f.push(("symbolDescription", s(description)));
|
|
}
|
|
}
|
|
NodeKind::Instance { props, .. } if !nested => {
|
|
if let Some(main) = main {
|
|
self.instance(n, main, props, f);
|
|
}
|
|
}
|
|
_ => {}
|
|
}
|
|
let boxy = n.kind.is_frame_like() || matches!(n.kind, NodeKind::Rectangle | NodeKind::Section { .. });
|
|
if (boxy || matches!(n.kind, NodeKind::Ellipse { .. } | NodeKind::Polygon { .. } | NodeKind::Star { .. }))
|
|
&& let Some(p) = figcraft_doc::geometry::shape_path(n)
|
|
{
|
|
self.geometry("fillGeometry", &p, WindingRule::NonZero, f);
|
|
}
|
|
self.stroke_geometry(n, boxy, f);
|
|
main.is_none()
|
|
}
|
|
|
|
/// Fields every layer kind shares.
|
|
fn common(&mut self, n: &Node, parent: Option<&Node>, f: &mut Fields) {
|
|
f.extend([
|
|
("visible", b(n.visible)),
|
|
("locked", b(n.locked)),
|
|
("opacity", fl(n.opacity.into())),
|
|
("blendMode", e(blend_name(n.blend))),
|
|
("size", xy(n.width, n.height)),
|
|
("transform", matrix(n.transform)),
|
|
]);
|
|
if n.is_mask {
|
|
let ty = match n.mask_type {
|
|
MaskType::Alpha => "ALPHA",
|
|
MaskType::Vector => "OUTLINE",
|
|
MaskType::Luminance => "LUMINANCE",
|
|
};
|
|
f.extend([("mask", b(true)), ("maskType", e(ty))]);
|
|
}
|
|
let bound = self.bound(n);
|
|
// Text whose own style sets fills paints with them (the layer's fills only show through
|
|
// runs); a variable bound to the layer's fill colours the layer's.
|
|
let fills = match &n.kind {
|
|
NodeKind::Text(TextData { style: TextStyle { fills: Some(own), .. }, .. }) => self.paints(own, true, &Bound::default()),
|
|
_ => self.paints(&n.fills, true, &bound),
|
|
};
|
|
let strokes = self.paints(&n.strokes, false, &bound);
|
|
f.extend([("fillPaints", fills), ("strokePaints", strokes)]);
|
|
self.stroke(n, f);
|
|
if !n.effects.is_empty() {
|
|
let effects = n.effects.iter().enumerate().map(|(i, x)| self.effect(x, i, &bound)).collect();
|
|
f.push(("effects", arr(effects)));
|
|
}
|
|
if n.kind.has_corner_radius() {
|
|
let r = n.corners.radii;
|
|
f.push(("cornerRadius", fl(r[0])));
|
|
let differ = r.iter().any(|x| *x != r[0]);
|
|
if n.kind.has_independent_corners() && (differ || r[0] > 0.0) {
|
|
f.extend(differ.then(|| ("rectangleCornerRadiiIndependent", b(true))));
|
|
f.extend([
|
|
("rectangleTopLeftCornerRadius", fl(r[0])),
|
|
("rectangleTopRightCornerRadius", fl(r[1])),
|
|
("rectangleBottomRightCornerRadius", fl(r[2])),
|
|
("rectangleBottomLeftCornerRadius", fl(r[3])),
|
|
]);
|
|
}
|
|
if n.corners.smoothing > 0.0 {
|
|
f.push(("cornerSmoothing", fl(n.corners.smoothing)));
|
|
}
|
|
}
|
|
let h = match n.constraints.horizontal {
|
|
HConstraint::Left => "MIN",
|
|
HConstraint::Right => "MAX",
|
|
HConstraint::LeftRight => "STRETCH",
|
|
HConstraint::Center => "CENTER",
|
|
HConstraint::Scale => "SCALE",
|
|
};
|
|
let v = match n.constraints.vertical {
|
|
VConstraint::Top => "MIN",
|
|
VConstraint::Bottom => "MAX",
|
|
VConstraint::TopBottom => "STRETCH",
|
|
VConstraint::Center => "CENTER",
|
|
VConstraint::Scale => "SCALE",
|
|
};
|
|
f.extend([("horizontalConstraint", e(h)), ("verticalConstraint", e(v))]);
|
|
if n.kind.is_frame_like() || matches!(n.kind, NodeKind::Section { .. }) {
|
|
f.push(("frameMaskDisabled", b(!n.clip)));
|
|
}
|
|
if n.kind.is_frame_like() {
|
|
if let Some(l) = &n.layout {
|
|
self.auto_layout(n, l, f);
|
|
}
|
|
if !n.grids.is_empty() {
|
|
f.push(("layoutGrids", arr(n.grids.iter().enumerate().map(|(i, g)| layout_grid(g, i, &bound)).collect())));
|
|
}
|
|
}
|
|
self.child_layout(n, parent, f);
|
|
if !n.exports.is_empty() {
|
|
if n.exports.iter().any(|x| x.format == figcraft_doc::ExportFormat::Webp) {
|
|
self.warn("WebP export settings were written as PNG");
|
|
}
|
|
f.push(("exportSettings", arr(n.exports.iter().map(export_setting).collect())));
|
|
}
|
|
self.prototype(n, f);
|
|
let refs: Vec<Kv> = n.prop_refs.iter().filter_map(|(field, prop)| self.prop_ref(field, prop)).collect();
|
|
if !refs.is_empty() {
|
|
f.push(("parameterConsumptionMap", o(vec![("entries", arr(refs))])));
|
|
}
|
|
let text = matches!(n.kind, NodeKind::Text(_));
|
|
let links = [
|
|
("styleIdForFill", &n.styles.fill, true),
|
|
("styleIdForStrokeFill", &n.styles.stroke, true),
|
|
("styleIdForEffect", &n.styles.effect, true),
|
|
("styleIdForGrid", &n.styles.grid, n.kind.is_frame_like()),
|
|
("styleIdForText", &n.styles.text, text),
|
|
];
|
|
for (key, id, fits) in links {
|
|
let Some(id) = id else { continue };
|
|
match self.style_ids.get(id.as_str()).filter(|_| fits) {
|
|
Some(local) => f.push((key, o(vec![("guid", guid(LAYERS, *local))]))),
|
|
None => self.warn("links to shared styles that aren't in the document were left out (their layers keep the values)"),
|
|
}
|
|
}
|
|
if let NodeKind::Text(td) = &n.kind
|
|
&& n.styles.text.is_none()
|
|
&& std::iter::once(&td.style).chain(td.runs.iter().map(|r| &r.style)).any(|st| st.style_id.is_some())
|
|
{
|
|
self.warn("text styles applied to part of a text were written as their values");
|
|
}
|
|
if !bound.entries.is_empty() {
|
|
f.push(("variableConsumptionMap", o(vec![("entries", arr(bound.entries))])));
|
|
}
|
|
self.modes(n, f);
|
|
if !n.guides.is_empty() {
|
|
self.warn("ruler guides were left out");
|
|
}
|
|
if !n.annotations.is_empty() || !n.dev_resources.is_empty() || !n.code_links.is_empty() || !n.dev_status.is_none() {
|
|
self.warn("Dev Mode annotations, statuses, resources and code links were left out");
|
|
}
|
|
if !n.plugin_data.is_empty() {
|
|
self.warn("plugin data was left out");
|
|
}
|
|
}
|
|
|
|
/// The variable modes layer (or page) `n` sets for what is in it.
|
|
fn modes(&mut self, n: &Node, f: &mut Fields) {
|
|
let mut entries = Vec::new();
|
|
for (coll, mode) in &n.var_modes {
|
|
match (self.set_ids.get(coll.as_str()), self.mode_ids.get(&(coll.as_str(), mode.as_str()))) {
|
|
(Some(set), Some(mode)) => {
|
|
entries.push(o(vec![("variableSetID", o(vec![("guid", guid(LAYERS, *set))])), ("variableModeID", guid(AUX, *mode))]));
|
|
}
|
|
_ => self.warn("variable modes of collections that aren't in the document were left out"),
|
|
}
|
|
}
|
|
if !entries.is_empty() {
|
|
f.push(("variableModeBySetMap", o(vec![("entries", arr(entries))])));
|
|
}
|
|
}
|
|
|
|
/// A paint list: a layer's fills (`fills`) or strokes with the variables `bound` to them.
|
|
fn paints(&mut self, list: &[Paint], fills: bool, bound: &Bound) -> Kv<'static> {
|
|
arr(list.iter().enumerate().filter_map(|(i, p)| self.paint(p, (fills, i), bound)).collect())
|
|
}
|
|
|
|
fn paint(&mut self, p: &Paint, at: (bool, usize), bound: &Bound) -> Option<Kv<'static>> {
|
|
let mut f: Fields = vec![("visible", b(p.visible)), ("blendMode", e(blend_name(p.blend)))];
|
|
let mut opacity = f64::from(p.opacity);
|
|
match &p.kind {
|
|
PaintKind::Solid { color: c } => {
|
|
opacity *= f64::from(c.a);
|
|
f.extend([("type", e("SOLID")), ("color", color(c.with_alpha(1.0)))]);
|
|
f.extend(bound.paints.get(&at).map(|a| ("colorVar", a.clone())));
|
|
}
|
|
PaintKind::Gradient(g) => {
|
|
let ty = match g.kind {
|
|
GradientKind::Linear => "GRADIENT_LINEAR",
|
|
GradientKind::Radial => "GRADIENT_RADIAL",
|
|
GradientKind::Angular => "GRADIENT_ANGULAR",
|
|
GradientKind::Diamond => "GRADIENT_DIAMOND",
|
|
};
|
|
// The handles in the unit box come from the inverse of the paint transform: it maps
|
|
// (0, ½) → start, (1, ½) → end, (0, 1) → width for linear gradients, and the centre
|
|
// (½, ½) and the points half a box away from it for the others.
|
|
let (from, to, width) = (g.from, g.to, g.width);
|
|
let (ax, ay) =
|
|
if g.kind == GradientKind::Linear { (to.0 - from.0, to.1 - from.1) } else { (2.0 * (to.0 - from.0), 2.0 * (to.1 - from.1)) };
|
|
let (cx, cy) = (2.0 * (width.0 - from.0), 2.0 * (width.1 - from.1));
|
|
let (ex, ey) = if g.kind == GradientKind::Linear {
|
|
(from.0 - 0.5 * cx, from.1 - 0.5 * cy)
|
|
} else {
|
|
(from.0 - 0.5 * (ax + cx), from.1 - 0.5 * (ay + cy))
|
|
};
|
|
let handles = Affine::new([ax, ay, cx, cy, ex, ey]);
|
|
let t = if handles.determinant().abs() > 1e-12 && handles.as_coeffs().iter().all(|x| x.is_finite()) {
|
|
handles.inverse()
|
|
} else {
|
|
self.warn("gradients with handles on one line were written with the default direction");
|
|
Affine::IDENTITY
|
|
};
|
|
let stops = g.stops.iter().map(|st| o(vec![("color", color(st.color)), ("position", fl(st.position.into()))])).collect();
|
|
f.extend([("type", e(ty)), ("stops", arr(stops)), ("transform", matrix(t))]);
|
|
// Stops bound to variables: every stop again, the bound ones with their variable.
|
|
if bound.stops.range((at.0, at.1, 0)..=(at.0, at.1, usize::MAX)).next().is_some() {
|
|
let vars = g.stops.iter().enumerate().map(|(j, st)| {
|
|
let mut sf: Fields = vec![("color", color(st.color))];
|
|
sf.extend(bound.stops.get(&(at.0, at.1, j)).map(|a| ("colorVar", a.clone())));
|
|
sf.push(("position", fl(st.position.into())));
|
|
o(sf)
|
|
});
|
|
f.push(("stopsVar", arr(vars.collect())));
|
|
}
|
|
}
|
|
PaintKind::Image(img) => {
|
|
let hash = self.image(&img.image);
|
|
let mode = match img.scale_mode {
|
|
ImageScaleMode::Fill => "FILL",
|
|
ImageScaleMode::Fit => "FIT",
|
|
ImageScaleMode::Crop => "STRETCH",
|
|
ImageScaleMode::Tile => "TILE",
|
|
};
|
|
f.extend([
|
|
("type", e("IMAGE")),
|
|
("image", o(vec![("hash", Kv::Bytes(hash)), ("name", s(""))])),
|
|
("imageScaleMode", e(mode)),
|
|
("rotation", fl(f64::from(img.rotation.rem_euclid(4)) * 90.0)),
|
|
("scale", fl(img.scale)),
|
|
]);
|
|
if let (ImageScaleMode::Crop, Some(c)) = (img.scale_mode, img.crop) {
|
|
f.push(("transform", matrix(Affine::new(c))));
|
|
}
|
|
if img.filters != Default::default() {
|
|
self.warn("image adjustments (exposure, contrast, …) were left out");
|
|
}
|
|
}
|
|
PaintKind::Pattern(_) => {
|
|
self.warn("pattern fills were left out");
|
|
return None;
|
|
}
|
|
}
|
|
f.push(("opacity", fl(opacity)));
|
|
Some(o(f))
|
|
}
|
|
|
|
/// The hash bytes of image `key`, writing its file once (empty when its bytes aren't there).
|
|
fn image(&mut self, key: &str) -> Vec<u8> {
|
|
let hex = match self.images.get(key) {
|
|
Some(h) => h.clone(),
|
|
None => {
|
|
let h = match self.doc.images.get(key) {
|
|
Some(img) if img.bytes.len() as u64 <= MAX_IMAGE => {
|
|
let h = crate::image_hash(&img.bytes);
|
|
if !self.files.iter().any(|(x, _)| *x == h) {
|
|
self.files.push((h.clone(), img.bytes.clone()));
|
|
}
|
|
Some(h)
|
|
}
|
|
Some(_) => {
|
|
self.warn("images larger than 256 MB were left out");
|
|
None
|
|
}
|
|
None => {
|
|
self.warn("image fills whose image isn't in the document were written without one");
|
|
None
|
|
}
|
|
};
|
|
self.images.insert(key.to_string(), h.clone());
|
|
h
|
|
}
|
|
};
|
|
let hex = hex.unwrap_or_default();
|
|
(0..hex.len() / 2).filter_map(|i| hex.get(2 * i..2 * i + 2).and_then(|d| u8::from_str_radix(d, 16).ok())).collect()
|
|
}
|
|
|
|
fn stroke(&mut self, n: &Node, f: &mut Fields) {
|
|
let sp = &n.stroke;
|
|
let align = match sp.align {
|
|
StrokeAlign::Inside => "INSIDE",
|
|
StrokeAlign::Center => "CENTER",
|
|
StrokeAlign::Outside => "OUTSIDE",
|
|
};
|
|
f.extend([
|
|
("strokeWeight", fl(sp.weight)),
|
|
("strokeAlign", e(align)),
|
|
("strokeJoin", e(join_name(sp.join))),
|
|
("strokeCap", e(cap_name(sp.cap_start))),
|
|
("miterLimit", fl(sp.miter_limit)),
|
|
]);
|
|
if !sp.dashes.is_empty() {
|
|
f.push(("dashPattern", arr(sp.dashes.iter().map(|d| fl(*d)).collect())));
|
|
}
|
|
if let Some([t, r, bo, l]) = sp.sides {
|
|
f.extend([
|
|
("borderStrokeWeightsIndependent", b(true)),
|
|
("borderTopWeight", fl(t)),
|
|
("borderRightWeight", fl(r)),
|
|
("borderBottomWeight", fl(bo)),
|
|
("borderLeftWeight", fl(l)),
|
|
]);
|
|
}
|
|
// A variable width: how far the stroke reaches on each side of the path at positions along
|
|
// its length, as a share of the stroke weight (half of it each for the full weight). The
|
|
// two sides are the same: a reader draws nothing for a point with unequal sides.
|
|
if let Some(p) = sp.profile().filter(|_| sp.weight.is_finite() && sp.weight > 0.0) {
|
|
let point = |q: &figcraft_doc::WidthPoint| o(vec![("position", fl(q.t)), ("ascent", fl(q.scale / 2.0)), ("descent", fl(q.scale / 2.0))]);
|
|
let p = p.sanitized();
|
|
if one_sided(&p) {
|
|
self.warn("strokes wider on one side of their path were written with that width on both sides");
|
|
}
|
|
f.push(("variableWidthPoints", arr(p.points.iter().map(point).collect())));
|
|
}
|
|
if sp.brush.is_some() {
|
|
self.warn("brush strokes were written as plain strokes");
|
|
}
|
|
if [sp.cap_start, sp.cap_end].contains(&StrokeCap::ReversedTriangle) {
|
|
self.warn("reversed triangle stroke ends were written as triangle arrows");
|
|
}
|
|
// Vectors keep each end's cap on their end points; other layers have one cap.
|
|
if sp.cap_start != sp.cap_end && !matches!(n.kind, NodeKind::Vector { .. }) {
|
|
self.warn("lines with different stroke ends use the start's at both ends");
|
|
}
|
|
}
|
|
|
|
/// Effect `index` of a layer, with the variables `bound` to its fields.
|
|
fn effect(&mut self, x: &figcraft_doc::Effect, index: usize, bound: &Bound) -> Kv<'static> {
|
|
let mut f: Fields = vec![("visible", b(x.visible))];
|
|
let vars = [
|
|
("color", "colorVar"),
|
|
("radius", "radiusVar"),
|
|
("spread", "spreadVar"),
|
|
("offsetX", "xVar"),
|
|
("offsetY", "yVar"),
|
|
("startRadius", "startRadiusVar"),
|
|
];
|
|
f.extend(vars.into_iter().filter_map(|(ours, key)| Some((key, bound.effects.get(&(index, ours))?.clone()))));
|
|
let blur = |f: &mut Fields, ty: &'static str, bl: &figcraft_doc::Blur| {
|
|
f.extend([("type", e(ty)), ("radius", fl(bl.radius))]);
|
|
if bl.blur_type == figcraft_doc::BlurType::Progressive {
|
|
f.extend([
|
|
("blurOpType", e("PROGRESSIVE")),
|
|
("startRadius", fl(bl.start_radius)),
|
|
("startOffset", xy(bl.start.0, bl.start.1)),
|
|
("endOffset", xy(bl.end.0, bl.end.1)),
|
|
]);
|
|
}
|
|
};
|
|
let grain = |size: f64, size_y: Option<f64>| xy(size, size_y.unwrap_or(size));
|
|
match &x.kind {
|
|
EffectKind::DropShadow(sh) | EffectKind::InnerShadow(sh) => {
|
|
let ty = if matches!(x.kind, EffectKind::DropShadow(_)) { "DROP_SHADOW" } else { "INNER_SHADOW" };
|
|
f.extend([
|
|
("type", e(ty)),
|
|
("color", color(sh.color)),
|
|
("offset", xy(sh.offset.0, sh.offset.1)),
|
|
("radius", fl(sh.radius)),
|
|
("spread", fl(sh.spread)),
|
|
("blendMode", e(blend_name(sh.blend))),
|
|
("showShadowBehindNode", b(sh.show_behind)),
|
|
]);
|
|
}
|
|
EffectKind::LayerBlur(bl) => blur(&mut f, "FOREGROUND_BLUR", bl),
|
|
EffectKind::BackgroundBlur(bl) => blur(&mut f, "BACKGROUND_BLUR", bl),
|
|
EffectKind::Noise(nz) => {
|
|
let mode = match nz.mode {
|
|
NoiseMode::Mono => "MONOTONE",
|
|
NoiseMode::Duo => "DUOTONE",
|
|
NoiseMode::Multi => "MULTITONE",
|
|
};
|
|
f.extend([
|
|
("type", e("NOISE")),
|
|
("noiseType", e(mode)),
|
|
("noiseSize", grain(nz.size, nz.size_y)),
|
|
("density", fl(nz.density)),
|
|
("color", color(nz.color)),
|
|
("secondaryColor", color(nz.secondary)),
|
|
("opacity", fl(nz.opacity.into())),
|
|
("blendMode", e(blend_name(nz.blend))),
|
|
]);
|
|
}
|
|
EffectKind::Texture(t) => {
|
|
f.extend([
|
|
("type", e("GRAIN")),
|
|
("noiseSize", grain(t.size, t.size_y)),
|
|
("radius", fl(t.radius)),
|
|
("clipToShape", b(t.clip_to_shape)),
|
|
]);
|
|
}
|
|
EffectKind::Glass(g) => {
|
|
self.warn("glass effects keep only their frost");
|
|
f.extend([("type", e("GLASS")), ("radius", fl(g.frost))]);
|
|
}
|
|
}
|
|
o(f)
|
|
}
|
|
|
|
fn auto_layout(&mut self, n: &Node, l: &AutoLayout, f: &mut Fields) {
|
|
let grid = l.mode == LayoutMode::Grid;
|
|
let mode = match l.mode {
|
|
LayoutMode::Horizontal => "HORIZONTAL",
|
|
LayoutMode::Vertical => "VERTICAL",
|
|
LayoutMode::Grid => "GRID",
|
|
};
|
|
let [top, right, bottom, left] = l.padding;
|
|
let main = match l.main_align {
|
|
MainAlign::Min => "MIN",
|
|
MainAlign::Center => "CENTER",
|
|
MainAlign::Max => "MAX",
|
|
MainAlign::SpaceBetween => "SPACE_BETWEEN",
|
|
MainAlign::SpaceAround => "SPACE_AROUND",
|
|
MainAlign::SpaceEvenly => "SPACE_EVENLY",
|
|
};
|
|
let cross = match l.cross_align {
|
|
CrossAlign::Min => "MIN",
|
|
CrossAlign::Center => "CENTER",
|
|
CrossAlign::Max => "MAX",
|
|
CrossAlign::Baseline => "BASELINE",
|
|
};
|
|
// The main axis is the width for horizontal and grid layouts.
|
|
let (main_hug, cross_hug) = {
|
|
let (h, v) = (n.child_layout.sizing_h == Sizing::Hug, n.child_layout.sizing_v == Sizing::Hug);
|
|
if l.mode == LayoutMode::Vertical { (v, h) } else { (h, v) }
|
|
};
|
|
let size = |hug: bool| e(if hug { "RESIZE_TO_FIT" } else { "FIXED" });
|
|
f.extend([
|
|
("stackMode", e(mode)),
|
|
("stackWrap", e(if l.wrap { "WRAP" } else { "NO_WRAP" })),
|
|
("stackHorizontalPadding", fl(left)),
|
|
("stackVerticalPadding", fl(top)),
|
|
("stackPaddingRight", fl(right)),
|
|
("stackPaddingBottom", fl(bottom)),
|
|
("stackPrimaryAlignItems", e(main)),
|
|
("stackCounterAlignItems", e(cross)),
|
|
("stackPrimarySizing", size(main_hug)),
|
|
("stackCounterSizing", size(cross_hug)),
|
|
("bordersTakeSpace", b(l.strokes_included)),
|
|
("stackReverseZIndex", b(l.reverse_z)),
|
|
]);
|
|
if grid {
|
|
// Instance layers share their main layer's track ids, so unchanged tracks and the cells
|
|
// their layers sit in still match.
|
|
let key = self.main_layer(n.id);
|
|
let (want_c, want_r) = (l.grid_columns.min(1000) as usize, l.grid_rows.min(1000) as usize);
|
|
let (cols, rows) = match self.tracks.get(&key) {
|
|
Some((c, r)) if (c.len(), r.len()) == (want_c, want_r) => (c.clone(), r.clone()),
|
|
_ => ((0..want_c).map(|_| self.next_aux()).collect(), (0..want_r).map(|_| self.next_aux()).collect()),
|
|
};
|
|
let map = |ids: &[u32]| {
|
|
o(vec![(
|
|
"entries",
|
|
arr(ids.iter().enumerate().map(|(i, t)| o(vec![("id", guid(AUX, *t)), ("position", s(&position(i)))])).collect()),
|
|
)])
|
|
};
|
|
f.extend([("gridColumnGap", fl(l.gap)), ("gridRowGap", fl(l.cross_gap)), ("gridColumns", map(&cols)), ("gridRows", map(&rows))]);
|
|
if l.column_tracks.iter().chain(&l.row_tracks).any(|t| t.sizing != Sizing::Fill) {
|
|
self.warn("grid tracks of fixed or content size were written as equal tracks");
|
|
}
|
|
self.tracks.insert(key, (cols, rows));
|
|
} else {
|
|
let spread = l.content_align == ContentAlign::SpaceBetween;
|
|
f.extend([
|
|
("stackSpacing", fl(l.gap)),
|
|
("stackCounterSpacing", fl(l.cross_gap)),
|
|
("stackCounterAlignContent", e(if spread { "SPACE_BETWEEN" } else { "AUTO" })),
|
|
]);
|
|
}
|
|
}
|
|
|
|
/// How a layer sizes and sits in its auto layout parent. Min/max sizes are the layer's own
|
|
/// and are written whatever its parent is.
|
|
fn child_layout(&mut self, n: &Node, parent: Option<&Node>, f: &mut Fields) {
|
|
let cl = &n.child_layout;
|
|
for (key, w, h) in [("minSize", cl.min_w, cl.min_h), ("maxSize", cl.max_w, cl.max_h)] {
|
|
if w.is_some() || h.is_some() {
|
|
f.push((key, o(vec![("value", xy(w.unwrap_or(0.0), h.unwrap_or(0.0)))])));
|
|
}
|
|
}
|
|
let Some(pl) = parent.and_then(|p| p.layout.as_ref()) else { return };
|
|
let (fill_h, fill_v) = (cl.sizing_h == Sizing::Fill, cl.sizing_v == Sizing::Fill);
|
|
let (grow, stretch) = if pl.mode == LayoutMode::Vertical { (fill_v, fill_h) } else { (fill_h, fill_v) };
|
|
if grow {
|
|
f.push(("stackChildPrimaryGrow", fl(1.0)));
|
|
}
|
|
if stretch {
|
|
f.push(("stackChildAlignSelf", e("STRETCH")));
|
|
}
|
|
if cl.absolute {
|
|
f.push(("stackPositioning", e("ABSOLUTE")));
|
|
}
|
|
if pl.mode == LayoutMode::Grid
|
|
&& let Some((cols, rows)) = parent.and_then(|p| self.tracks.get(&self.main_layer(p.id)))
|
|
{
|
|
let anchor = |ids: &[u32], i: Option<u32>| i.and_then(|i| ids.get(i as usize)).map(|t| guid(AUX, *t));
|
|
let (c, r) = (anchor(cols, cl.grid_column), anchor(rows, cl.grid_row));
|
|
f.extend(c.map(|g| ("gridColumnAnchor", g)));
|
|
f.extend(r.map(|g| ("gridRowAnchor", g)));
|
|
if cl.grid_column_span > 0 {
|
|
f.push(("gridColumnSpan", int(cl.grid_column_span.into())));
|
|
}
|
|
if cl.grid_row_span > 0 {
|
|
f.push(("gridRowSpan", int(cl.grid_row_span.into())));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Text: its style, box settings, and characters with their styled runs. `fills`: the layer's
|
|
/// (what runs without fills of their own show when the text's own style sets other fills).
|
|
fn text(&mut self, td: &TextData, fills: &[Paint], f: &mut Fields) {
|
|
style_fields(&td.style, f);
|
|
let (ha, va) = (
|
|
match td.align_h {
|
|
TextAlignH::Left => "LEFT",
|
|
TextAlignH::Center => "CENTER",
|
|
TextAlignH::Right => "RIGHT",
|
|
TextAlignH::Justified => "JUSTIFIED",
|
|
},
|
|
match td.align_v {
|
|
TextAlignV::Top => "TOP",
|
|
TextAlignV::Middle => "CENTER",
|
|
TextAlignV::Bottom => "BOTTOM",
|
|
},
|
|
);
|
|
let resize = match td.auto_resize {
|
|
TextAutoResize::WidthAndHeight => "WIDTH_AND_HEIGHT",
|
|
TextAutoResize::Height => "HEIGHT",
|
|
TextAutoResize::None | TextAutoResize::Truncate => "NONE",
|
|
};
|
|
f.extend([
|
|
("textAlignHorizontal", e(ha)),
|
|
("textAlignVertical", e(va)),
|
|
("textAutoResize", e(resize)),
|
|
("paragraphSpacing", fl(td.paragraph_spacing)),
|
|
("paragraphIndent", fl(td.paragraph_indent)),
|
|
("autoRename", b(false)),
|
|
("fontVariantCommonLigatures", b(true)),
|
|
("fontVariantContextualLigatures", b(true)),
|
|
("fontVersion", s("")),
|
|
("textUserLayoutVersion", u(5)),
|
|
("textExplicitLayoutVersion", u(1)),
|
|
("textBidiVersion", u(1)),
|
|
("textTracking", fl(0.0)),
|
|
("textDecorationSkipInk", b(true)),
|
|
("emojiImageSet", e("APPLE")),
|
|
]);
|
|
if td.auto_resize == TextAutoResize::Truncate {
|
|
f.push(("textTruncation", e("ENDING")));
|
|
}
|
|
if td.max_lines > 0 {
|
|
f.push(("maxLines", int(td.max_lines.into())));
|
|
}
|
|
// Styles per UTF-16 unit: 0 for the base style, else an entry of the override table.
|
|
if td.char_count() > MAX_CHARS {
|
|
self.warn("text longer than 1,048,576 characters was cut");
|
|
}
|
|
let spans = td.spans();
|
|
let mut table: Vec<&TextStyle> = Vec::new();
|
|
let mut span_ids = Vec::with_capacity(spans.len());
|
|
for (_, _, st) in &spans {
|
|
span_ids.push(if **st == td.style {
|
|
0
|
|
} else {
|
|
let i = table.iter().position(|t| *t == *st).unwrap_or_else(|| {
|
|
table.push(st);
|
|
table.len() - 1
|
|
});
|
|
i as u32 + 1
|
|
});
|
|
}
|
|
let mut chars = String::new();
|
|
let mut ids: Vec<Kv> = Vec::new();
|
|
let mut span = 0;
|
|
for (i, ch) in td.characters.chars().take(MAX_CHARS).enumerate() {
|
|
while spans.get(span).is_some_and(|sp| i >= sp.1) {
|
|
span += 1;
|
|
}
|
|
// NULs can't be stored in a string.
|
|
if ch == '\0' {
|
|
continue;
|
|
}
|
|
chars.push(ch);
|
|
let id = span_ids.get(span).copied().unwrap_or(0);
|
|
ids.extend((0..ch.len_utf16()).map(|_| u(id)));
|
|
}
|
|
let mut data: Fields = vec![("characters", Kv::Str(chars))];
|
|
if !table.is_empty() {
|
|
let entries = table
|
|
.iter()
|
|
.zip(1u32..)
|
|
.map(|(st, id)| {
|
|
let mut ef: Fields = vec![("styleID", u(id))];
|
|
style_fields(st, &mut ef);
|
|
// An empty link clears the text's own (a missing one would inherit it).
|
|
if st.link.is_none() && td.style.link.is_some() {
|
|
ef.push(("hyperlink", o(vec![("url", s(""))])));
|
|
}
|
|
if let Some(p) = st.fills.as_deref().or(td.style.fills.as_ref().map(|_| fills)) {
|
|
ef.push(("fillPaints", self.paints(p, true, &Bound::default())));
|
|
}
|
|
o(ef)
|
|
})
|
|
.collect();
|
|
data.extend([("characterStyleIDs", arr(ids)), ("styleOverrideTable", arr(entries))]);
|
|
}
|
|
let lists: Vec<ListStyle> = (0..td.paragraph_count()).map(|p| td.para_list(p).list).collect();
|
|
// One entry per paragraph, each with every field a reader expects.
|
|
let line = |(i, l): (usize, &ListStyle)| {
|
|
let ty = match l {
|
|
ListStyle::None => "PLAIN",
|
|
ListStyle::Numbered => "ORDERED_LIST",
|
|
ListStyle::Bulleted => "UNORDERED_LIST",
|
|
};
|
|
let listed = *l != ListStyle::None;
|
|
let first = listed && (i == 0 || lists.get(i - 1) != Some(l));
|
|
o(vec![
|
|
("lineType", e(ty)),
|
|
("styleId", int(0)),
|
|
("indentationLevel", int(i64::from(listed))),
|
|
("sourceDirectionality", e("AUTO")),
|
|
("listStartOffset", int(0)),
|
|
("isFirstLineOfList", b(first)),
|
|
])
|
|
};
|
|
data.push(("lines", arr(lists.iter().enumerate().map(line).collect())));
|
|
f.push(("textData", o(data)));
|
|
if (0..td.paragraph_count()).any(|p| td.para_list(p).indent > 0) {
|
|
self.warn("nested list levels were written as the first level");
|
|
}
|
|
let styles = std::iter::once(&td.style).chain(td.runs.iter().map(|r| &r.style));
|
|
if styles.clone().any(|st| st.decoration_look.is_some() || !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.list_spacing != 0.0 || td.hanging_punctuation || td.hanging_list || td.leading_trim != Default::default() || !td.features.is_empty() {
|
|
self.warn("list spacing, hanging punctuation, leading trim and OpenType features were left out");
|
|
}
|
|
}
|
|
|
|
/// The editable network (with per-point corner radii, handle mirroring and end caps) and,
|
|
/// when it has filled areas, their outline.
|
|
fn vector(&mut self, n: &Node, net: &VectorNetwork, f: &mut Fields) {
|
|
let entries: usize = net.regions.iter().flat_map(|r| &r.loops).map(Vec::len).sum();
|
|
if net.vertices.len() + net.segments.len() + entries > MAX_NETWORK {
|
|
self.warn("vector networks too large for the format were written as outlines");
|
|
} else {
|
|
// The stroke starts at the first end point and stops at the last: the layer's end caps go
|
|
// there (where the point has none of its own).
|
|
let mut degree = vec![0usize; net.vertices.len()];
|
|
for sg in &net.segments {
|
|
for i in [sg.a, sg.b] {
|
|
if let Some(d) = degree.get_mut(i) {
|
|
*d += 1;
|
|
}
|
|
}
|
|
}
|
|
let ends: Vec<usize> = (0..degree.len()).filter(|i| degree.get(*i) == Some(&1)).collect();
|
|
let (first, last) = (ends.first().copied(), ends.last().copied());
|
|
let caps_differ = n.stroke.cap_start != n.stroke.cap_end || net.vertices.iter().any(|v| v.cap.is_some());
|
|
let mut styles: Vec<Fields> = Vec::new();
|
|
let mut style_of = |fields: Fields| -> u32 {
|
|
if fields.is_empty() {
|
|
return 0;
|
|
}
|
|
let i = styles.iter().position(|x| *x == fields).unwrap_or_else(|| {
|
|
styles.push(fields);
|
|
styles.len() - 1
|
|
});
|
|
i as u32 + 1
|
|
};
|
|
let vertices = net
|
|
.vertices
|
|
.iter()
|
|
.enumerate()
|
|
.map(|(i, v)| {
|
|
let mut st: Fields = Vec::new();
|
|
if v.radius > 0.0 {
|
|
st.push(("cornerRadius", fl(v.radius)));
|
|
}
|
|
if let Some(m) = v.mirror {
|
|
st.push((
|
|
"handleMirroring",
|
|
e(match m {
|
|
figcraft_doc::HandleMirroring::None => "NONE",
|
|
figcraft_doc::HandleMirroring::Angle => "ANGLE",
|
|
figcraft_doc::HandleMirroring::AngleAndLength => "ANGLE_AND_LENGTH",
|
|
}),
|
|
));
|
|
}
|
|
let end_cap = if Some(i) == first {
|
|
Some(n.stroke.cap_start)
|
|
} else if Some(i) == last {
|
|
Some(n.stroke.cap_end)
|
|
} else {
|
|
None
|
|
};
|
|
if let Some(c) = v.cap.or(end_cap.filter(|_| caps_differ)) {
|
|
st.push(("strokeCap", e(cap_name(c))));
|
|
}
|
|
if let Some(j) = v.join {
|
|
st.push(("strokeJoin", e(join_name(j))));
|
|
}
|
|
network::Vertex { style: style_of(st), x: finite(v.x), y: finite(v.y) }
|
|
})
|
|
.collect();
|
|
let segments = net
|
|
.segments
|
|
.iter()
|
|
.map(|sg| network::Segment { a: sg.a, ta: (finite(sg.ta.0), finite(sg.ta.1)), b: sg.b, tb: (finite(sg.tb.0), finite(sg.tb.1)) })
|
|
.collect();
|
|
let regions = net
|
|
.regions
|
|
.iter()
|
|
.map(|r| network::Region { style: 0, non_zero: r.winding == WindingRule::NonZero, loops: r.loops.clone() })
|
|
.collect();
|
|
let blob = network::encode(&network::Network { vertices, segments, regions });
|
|
let table = styles.into_iter().zip(1u32..).map(|(mut st, id)| {
|
|
st.insert(0, ("styleID", u(id)));
|
|
o(st)
|
|
});
|
|
let table: Vec<Kv> = table.collect();
|
|
if let Some(i) = self.blob(blob) {
|
|
f.push((
|
|
"vectorData",
|
|
o(vec![("vectorNetworkBlob", u(i)), ("normalizedSize", xy(n.width, n.height)), ("styleOverrideTable", arr(table))]),
|
|
));
|
|
}
|
|
}
|
|
if !net.regions.is_empty() {
|
|
let winding = net.regions.first().map(|r| r.winding).unwrap_or_default();
|
|
if net.regions.iter().any(|r| r.winding != winding) {
|
|
self.warn("vectors whose filled areas use different winding rules use the first one's in their outline");
|
|
}
|
|
self.geometry("fillGeometry", &net.fill_path(), winding, f);
|
|
}
|
|
}
|
|
|
|
/// `fillGeometry` or `strokeGeometry` (`key`) from a local path.
|
|
fn geometry(&mut self, key: &'static str, p: &BezPath, winding: WindingRule, f: &mut Fields) {
|
|
if p.elements().is_empty() {
|
|
return;
|
|
}
|
|
if let Some(i) = self.blob(path_blob(p)) {
|
|
let rule = if winding == WindingRule::EvenOdd { "ODD" } else { "NONZERO" };
|
|
f.push((key, arr(vec![o(vec![("windingRule", e(rule)), ("commandsBlob", u(i)), ("styleID", u(0))])])));
|
|
}
|
|
}
|
|
|
|
/// `strokeGeometry`, the outline of a plain stroke: a ring around boxes and whole ellipses, the
|
|
/// widened path of other centred strokes. Dashed, per-side and other strokes get none (a reader
|
|
/// builds theirs from the stroke settings).
|
|
fn stroke_geometry(&mut self, n: &Node, boxy: bool, f: &mut Fields) {
|
|
let sp = &n.stroke;
|
|
let (w, h, weight) = (n.width, n.height, sp.weight);
|
|
let plain = n.strokes.iter().any(|p| p.visible) && sp.dashes.is_empty() && sp.sides.is_none() && sp.profile().is_none() && sp.brush.is_none();
|
|
if !plain || !(weight.is_finite() && weight > 0.0 && w.is_finite() && h.is_finite()) {
|
|
return;
|
|
}
|
|
let whole = matches!(n.kind, NodeKind::Ellipse { sweep, inner, .. } if inner == 0.0 && sweep.abs() >= std::f64::consts::TAU - 1e-9);
|
|
if boxy || whole {
|
|
let (out, inset) = match sp.align {
|
|
StrokeAlign::Inside => (0.0, weight),
|
|
StrokeAlign::Center => (weight / 2.0, weight / 2.0),
|
|
StrokeAlign::Outside => (weight, 0.0),
|
|
};
|
|
// The shape grown by `d` (shrunk when negative), or nothing when it shrinks away.
|
|
let grown = |d: f64| -> Option<BezPath> {
|
|
let (gw, gh) = (w + 2.0 * d, h + 2.0 * d);
|
|
if gw <= 0.0 || gh <= 0.0 {
|
|
return None;
|
|
}
|
|
let mut p = if whole {
|
|
figcraft_doc::geom::ellipse(gw, gh, 0.0, std::f64::consts::TAU, 0.0)
|
|
} else {
|
|
let radii = n.corners.radii.map(|r| if r > 0.0 { (r + d).max(0.0) } else { 0.0 });
|
|
figcraft_doc::geom::rounded_rect(gw, gh, radii, n.corners.smoothing)
|
|
};
|
|
p.apply_affine(Affine::translate((-d, -d)));
|
|
Some(p)
|
|
};
|
|
let Some(mut ring) = grown(out) else { return };
|
|
ring.extend(grown(-inset).iter().flat_map(|p| p.elements().iter().copied()));
|
|
self.geometry("strokeGeometry", &ring, WindingRule::EvenOdd, f);
|
|
} else if sp.align == StrokeAlign::Center {
|
|
let path = match &n.kind {
|
|
NodeKind::Vector { network } => Some(network.stroke_path()),
|
|
NodeKind::Text(_) => None,
|
|
_ => figcraft_doc::geometry::shape_path(n),
|
|
};
|
|
let Some(path) = path.filter(|p| !p.elements().is_empty()) else { return };
|
|
use figcraft_doc::geom::kurbo::{Cap, Join, Stroke, StrokeOpts, stroke};
|
|
let cap = match sp.cap_start {
|
|
StrokeCap::Round => Cap::Round,
|
|
StrokeCap::Square => Cap::Square,
|
|
_ => Cap::Butt,
|
|
};
|
|
let join = match sp.join {
|
|
StrokeJoin::Miter => Join::Miter,
|
|
StrokeJoin::Bevel => Join::Bevel,
|
|
StrokeJoin::Round => Join::Round,
|
|
};
|
|
let limit = if sp.miter_limit.is_finite() { sp.miter_limit.max(1.0) } else { 4.0 };
|
|
let style = Stroke::new(weight).with_caps(cap).with_join(join).with_miter_limit(limit);
|
|
self.geometry("strokeGeometry", &stroke(path, &style, &StrokeOpts::default(), 0.05), WindingRule::NonZero, f);
|
|
}
|
|
}
|
|
|
|
/// Add a blob; its index (`None` once the blobs would make the file too large).
|
|
fn blob(&mut self, bytes: Vec<u8>) -> Option<u32> {
|
|
if let Some(i) = self.blobs.get(&bytes) {
|
|
return Some(*i);
|
|
}
|
|
self.blob_bytes += bytes.len() as u64;
|
|
if self.blob_bytes > MAX_CANVAS {
|
|
self.warn("vector data too large for the format was left out");
|
|
return None;
|
|
}
|
|
let i = u32::try_from(self.blobs.len()).ok()?;
|
|
self.blobs.insert(bytes, i);
|
|
Some(i)
|
|
}
|
|
|
|
/// A component property definition (variant properties are implied by the variants' names).
|
|
fn prop_def(&mut self, name: &str, d: &PropDef) -> Option<Kv<'static>> {
|
|
let ty = prop_type(d)?;
|
|
let id = *self.defs.get(&(name.to_string(), ty))?;
|
|
let value = match d {
|
|
PropDef::Boolean { default } => o(vec![("boolValue", b(*default))]),
|
|
PropDef::Text { default } => o(vec![("textValue", o(vec![("characters", s(default))]))]),
|
|
PropDef::InstanceSwap { default, preferred } => {
|
|
if !preferred.is_empty() {
|
|
self.warn("preferred values of instance swap properties were left out");
|
|
}
|
|
o(vec![("guidValue", self.guid_of(*default)?)])
|
|
}
|
|
PropDef::Variant { .. } | PropDef::Slot { .. } => return None,
|
|
};
|
|
Some(o(vec![("id", guid(AUX, id)), ("name", s(name)), ("initialValue", value), ("type", e(ty))]))
|
|
}
|
|
|
|
/// Which property controls a layer's `field`.
|
|
fn prop_ref(&mut self, field: &str, prop: &str) -> Option<Kv<'static>> {
|
|
let (var_field, ty, resolved) = match field {
|
|
"visible" => ("VISIBLE", "BOOL", "BOOLEAN"),
|
|
"characters" => ("TEXT_DATA", "TEXT", "TEXT_DATA"),
|
|
"mainComponent" => ("OVERRIDDEN_SYMBOL_ID", "INSTANCE_SWAP", "SYMBOL_ID"),
|
|
_ => {
|
|
self.warn("slot layers were written as plain layers");
|
|
return None;
|
|
}
|
|
};
|
|
let id = *self.defs.get(&(prop.to_string(), ty))?;
|
|
let data = o(vec![
|
|
("value", o(vec![("propRefValue", o(vec![("defId", guid(AUX, id))]))])),
|
|
("dataType", e("PROP_REF")),
|
|
("resolvedDataType", e(resolved)),
|
|
]);
|
|
Some(o(vec![("variableData", data), ("variableField", e(var_field))]))
|
|
}
|
|
|
|
/// An instance: its main, the fields it and its layers override, the size, place and outline
|
|
/// its layers get from that (derived data), its property values. `f`: its own fields so far.
|
|
fn instance(&mut self, n: &Node, main: NodeId, props: &BTreeMap<String, Value>, f: &mut Fields) {
|
|
const OWN: [&str; 7] = ["guid", "phase", "parentIndex", "type", "transform", "fillGeometry", "strokeGeometry"];
|
|
let doc = self.doc;
|
|
let (Some(m), Some(symbol)) = (doc.node(main), self.guid_of(main)) else { return };
|
|
// What the instance itself changes from its main (its size, its paints, …) is an override
|
|
// addressed by the main's id: a reader takes everything else from the main. Where it sits
|
|
// is its own.
|
|
let mut root_theirs = Vec::new();
|
|
self.layer(m, m.parent.and_then(|p| doc.node(p)), &mut root_theirs, true);
|
|
root_theirs.retain(|(k, _)| !OWN.contains(k));
|
|
// An instance is named after its component (the set, for a variant) until renamed.
|
|
let set = m.parent.and_then(|p| doc.node(p)).filter(|p| matches!(p.kind, NodeKind::ComponentSet { .. }));
|
|
let named = set.is_none_or(|s| s.name != n.name);
|
|
let root_mine: Fields = f.iter().filter(|(k, _)| !OWN.contains(k) && (named || *k != "name")).cloned().collect();
|
|
// Each layer below: its id path, the fields that differ from the main's layer, that layer's
|
|
// fields, and the component a nested instance was swapped for.
|
|
struct Row {
|
|
path: Kv<'static>,
|
|
changed: Fields,
|
|
theirs: Fields,
|
|
nested: bool,
|
|
swap: Option<Kv<'static>>,
|
|
}
|
|
let mut rows: Vec<Row> = Vec::new();
|
|
let mut stack: Vec<(NodeId, NodeId)> = n.children.iter().rev().map(|c| (*c, n.id)).collect();
|
|
let mut seen = 0usize;
|
|
while let Some((id, parent)) = stack.pop() {
|
|
let Some(d) = doc.node(id) else { continue };
|
|
seen += 1;
|
|
if seen > MAX_NODES {
|
|
break;
|
|
}
|
|
stack.extend(d.children.iter().rev().map(|c| (*c, id)));
|
|
let path = self.layer_path(d, n.id, main, 0);
|
|
let guids: Option<Vec<Kv>> = path.and_then(|p| p.iter().map(|x| self.guid_of(*x)).collect());
|
|
let (Some(guids), Some(src)) = (guids, d.source.and_then(|src| doc.node(src))) else {
|
|
self.warn("instance layers that don't come from their main component were left out");
|
|
continue;
|
|
};
|
|
let (mut mine, mut theirs) = (Vec::new(), Vec::new());
|
|
self.layer(d, doc.node(parent), &mut mine, true);
|
|
self.layer(src, src.parent.and_then(|p| doc.node(p)), &mut theirs, true);
|
|
// A nested instance swapped for another component.
|
|
let swap = match (&d.kind, &src.kind) {
|
|
(NodeKind::Instance { component, .. }, NodeKind::Instance { component: was, .. }) if component == was => None,
|
|
(NodeKind::Instance { component, .. }, _) => self.guid_of(*component),
|
|
_ => None,
|
|
};
|
|
let nested = matches!(d.kind, NodeKind::Instance { .. });
|
|
rows.push(Row { path: o(vec![("guids", arr(guids))]), changed: changed(mine, &theirs), theirs, nested, swap });
|
|
}
|
|
// An instance scaled as a whole (the Scale tool) is `factor` times its main in every length:
|
|
// sizes, places and stroke weights, its own and its layers'. A resized one keeps its weights.
|
|
let field = |fields: &Fields, key: &str| fields.iter().find(|(k, _)| *k == key).map(|(_, v)| v.clone());
|
|
let factor = Some(n.width / m.width).filter(|k| k.is_finite() && *k > 0.0 && (k - 1.0).abs() > 1e-6).filter(|k| {
|
|
let grown = |mine: &Fields, theirs: &Fields| {
|
|
let weight = field(theirs, "strokeWeight").and_then(|w| w.f64()).unwrap_or(0.0);
|
|
(weight == 0.0 || field(mine, "strokeWeight").is_some_and(|w| scaled(&w, &fl(weight), *k, 0.0)))
|
|
&& field(mine, "size").zip(field(theirs, "size")).is_some_and(|(a, b)| scaled(&a, &b, *k, 1.0))
|
|
&& field(mine, "transform").zip(field(theirs, "transform")).is_none_or(|(a, b)| scaled(&a, &b, *k, 1.0))
|
|
};
|
|
(n.height / m.height - k).abs() <= 1e-6 * k.max(1.0)
|
|
&& grown(&changed(root_mine.clone(), &root_theirs), &root_theirs)
|
|
&& rows.iter().all(|r| grown(&r.changed, &r.theirs))
|
|
});
|
|
// What follows from the overrides goes with the derived data: a layer's size, place and
|
|
// outline (a vector's network is the main's, drawn at the layer's size), the colours its
|
|
// variables give here, and what the scale factor makes of the main's values.
|
|
let follows = |k: &str, v: &Kv<'static>, theirs: &Fields| {
|
|
["size", "transform", "fillGeometry", "strokeGeometry", "vectorData"].contains(&k)
|
|
|| resolved_alike(k, v, theirs)
|
|
|| factor.is_some_and(|x| field(theirs, k).is_some_and(|t| scaled(v, &t, x, 0.0)))
|
|
};
|
|
let mut overrides = Vec::new();
|
|
let mut derived = Vec::new();
|
|
let mut of: Fields = vec![("guidPath", o(vec![("guids", arr(vec![symbol.clone()]))]))];
|
|
of.extend(changed(root_mine, &root_theirs).into_iter().filter(|(k, v)| *k == "size" || !follows(k, v, &root_theirs)));
|
|
if of.len() > 1 {
|
|
overrides.push(o(of));
|
|
}
|
|
for r in rows {
|
|
let (mut of, mut df): (Fields, Fields) = (vec![("guidPath", r.path.clone())], vec![("guidPath", r.path)]);
|
|
for (k, v) in r.changed {
|
|
let follows = follows(k, &v, &r.theirs);
|
|
// A nested instance's size is its own to set.
|
|
if follows && r.nested && k == "size" {
|
|
of.push((k, v.clone()));
|
|
}
|
|
if follows { &mut df } else { &mut of }.push((k, v));
|
|
}
|
|
if df.len() > 1 {
|
|
derived.push(o(df));
|
|
}
|
|
of.extend(r.swap.map(|g| ("overriddenSymbolID", g)));
|
|
if of.len() > 1 {
|
|
overrides.push(o(of));
|
|
}
|
|
}
|
|
f.push(("symbolData", o(vec![("symbolID", symbol), ("symbolOverrides", arr(overrides)), ("uniformScaleFactor", fl(factor.unwrap_or(1.0)))])));
|
|
if !derived.is_empty() {
|
|
f.push(("derivedSymbolData", arr(derived)));
|
|
}
|
|
let mut assignments = Vec::new();
|
|
for (name, v) in props {
|
|
let (ty, value) = match v {
|
|
Value::Bool(x) => ("BOOL", Some(o(vec![("boolValue", b(*x))]))),
|
|
Value::String(t) => ("TEXT", Some(o(vec![("textValue", o(vec![("characters", s(t))]))]))),
|
|
Value::Number(c) => ("INSTANCE_SWAP", c.as_u64().and_then(|c| self.guid_of(NodeId(c))).map(|g| o(vec![("guidValue", g)]))),
|
|
_ => continue,
|
|
};
|
|
// Variant values have no definition of their own: the main they show says them.
|
|
if let (Some(&id), Some(value)) = (self.defs.get(&(name.clone(), ty)), value) {
|
|
assignments.push(o(vec![("defID", guid(AUX, id)), ("value", value)]));
|
|
}
|
|
}
|
|
if !assignments.is_empty() {
|
|
f.push(("componentPropAssignments", arr(assignments)));
|
|
}
|
|
if n.children.iter().filter_map(|c| doc.node(*c)).any(|c| c.source.is_none()) {
|
|
self.warn("instance layers that don't come from their main component were left out");
|
|
}
|
|
}
|
|
|
|
/// The main component layer an instance or instance layer mirrors (through nested instances),
|
|
/// or `id` itself.
|
|
fn main_layer(&self, id: NodeId) -> NodeId {
|
|
let mut cur = id;
|
|
for _ in 0..32 {
|
|
let next = self.doc.node(cur).and_then(|n| match &n.kind {
|
|
_ if n.source.is_some() => n.source,
|
|
NodeKind::Instance { component, .. } => Some(*component),
|
|
_ => None,
|
|
});
|
|
match next.filter(|s| self.doc.contains(*s)) {
|
|
Some(s) => cur = s,
|
|
None => break,
|
|
}
|
|
}
|
|
cur
|
|
}
|
|
|
|
/// The id path of layer `d` of instance `inst` (of `main`): that of the main's layer it mirrors,
|
|
/// or, inside a nested instance swapped for another component, the path of that instance and
|
|
/// then the one inside its new main.
|
|
fn layer_path(&self, d: &Node, inst: NodeId, main: NodeId, depth: usize) -> Option<Vec<NodeId>> {
|
|
let src = d.source?;
|
|
if let Some(p) = self.path_in(src, main, 0) {
|
|
return Some(p);
|
|
}
|
|
if depth > 32 {
|
|
return None;
|
|
}
|
|
let doc = self.doc;
|
|
let nested = doc.ancestors(d.id).into_iter().take_while(|a| *a != inst).filter_map(|a| doc.node(a)).find_map(|a| match &a.kind {
|
|
NodeKind::Instance { component, .. } => Some((a, *component)),
|
|
_ => None,
|
|
});
|
|
let (outer, component) = nested?;
|
|
let mut p = self.layer_path(outer, inst, main, depth + 1)?;
|
|
p.extend(self.path_in(src, component, 0)?);
|
|
Some(p)
|
|
}
|
|
|
|
/// The id path of layer `s` inside component `comp`: `s` itself, or through the nested
|
|
/// instance it is expanded in, then on inside that instance's main.
|
|
fn path_in(&self, s: NodeId, comp: NodeId, depth: usize) -> Option<Vec<NodeId>> {
|
|
if depth > 32 {
|
|
return None;
|
|
}
|
|
let doc = self.doc;
|
|
let up = doc.ancestors(s);
|
|
let below: Vec<NodeId> = up.iter().take_while(|a| **a != comp).copied().collect();
|
|
if below.len() == up.len() {
|
|
return None;
|
|
}
|
|
// The outermost nested instance between the component and the layer.
|
|
match below.iter().rev().find_map(|a| match doc.node(*a).map(|n| &n.kind) {
|
|
Some(NodeKind::Instance { component, .. }) => Some((*a, *component)),
|
|
_ => None,
|
|
}) {
|
|
None => Some(vec![s]),
|
|
Some((inst, main)) => {
|
|
let mut p = vec![inst];
|
|
p.extend(self.path_in(doc.node(s)?.source?, main, depth + 1)?);
|
|
Some(p)
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Interactions, scrolling, flow starts and the overlay settings this layer is opened with.
|
|
fn prototype(&mut self, n: &Node, f: &mut Fields) {
|
|
let list: Vec<Kv> = n.interactions.iter().filter_map(|it| self.interaction(it)).collect();
|
|
if !list.is_empty() {
|
|
f.push(("prototypeInteractions", arr(list)));
|
|
}
|
|
let dir = match n.overflow {
|
|
Overflow::None => None,
|
|
Overflow::Horizontal => Some("HORIZONTAL"),
|
|
Overflow::Vertical => Some("VERTICAL"),
|
|
Overflow::Both => Some("BOTH"),
|
|
};
|
|
f.extend(dir.map(|d| ("scrollDirection", e(d))));
|
|
let behavior = match n.scroll_position {
|
|
ScrollPosition::Scrolls => None,
|
|
ScrollPosition::Fixed => Some("FIXED_WHEN_CHILD_OF_SCROLLING_FRAME"),
|
|
ScrollPosition::Sticky => Some("STICKY_SCROLLS"),
|
|
};
|
|
f.extend(behavior.map(|x| ("scrollBehavior", e(x))));
|
|
if let Some((i, name)) = self.starts.get(&n.id) {
|
|
f.push(("prototypeStartingPoint", o(vec![("name", s(name)), ("position", s(&position(*i)))])));
|
|
}
|
|
if let Some(ov) = self.overlays.get(&n.id) {
|
|
const POSITIONS: [&str; 8] = ["CENTER", "TOP_LEFT", "TOP_CENTER", "TOP_RIGHT", "BOTTOM_LEFT", "BOTTOM_CENTER", "BOTTOM_RIGHT", "MANUAL"];
|
|
let pos = POSITIONS.into_iter().find(|p| crate::rest::proto::overlay_position(p) == Some(ov.position)).unwrap_or("CENTER");
|
|
let bg = match ov.background {
|
|
Some(c) => o(vec![("backgroundType", e("SOLID_COLOR")), ("backgroundColor", color(c))]),
|
|
None => o(vec![("backgroundType", e("NONE"))]),
|
|
};
|
|
f.extend([
|
|
("overlayPositionType", e(pos)),
|
|
("overlayBackgroundInteraction", e(if ov.close_on_outside { "CLOSE_ON_CLICK_OUTSIDE" } else { "NONE" })),
|
|
("overlayBackgroundAppearance", bg),
|
|
]);
|
|
}
|
|
}
|
|
|
|
fn interaction(&mut self, it: &Interaction) -> Option<Kv<'static>> {
|
|
let mut event: Fields = Vec::new();
|
|
let ty = match &it.trigger {
|
|
Trigger::OnClick => "ON_CLICK",
|
|
Trigger::OnHover => "ON_HOVER",
|
|
Trigger::OnPress => "ON_PRESS",
|
|
Trigger::OnDrag => "DRAG",
|
|
Trigger::MouseEnter => "MOUSE_IN",
|
|
Trigger::MouseLeave => "MOUSE_OUT",
|
|
Trigger::MouseDown => "MOUSE_DOWN",
|
|
Trigger::MouseUp => "MOUSE_UP",
|
|
Trigger::AfterDelay { ms } => {
|
|
event.push(("transitionTimeout", fl(f64::from(*ms) / 1000.0)));
|
|
"AFTER_TIMEOUT"
|
|
}
|
|
Trigger::KeyPress { key } => {
|
|
let Some((codes, pad)) = key_codes(key) else {
|
|
self.warn("key triggers on keys the format has no code for were left out");
|
|
return None;
|
|
};
|
|
let device = e(if pad { "UNKNOWN_CONTROLLER" } else { "KEYBOARD" });
|
|
event.push(("keyTrigger", o(vec![("keyCodes", arr(codes.into_iter().map(int).collect())), ("triggerDevice", device)])));
|
|
"ON_KEY_DOWN"
|
|
}
|
|
};
|
|
// A mouse trigger's delay is the event's timeout.
|
|
if it.delay_secs() > 0.0 {
|
|
event.push(("transitionTimeout", fl(it.delay_secs())));
|
|
}
|
|
event.insert(0, ("interactionType", e(ty)));
|
|
let actions: Vec<Kv> = it.actions.iter().filter_map(|a| self.action(a, it)).collect();
|
|
(!actions.is_empty()).then(|| o(vec![("event", o(event)), ("actions", arr(actions))]))
|
|
}
|
|
|
|
fn action(&mut self, a: &Action, it: &Interaction) -> Option<Kv<'static>> {
|
|
let node = |x: &mut Self, dest: &NodeId, nav: &'static str| -> Option<Kv<'static>> {
|
|
let Some(g) = x.guid_of(*dest) else {
|
|
x.warn("prototype actions whose destination isn't written were left out");
|
|
return None;
|
|
};
|
|
let mut f: Fields = vec![("transitionNodeID", g), ("connectionType", e("INTERNAL_NODE")), ("navigationType", e(nav))];
|
|
x.transition(it, &mut f);
|
|
Some(o(f))
|
|
};
|
|
let plain = |ty: &'static str| Some(o(vec![("connectionType", e(ty))]));
|
|
match a {
|
|
Action::Navigate { dest, preserve_scroll } => {
|
|
let mut act = node(self, dest, "NAVIGATE")?;
|
|
if let Kv::Object(f) = &mut act {
|
|
f.push(("transitionPreserveScroll", b(*preserve_scroll)));
|
|
}
|
|
Some(act)
|
|
}
|
|
Action::OpenOverlay { dest, position, offset, .. } => {
|
|
let mut act = node(self, dest, "OVERLAY")?;
|
|
if let (Kv::Object(f), OverlayPosition::Manual, Some([x, y])) = (&mut act, position, offset) {
|
|
f.push(("overlayRelativePosition", o(vec![("x", fl(*x)), ("y", fl(*y))])));
|
|
}
|
|
Some(act)
|
|
}
|
|
Action::SwapOverlay { dest } => node(self, dest, "SWAP"),
|
|
Action::ChangeTo { dest } => node(self, dest, "SWAP_STATE"),
|
|
Action::ScrollTo { dest, offset } => {
|
|
if *offset != [0.0, 0.0] {
|
|
self.warn("scroll-to offsets were left out");
|
|
}
|
|
node(self, dest, "SCROLL_TO")
|
|
}
|
|
Action::Back => plain("BACK"),
|
|
Action::CloseOverlay => plain("CLOSE"),
|
|
Action::OpenUrl { url } => Some(o(vec![("connectionType", e("URL")), ("connectionURL", s(url))])),
|
|
Action::SetVariable { .. } | Action::SetVariableMode { .. } | Action::Conditional { .. } => {
|
|
self.warn("variable and conditional prototype actions were left out");
|
|
None
|
|
}
|
|
}
|
|
}
|
|
|
|
/// An interaction's transition on one of its actions.
|
|
fn transition(&mut self, it: &Interaction, f: &mut Fields) {
|
|
let side_from = |d: Direction, l: &'static str, r: &'static str, t: &'static str, bo: &'static str| match d {
|
|
// The direction names where the incoming screen moves: it comes from the other side.
|
|
Direction::Right => l,
|
|
Direction::Left => r,
|
|
Direction::Bottom => t,
|
|
Direction::Top => bo,
|
|
};
|
|
let side_to = |d: Direction, l: &'static str, r: &'static str, t: &'static str, bo: &'static str| match d {
|
|
Direction::Left => l,
|
|
Direction::Right => r,
|
|
Direction::Top => t,
|
|
Direction::Bottom => bo,
|
|
};
|
|
let ty = match it.transition {
|
|
Transition::Instant => "INSTANT_TRANSITION",
|
|
Transition::Dissolve => "DISSOLVE",
|
|
Transition::SmartAnimate => "SMART_ANIMATE",
|
|
Transition::SlideIn { direction } => side_from(direction, "SLIDE_FROM_LEFT", "SLIDE_FROM_RIGHT", "SLIDE_FROM_TOP", "SLIDE_FROM_BOTTOM"),
|
|
Transition::Push { direction } => side_from(direction, "PUSH_FROM_LEFT", "PUSH_FROM_RIGHT", "PUSH_FROM_TOP", "PUSH_FROM_BOTTOM"),
|
|
Transition::MoveIn { direction } => side_from(direction, "MOVE_FROM_LEFT", "MOVE_FROM_RIGHT", "MOVE_FROM_TOP", "MOVE_FROM_BOTTOM"),
|
|
Transition::SlideOut { direction } => {
|
|
side_to(direction, "SLIDE_OUT_TO_LEFT", "SLIDE_OUT_TO_RIGHT", "SLIDE_OUT_TO_TOP", "SLIDE_OUT_TO_BOTTOM")
|
|
}
|
|
Transition::MoveOut { direction } => side_to(direction, "MOVE_OUT_TO_LEFT", "MOVE_OUT_TO_RIGHT", "MOVE_OUT_TO_TOP", "MOVE_OUT_TO_BOTTOM"),
|
|
};
|
|
let easing = match it.easing {
|
|
Easing::Linear => "LINEAR",
|
|
Easing::EaseIn => "IN_CUBIC",
|
|
Easing::EaseOut => "OUT_CUBIC",
|
|
Easing::EaseInOut => "INOUT_CUBIC",
|
|
Easing::EaseInBack => "IN_BACK_CUBIC",
|
|
Easing::EaseOutBack => "OUT_BACK_CUBIC",
|
|
Easing::EaseInOutBack => "INOUT_BACK_CUBIC",
|
|
Easing::Gentle => "GENTLE_SPRING",
|
|
Easing::CustomBezier { .. } => "CUSTOM_CUBIC",
|
|
Easing::Quick | Easing::Bouncy | Easing::Slow | Easing::CustomSpring { .. } => {
|
|
self.warn("spring animations other than Gentle were written as ease out");
|
|
"OUT_CUBIC"
|
|
}
|
|
};
|
|
f.extend([("transitionType", e(ty)), ("transitionDuration", fl(f64::from(it.duration_ms) / 1000.0)), ("easingType", e(easing))]);
|
|
if let Easing::CustomBezier { x1, y1, x2, y2 } = it.easing {
|
|
f.push(("easingFunction", arr(vec![fl(x1), fl(y1), fl(x2), fl(y2)])));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// The plugin id and key under which a layer written as an outline keeps what it was.
|
|
pub(super) const STASH: (&str, &str) = ("figcraft", "stroke");
|
|
/// Longest kept description of such a layer (bytes of JSON).
|
|
const MAX_STASH: usize = 1 << 20;
|
|
|
|
/// Whether a width profile reaches further on one side of the path than on the other.
|
|
fn one_sided(p: &figcraft_doc::WidthProfile) -> bool {
|
|
p.points.iter().any(|q| q.bias.abs() > 1e-6)
|
|
}
|
|
|
|
/// A shape whose stroke is wider on one side of its path, as the area that stroke paints (a vector
|
|
/// filled with the stroke's paints), with what it was as JSON: its kind, paints and stroke. Only
|
|
/// for shapes that show nothing but that stroke; `None` for every other layer.
|
|
fn outlined(n: &Node) -> Option<(Node, String)> {
|
|
let sp = &n.stroke;
|
|
let shape = matches!(
|
|
n.kind,
|
|
NodeKind::Line | NodeKind::Vector { .. } | NodeKind::Ellipse { .. } | NodeKind::Polygon { .. } | NodeKind::Star { .. } | NodeKind::Rectangle
|
|
);
|
|
let shown = |paints: &[Paint]| paints.iter().any(|p| p.visible);
|
|
if !shape
|
|
|| sp.brush.is_some()
|
|
|| !sp.profile().is_some_and(one_sided)
|
|
|| !(sp.weight.is_finite() && sp.weight > 0.0)
|
|
|| !shown(&n.strokes)
|
|
|| shown(&n.fills)
|
|
{
|
|
return None;
|
|
}
|
|
let path = figcraft_doc::geometry::stroke_geometry(n)?;
|
|
let net = match &n.kind {
|
|
NodeKind::Vector { network } => Some(network),
|
|
_ => None,
|
|
};
|
|
let area = figcraft_pathops::stroke_outline_of(&path, sp, figcraft_doc::geometry::is_closed(n), net);
|
|
if area.elements().is_empty() || area.elements().len() > MAX_NETWORK / 4 {
|
|
return None;
|
|
}
|
|
let original = serde_json::json!({"kind": n.kind, "fills": n.fills, "strokes": n.strokes, "stroke": n.stroke}).to_string();
|
|
if original.len() > MAX_STASH {
|
|
return None;
|
|
}
|
|
let mut network = VectorNetwork::from_path(&area);
|
|
for r in &mut network.regions {
|
|
r.winding = WindingRule::NonZero;
|
|
}
|
|
let mut v = n.clone();
|
|
v.kind = NodeKind::Vector { network };
|
|
v.fills = std::mem::take(&mut v.strokes);
|
|
v.stroke = Default::default();
|
|
v.styles.fill = v.styles.stroke.take();
|
|
// Bindings name the stroke's paints, which are the fills now: the values stay.
|
|
v.bound.retain(|k, _| !(k == "stroke" || k == "fill" || k.starts_with("strokes/") || k.starts_with("fills/") || k.starts_with("stroke")));
|
|
Some((v, original))
|
|
}
|
|
|
|
/// The number of the layer field a bound property (`VariableField`) is held in.
|
|
fn node_field(field: &str) -> Option<u32> {
|
|
let name = match field {
|
|
"WIDTH" | "HEIGHT" => "size",
|
|
"MIN_WIDTH" | "MIN_HEIGHT" => "minSize",
|
|
"MAX_WIDTH" | "MAX_HEIGHT" => "maxSize",
|
|
"STACK_SPACING" => "stackSpacing",
|
|
"STACK_COUNTER_SPACING" => "stackCounterSpacing",
|
|
"STACK_PADDING_LEFT" => "stackHorizontalPadding",
|
|
"STACK_PADDING_TOP" => "stackVerticalPadding",
|
|
"STACK_PADDING_RIGHT" => "stackPaddingRight",
|
|
"STACK_PADDING_BOTTOM" => "stackPaddingBottom",
|
|
"CORNER_RADIUS" => "cornerRadius",
|
|
"RECTANGLE_TOP_LEFT_CORNER_RADIUS" => "rectangleTopLeftCornerRadius",
|
|
"RECTANGLE_TOP_RIGHT_CORNER_RADIUS" => "rectangleTopRightCornerRadius",
|
|
"RECTANGLE_BOTTOM_LEFT_CORNER_RADIUS" => "rectangleBottomLeftCornerRadius",
|
|
"RECTANGLE_BOTTOM_RIGHT_CORNER_RADIUS" => "rectangleBottomRightCornerRadius",
|
|
"OPACITY" => "opacity",
|
|
"VISIBLE" => "visible",
|
|
"TEXT_DATA" => "textData",
|
|
"STROKE_WEIGHT" => "strokeWeight",
|
|
"BORDER_TOP_WEIGHT" => "borderTopWeight",
|
|
"BORDER_RIGHT_WEIGHT" => "borderRightWeight",
|
|
"BORDER_BOTTOM_WEIGHT" => "borderBottomWeight",
|
|
"BORDER_LEFT_WEIGHT" => "borderLeftWeight",
|
|
"FONT_SIZE" => "fontSize",
|
|
"FONT_FAMILY" | "FONT_STYLE" => "fontName",
|
|
"LETTER_SPACING" => "letterSpacing",
|
|
"LINE_HEIGHT" => "lineHeight",
|
|
"PARAGRAPH_SPACING" => "paragraphSpacing",
|
|
"PARAGRAPH_INDENT" => "paragraphIndent",
|
|
_ => return None,
|
|
};
|
|
// The numbers are the schema's.
|
|
let layer = SCHEMA.lines().find(|l| l.starts_with("message NodeChange "))?;
|
|
layer.split(", ").find_map(|f| f.rsplit_once(' ')?.1.strip_prefix(name)?.strip_prefix('=')?.parse().ok())
|
|
}
|
|
|
|
/// Whether `a` is `b` with its lengths scaled by `k`: every number is `k` times the other's (within
|
|
/// `slack`, for sizes that snap to whole pixels) or the same, and the rest is equal.
|
|
fn scaled(a: &Kv<'static>, b: &Kv<'static>, k: f64, slack: f64) -> bool {
|
|
match (a, b) {
|
|
(Kv::Float(x), Kv::Float(y)) => {
|
|
let (x, y) = (f64::from(*x), f64::from(*y));
|
|
x == y || (x - y * k).abs() <= slack + 1e-3 * x.abs().max(1.0)
|
|
}
|
|
(Kv::Array(x), Kv::Array(y)) => x.len() == y.len() && x.iter().zip(y).all(|(p, q)| scaled(p, q, k, slack)),
|
|
(Kv::Object(x), Kv::Object(y)) => x.len() == y.len() && x.iter().zip(y).all(|((kp, p), (kq, q))| kp == kq && scaled(p, q, k, slack)),
|
|
_ => a == b,
|
|
}
|
|
}
|
|
|
|
/// The fields of `mine` that differ from `theirs` (a layer and the main's layer it mirrors), and
|
|
/// the ones only `theirs` has at their empty values.
|
|
fn changed(mine: Fields, theirs: &Fields) -> Fields {
|
|
let cleared: Fields = theirs.iter().filter(|(k, _)| !mine.iter().any(|(mk, _)| mk == k)).filter_map(|(k, _)| Some((*k, unset(k)?))).collect();
|
|
let mut out: Fields = mine.into_iter().filter(|(k, v)| !theirs.iter().any(|(tk, tv)| tk == k && tv == v)).collect();
|
|
out.extend(cleared);
|
|
out
|
|
}
|
|
|
|
/// Whether paint list `v` (field `key`) is `theirs` but for the colours variables give: two layers
|
|
/// bound alike are the same, whatever mode each one shows.
|
|
fn resolved_alike(key: &str, v: &Kv<'static>, theirs: &Fields) -> bool {
|
|
fn unresolved(v: &Kv<'static>) -> Vec<Kv<'static>> {
|
|
let bare = |p: &Kv<'static>| match p {
|
|
Kv::Object(f) if f.iter().any(|(k, _)| *k == "colorVar") => o(f.iter().filter(|(k, _)| *k != "color").cloned().collect()),
|
|
other => other.clone(),
|
|
};
|
|
v.list().iter().map(bare).collect()
|
|
}
|
|
matches!(key, "fillPaints" | "strokePaints") && theirs.iter().any(|(k, t)| *k == key && unresolved(t) == unresolved(v))
|
|
}
|
|
|
|
/// The format's name of a variable type.
|
|
fn resolved_type(kind: VariableType) -> &'static str {
|
|
match kind {
|
|
VariableType::Color => "COLOR",
|
|
VariableType::Number => "FLOAT",
|
|
VariableType::String => "STRING",
|
|
VariableType::Boolean => "BOOLEAN",
|
|
}
|
|
}
|
|
|
|
/// The format's name of a variable scope (`None`: it has none).
|
|
fn scope_name(scope: &str) -> Option<&'static str> {
|
|
const NAMES: [&str; 20] = [
|
|
"ALL_SCOPES",
|
|
"TEXT_CONTENT",
|
|
"CORNER_RADIUS",
|
|
"WIDTH_HEIGHT",
|
|
"GAP",
|
|
"ALL_FILLS",
|
|
"FRAME_FILL",
|
|
"SHAPE_FILL",
|
|
"TEXT_FILL",
|
|
"STROKE_FLOAT",
|
|
"EFFECT_FLOAT",
|
|
"EFFECT_COLOR",
|
|
"OPACITY",
|
|
"FONT_STYLE",
|
|
"FONT_FAMILY",
|
|
"FONT_SIZE",
|
|
"LINE_HEIGHT",
|
|
"LETTER_SPACING",
|
|
"PARAGRAPH_SPACING",
|
|
"PARAGRAPH_INDENT",
|
|
];
|
|
if scope == "STROKE_COLOR" {
|
|
return Some("STROKE");
|
|
}
|
|
NAMES.into_iter().find(|n| *n == scope)
|
|
}
|
|
|
|
/// The empty value of a field only written when set (an override clears it with this).
|
|
fn unset(key: &str) -> Option<Kv<'static>> {
|
|
Some(match key {
|
|
"styleIdForFill" | "styleIdForStrokeFill" | "styleIdForEffect" | "styleIdForGrid" | "styleIdForText" => {
|
|
o(vec![("guid", guid(u32::MAX, u32::MAX))])
|
|
}
|
|
"variableConsumptionMap" | "variableModeBySetMap" => o(vec![("entries", arr(Vec::new()))]),
|
|
"mask" | "rectangleCornerRadiiIndependent" | "borderStrokeWeightsIndependent" => b(false),
|
|
"effects" | "dashPattern" | "layoutGrids" | "exportSettings" | "prototypeInteractions" | "fillGeometry" | "variableWidthPoints" => {
|
|
arr(Vec::new())
|
|
}
|
|
"cornerSmoothing" | "stackChildPrimaryGrow" => fl(0.0),
|
|
"stackMode" => e("NONE"),
|
|
"stackChildAlignSelf" | "stackPositioning" => e("AUTO"),
|
|
"minSize" | "maxSize" => o(vec![("value", xy(0.0, 0.0))]),
|
|
"gridColumnSpan" | "gridRowSpan" | "maxLines" => int(0),
|
|
"scrollDirection" => e("NONE"),
|
|
"scrollBehavior" => e("SCROLLS"),
|
|
"parameterConsumptionMap" => o(vec![("entries", arr(Vec::new()))]),
|
|
"textTruncation" => e("DISABLED"),
|
|
"hyperlink" => o(vec![("url", s(""))]),
|
|
_ => return None,
|
|
})
|
|
}
|
|
|
|
/// The format's type of a component property (`None`: not written).
|
|
fn prop_type(d: &PropDef) -> Option<&'static str> {
|
|
match d {
|
|
PropDef::Boolean { .. } => Some("BOOL"),
|
|
PropDef::Text { .. } => Some("TEXT"),
|
|
PropDef::InstanceSwap { .. } => Some("INSTANCE_SWAP"),
|
|
PropDef::Variant { .. } | PropDef::Slot { .. } => None,
|
|
}
|
|
}
|
|
|
|
/// The key codes of a key trigger (modifiers first), and whether it's a controller button.
|
|
fn key_codes(key: &str) -> Option<(Vec<i64>, bool)> {
|
|
if let Some(i) = GAMEPAD_BUTTONS.iter().position(|g| g.eq_ignore_ascii_case(key.trim())) {
|
|
return Some((vec![i as i64], true));
|
|
}
|
|
let (mods, k): (KeyMods, &str) = KeyMods::split(key);
|
|
let code = (0..=255).find(|c| crate::rest::proto::key_name(f64::from(*c)).is_some_and(|n| n.eq_ignore_ascii_case(k)))?;
|
|
let mut codes: Vec<i64> = [(mods.shift, 16), (mods.ctrl, 17), (mods.alt, 18), (mods.cmd, 91)].into_iter().filter(|m| m.0).map(|m| m.1).collect();
|
|
codes.push(i64::from(code));
|
|
Some((codes, false))
|
|
}
|
|
|
|
/// The text style fields of a layer or of an override table entry.
|
|
fn style_fields(st: &TextStyle, f: &mut Fields) {
|
|
let line_height = match st.line_height {
|
|
// Percent units count from the font's own line height (100 % is "auto"); a share of the
|
|
// font size is a raw multiplier.
|
|
LineHeight::Auto => o(vec![("value", fl(100.0)), ("units", e("PERCENT"))]),
|
|
LineHeight::Percent(p) => o(vec![("value", fl(p / 100.0)), ("units", e("RAW"))]),
|
|
LineHeight::Pixels(v) => o(vec![("value", fl(v)), ("units", e("PIXELS"))]),
|
|
};
|
|
let letter_spacing = match st.letter_spacing {
|
|
LetterSpacing::Percent(p) => o(vec![("value", fl(p)), ("units", e("PERCENT"))]),
|
|
LetterSpacing::Pixels(v) => o(vec![("value", fl(v)), ("units", e("PIXELS"))]),
|
|
};
|
|
let case = match st.case {
|
|
TextCase::Original => "ORIGINAL",
|
|
TextCase::Upper => "UPPER",
|
|
TextCase::Lower => "LOWER",
|
|
TextCase::Title => "TITLE",
|
|
TextCase::SmallCaps => "SMALL_CAPS",
|
|
};
|
|
let decoration = match st.decoration {
|
|
TextDecoration::None => "NONE",
|
|
TextDecoration::Underline => "UNDERLINE",
|
|
TextDecoration::Strikethrough => "STRIKETHROUGH",
|
|
};
|
|
f.extend([
|
|
("fontName", o(vec![("family", s(&st.font_family)), ("style", s(&super::style_name(&st.font_style))), ("postscript", s(""))])),
|
|
("fontSize", fl(st.font_size)),
|
|
("lineHeight", line_height),
|
|
("letterSpacing", letter_spacing),
|
|
("textCase", e(case)),
|
|
("textDecoration", e(decoration)),
|
|
]);
|
|
if let Some(url) = &st.link {
|
|
f.push(("hyperlink", o(vec![("url", s(url))])));
|
|
}
|
|
}
|
|
|
|
/// Layout grid `index` of a layer, with the variables `bound` to its fields.
|
|
fn layout_grid(g: &figcraft_doc::LayoutGrid, index: usize, bound: &Bound) -> Kv<'static> {
|
|
let (pattern, axis) = match g.kind {
|
|
GridKind::Grid => ("GRID", "X"),
|
|
GridKind::Columns => ("STRIPES", "X"),
|
|
GridKind::Rows => ("STRIPES", "Y"),
|
|
};
|
|
let align = match g.align {
|
|
GridAlign::Stretch => "STRETCH",
|
|
GridAlign::Min => "MIN",
|
|
GridAlign::Center => "CENTER",
|
|
GridAlign::Max => "MAX",
|
|
};
|
|
let mut f: Fields = vec![
|
|
("type", e(align)),
|
|
("axis", e(axis)),
|
|
("visible", b(g.visible)),
|
|
("numSections", int(g.count.into())),
|
|
("offset", fl(g.offset)),
|
|
("sectionSize", fl(g.size)),
|
|
("gutterSize", fl(g.gutter)),
|
|
("color", color(g.color)),
|
|
("pattern", e(pattern)),
|
|
];
|
|
let vars = [("count", "numSectionsVar"), ("offset", "offsetVar"), ("size", "sectionSizeVar"), ("gutter", "gutterSizeVar")];
|
|
f.extend(vars.into_iter().filter_map(|(ours, key)| Some((key, bound.grids.get(&(index, ours))?.clone()))));
|
|
o(f)
|
|
}
|
|
|
|
fn export_setting(x: &figcraft_doc::ExportSetting) -> Kv<'static> {
|
|
let format = match x.format {
|
|
// The format has no WebP export setting.
|
|
figcraft_doc::ExportFormat::Png | figcraft_doc::ExportFormat::Webp => "PNG",
|
|
figcraft_doc::ExportFormat::Jpg => "JPEG",
|
|
figcraft_doc::ExportFormat::Svg => "SVG",
|
|
figcraft_doc::ExportFormat::Pdf => "PDF",
|
|
};
|
|
let (ty, value) = match x.size {
|
|
ExportSize::Scale { value } => ("CONTENT_SCALE", value),
|
|
ExportSize::Width { value } => ("CONTENT_WIDTH", value),
|
|
ExportSize::Height { value } => ("CONTENT_HEIGHT", value),
|
|
};
|
|
o(vec![("suffix", s(&x.suffix)), ("imageType", e(format)), ("constraint", o(vec![("type", e(ty)), ("value", fl(value))]))])
|
|
}
|