mirror of
https://github.com/storytold/figcraft.git
synced 2026-11-15 23:02:36 +00:00
Merge upstream/main into fix/field-alt-scrub
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
This commit is contained in:
commit
fffdf98c0f
96 files changed
+2072
-167
No files matched your search
@@ -333,6 +333,17 @@ impl Change {
|
||||
}
|
||||
|
||||
impl Entry {
|
||||
/// The synced list this entry belongs to (`None` for entries kept in maps).
|
||||
pub(crate) fn family(&self) -> Option<Family> {
|
||||
match self {
|
||||
Entry::Style(_) => Some(Family::Styles),
|
||||
Entry::Comment(_) => Some(Family::Comments),
|
||||
Entry::Collection(_) => Some(Family::Collections),
|
||||
Entry::Variable(_) => Some(Family::Variables),
|
||||
Entry::DevSnapshot(_) | Entry::Image(_) | Entry::Ballot(_) => None,
|
||||
}
|
||||
}
|
||||
|
||||
/// The client id space the entry's id lies in ([`figcraft_doc::ids`]): ids made during a live
|
||||
/// session carry their creator's client id, ids from before and ids of other forms are in
|
||||
/// space 0. `None` for entries keyed by something else (dev snapshots by layer, images by
|
||||
|
||||
@@ -95,7 +95,8 @@ pub fn diff(from: &Replica, to: &Document) -> Result<Diff, Error> {
|
||||
let mut changes = fields;
|
||||
let new: BTreeSet<NodeId> = added.iter().copied().collect();
|
||||
// Creations, parents before children.
|
||||
added.sort_by_cached_key(|id| (depth(to, *id), *id));
|
||||
let mut memo = BTreeMap::new();
|
||||
added.sort_by_cached_key(|id| (depth(to, *id, &mut memo), *id));
|
||||
for id in &added {
|
||||
if let Some(n) = to.node(*id) {
|
||||
changes.push(create_change(n, replica.key(*id))?);
|
||||
@@ -121,18 +122,30 @@ pub fn diff(from: &Replica, to: &Document) -> Result<Diff, Error> {
|
||||
Ok(Diff { changes, replica })
|
||||
}
|
||||
|
||||
/// Depth of `id` in `doc` (pages are 0).
|
||||
fn depth(doc: &Document, id: NodeId) -> usize {
|
||||
let mut d = 0;
|
||||
/// Depth of `id` in `doc` (pages are 0). `memo` holds the depths found so far, so a deep chain of
|
||||
/// new layers is walked once rather than once per layer.
|
||||
fn depth(doc: &Document, id: NodeId, memo: &mut BTreeMap<NodeId, usize>) -> usize {
|
||||
let mut chain = vec![id];
|
||||
let mut base = 0;
|
||||
let mut cur = doc.node(id).and_then(|n| n.parent);
|
||||
while let Some(p) = cur {
|
||||
d += 1;
|
||||
if d > 100_000 {
|
||||
if let Some(d) = memo.get(&p) {
|
||||
base = *d + 1;
|
||||
break;
|
||||
}
|
||||
// An acyclic chain is no longer than the document: this only stops a cycle.
|
||||
if chain.len() > doc.node_count() {
|
||||
break;
|
||||
}
|
||||
chain.push(p);
|
||||
cur = doc.node(p).and_then(|n| n.parent);
|
||||
}
|
||||
d
|
||||
// `chain` runs from `id` up; the last entry's depth is `base` when it ends at a root or a memo hit.
|
||||
let top = chain.len();
|
||||
for (i, c) in chain.iter().enumerate() {
|
||||
memo.insert(*c, base + (top - 1 - i));
|
||||
}
|
||||
memo.get(&id).copied().unwrap_or(0)
|
||||
}
|
||||
|
||||
/// New keys for the children `kids` (in their new order) whose `old` key no longer fits: the
|
||||
@@ -196,3 +209,21 @@ fn increasing_run(keys: &[Option<&str>]) -> Vec<bool> {
|
||||
}
|
||||
kept
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod depth_tests {
|
||||
use super::*;
|
||||
use figcraft_doc::NodeKind;
|
||||
|
||||
#[test]
|
||||
fn a_chain_longer_than_a_fixed_bound_is_walked_whole() {
|
||||
let mut doc = Document::new("File");
|
||||
let mut parent = doc.first_page().unwrap();
|
||||
let mut last = parent;
|
||||
for i in 0..100_050 {
|
||||
last = doc.create(parent, NodeKind::Frame, &format!("F{i}"), 0.0, 0.0, 1.0, 1.0).unwrap();
|
||||
parent = last;
|
||||
}
|
||||
assert_eq!(depth(&doc, last, &mut BTreeMap::new()), 100_050);
|
||||
}
|
||||
}
|
||||
@@ -310,3 +310,14 @@ fn many_sibling_placements_keep_the_order_of_counting_them() {
|
||||
assert_eq!(r.document().node(p).unwrap().children, kids[&p], "children of {p}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_chain_of_new_nested_layers_is_created_parents_first() {
|
||||
let (a, _, frame, _) = setup();
|
||||
let mut b = a.document().clone();
|
||||
let mut parent = frame;
|
||||
for i in 0..400 {
|
||||
parent = b.create(parent, NodeKind::Frame, &format!("F{i}"), 0.0, 0.0, 10.0, 10.0).unwrap();
|
||||
}
|
||||
assert_eq!(round_trip(&a, &b).iter().filter(|c| matches!(c, Change::Create { .. })).count(), 400);
|
||||
}
|
||||
@@ -236,7 +236,9 @@ impl Replica {
|
||||
self.doc.insert_page(node).map_err(doc_err)?;
|
||||
}
|
||||
(false, Some(p)) => {
|
||||
let at = self.slot(&self.doc.get(*p).map_err(doc_err)?.children, *id, position);
|
||||
// A new id sits in no sibling list yet: no scan for it, just the binary search.
|
||||
let siblings = &self.doc.get(*p).map_err(doc_err)?.children;
|
||||
let at = siblings.partition_point(|c| (self.key(*c), *c) < (position.as_str(), *id));
|
||||
self.doc.insert(node, *p, Some(at)).map_err(doc_err)?;
|
||||
}
|
||||
_ => return Err(Error::Invalid("pages, and only pages, have no parent".into())),
|
||||
|
||||
@@ -6,7 +6,7 @@ use std::collections::{BTreeMap, BTreeSet, VecDeque};
|
||||
use figcraft_doc::{Document, NodeId};
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use crate::change::{Change, Entry, Prop, Target};
|
||||
use crate::change::{Change, Entry, Family, Prop, Target};
|
||||
use crate::message::{
|
||||
Accepted, Access, CatchUp, ClientMsg, Hello, PROTOCOL, Peer, Presence, Processed, Resume, ServerMsg, Signal, reads_comments, reads_signals,
|
||||
};
|
||||
@@ -413,10 +413,14 @@ impl Server {
|
||||
// client learned what happened to it from the catch-up.
|
||||
ClientMsg::Changes { batch_id, .. } if self.issued.get(&from).is_some_and(|p| batch_id <= p.last_batch) => Vec::new(),
|
||||
ClientMsg::Changes { base_seq, batch_id, changes } => {
|
||||
let mut denied = true;
|
||||
let result = match self.limited.get(&from) {
|
||||
Some(Access::View) => Err(Error::Invalid(VIEW_ONLY.into())),
|
||||
Some(Access::Comment) if !changes.iter().all(Change::is_comment) => Err(Error::Invalid(COMMENT_ONLY.into())),
|
||||
_ => self.accept(from, base_seq, &changes),
|
||||
_ => {
|
||||
denied = false;
|
||||
self.accept(from, base_seq, &changes)
|
||||
}
|
||||
};
|
||||
if let Some(p) = self.issued.get_mut(&from) {
|
||||
p.note(batch_id, result.is_err());
|
||||
@@ -430,7 +434,9 @@ impl Server {
|
||||
}
|
||||
Err(e) => {
|
||||
self.note(Journal::Refused { client: from, batch_id });
|
||||
let fixes = self.fixes(&changes).unwrap_or_default();
|
||||
// A refusal for lack of permission costs no repair: the client's confirmed copy
|
||||
// already is the server's state, so the fixes would only repeat it.
|
||||
let fixes = if denied { Vec::new() } else { self.fixes(&changes).unwrap_or_default() };
|
||||
vec![Outgoing::To(from, ServerMsg::Reject { batch_id, reason: reason(&e), fixes })]
|
||||
}
|
||||
}
|
||||
@@ -557,6 +563,7 @@ impl Server {
|
||||
fn check_entries(&self, from: u32, changes: &[Change], after: &Document) -> Result<Vec<(Entry, bool)>, Error> {
|
||||
let before = self.state.document();
|
||||
let mut touched: BTreeSet<Entry> = BTreeSet::new();
|
||||
let mut listed: BTreeMap<Family, (BTreeSet<Entry>, BTreeSet<Entry>)> = BTreeMap::new();
|
||||
for c in changes {
|
||||
match c {
|
||||
Change::Put { entry, .. } | Change::Remove { entry } if entry.id_space().is_some() => {
|
||||
@@ -565,8 +572,10 @@ impl Server {
|
||||
// A whole list replaced (the fallback for lists whose ids aren't unique).
|
||||
Change::SetDoc { prop, .. } => {
|
||||
if let Some(Ok(family)) = prop.list() {
|
||||
touched.extend(docprops::entries(before, family));
|
||||
touched.extend(docprops::entries(after, family));
|
||||
let (b, a) = (docprops::entries(before, family), docprops::entries(after, family));
|
||||
touched.extend(b.iter().chain(&a).cloned());
|
||||
// Looked up in sets below: a linear search per entry would be quadratic.
|
||||
listed.entry(family).or_insert_with(|| (b.into_iter().collect(), a.into_iter().collect()));
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
@@ -574,7 +583,10 @@ impl Server {
|
||||
}
|
||||
let mut out = Vec::new();
|
||||
for entry in touched {
|
||||
let (was, now) = (docprops::has(before, &entry), docprops::has(after, &entry));
|
||||
let (was, now) = match entry.family().and_then(|f| listed.get(&f)) {
|
||||
Some((b, a)) => (b.contains(&entry), a.contains(&entry)),
|
||||
None => (docprops::has(before, &entry), docprops::has(after, &entry)),
|
||||
};
|
||||
if was == now {
|
||||
continue;
|
||||
}
|
||||
|
||||
@@ -182,6 +182,26 @@ fn deleted_nodes_can_come_back_but_ids_are_never_handed_out_twice() {
|
||||
assert_eq!(s.document(), gone.document());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_viewers_refused_deletion_gets_no_repair() {
|
||||
let (d, _, frame) = doc();
|
||||
let mut s = Server::new(d, "tok", Limits::default());
|
||||
let (id, out) = s.join_as(hello("tok"), crate::message::Access::View).unwrap();
|
||||
let Some(Outgoing::To(_, welcome)) = out.into_iter().next() else { panic!() };
|
||||
let mut v = Client::join(welcome).unwrap();
|
||||
let del = edit(&mut v, |d| d.remove(frame).unwrap());
|
||||
let (reason, fixes) = rejected(
|
||||
&mut s,
|
||||
id,
|
||||
match del {
|
||||
ClientMsg::Changes { changes, .. } => changes,
|
||||
_ => panic!(),
|
||||
},
|
||||
);
|
||||
assert_eq!(reason, crate::VIEW_ONLY);
|
||||
assert!(fixes.is_empty(), "{fixes:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fixes_roll_a_rejected_client_back_to_the_server_state() {
|
||||
let (d, _, frame) = doc();
|
||||
|
||||
@@ -49,6 +49,47 @@ fn glass_values_are_clamped_and_reach_their_backdrop() {
|
||||
assert_eq!(hidden.backdrop_radius(), 0.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn glass_frost_stays_within_the_reference_range() {
|
||||
// A file from before the 0–100 range draws its frost at 100, and reaches no further.
|
||||
let g = Glass { frost: 150.0, ..Glass::default() };
|
||||
assert_eq!(g.sanitized().frost, Glass::MAX_FROST);
|
||||
let e = Effect { kind: EffectKind::Glass(g), visible: true };
|
||||
let capped = Effect { kind: EffectKind::Glass(Glass { frost: Glass::MAX_FROST, ..Glass::default() }), visible: true };
|
||||
assert_eq!(e.backdrop_radius(), capped.backdrop_radius());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn glass_fields_take_bound_numbers_as_the_panel_shows_them() {
|
||||
let mut g = Glass::default();
|
||||
for (field, x) in [
|
||||
("lightAngle", 30.0),
|
||||
("lightIntensity", 25.0),
|
||||
("refraction", 40.0),
|
||||
("depth", 12.0),
|
||||
("dispersion", 10.0),
|
||||
("radius", 8.0),
|
||||
("splay", 50.0),
|
||||
] {
|
||||
assert!(g.set_bound(field, x), "{field}");
|
||||
}
|
||||
assert_eq!((g.light_angle, g.light_intensity, g.refraction, g.depth, g.dispersion, g.frost, g.splay), (30.0, 0.25, 0.4, 12.0, 0.1, 8.0, 0.5));
|
||||
// Out of range: clamped to the field's range.
|
||||
for (field, x) in [("lightAngle", 270.0), ("lightIntensity", 250.0), ("depth", 0.0), ("radius", 150.0), ("splay", -5.0)] {
|
||||
assert!(g.set_bound(field, x), "{field}");
|
||||
}
|
||||
assert_eq!((g.light_angle, g.light_intensity, g.depth, g.frost, g.splay), (180.0, 1.0, 1.0, Glass::MAX_FROST, 0.0));
|
||||
// A field glass doesn't have, or a value that isn't a number, changes nothing.
|
||||
let before = g.clone();
|
||||
assert!(!g.set_bound("spread", 3.0));
|
||||
assert!(!g.set_bound("splay", f64::NAN));
|
||||
assert!(!g.set_bound("depth", f64::INFINITY));
|
||||
assert_eq!(g, before);
|
||||
for field in Glass::BOUND_FIELDS {
|
||||
assert!(Glass::default().set_bound(field, 1.0), "{field}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn effect_colours() {
|
||||
let mut e = Effect::noise();
|
||||
|
||||
+19
-2
@@ -574,6 +574,19 @@ impl Document {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Remove every child of `id` with its subtree, in one pass over `id`'s child list (removing
|
||||
/// them one by one would search that list once per child).
|
||||
pub fn remove_children(&mut self, id: NodeId) -> DocResult<()> {
|
||||
let kids = std::mem::take(&mut self.get_mut(id)?.children);
|
||||
for c in kids {
|
||||
for d in self.subtree(c) {
|
||||
self.nodes.remove(&d);
|
||||
self.dirty.touch(d);
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Whether sections may go in `parent`: a page or another section (never a frame or a group).
|
||||
pub fn takes_sections(&self, parent: NodeId) -> bool {
|
||||
self.node(parent).is_some_and(|p| p.is_page() || matches!(p.kind, NodeKind::Section { .. }))
|
||||
@@ -1085,6 +1098,9 @@ impl Document {
|
||||
// lookups: a wide parent or a long page list doesn't make validation quadratic.
|
||||
let edges: std::collections::BTreeSet<(NodeId, NodeId)> = self.nodes.iter().flat_map(|(p, n)| n.children.iter().map(|c| (*p, *c))).collect();
|
||||
let page_ids: std::collections::BTreeSet<NodeId> = self.pages.iter().copied().collect();
|
||||
if page_ids.len() != self.pages.len() {
|
||||
note(&mut issues, || "a page is listed twice".to_string());
|
||||
}
|
||||
for (id, n) in self.nodes.iter() {
|
||||
if n.id != *id {
|
||||
note(&mut issues, || format!("node key {id} has id {}", n.id));
|
||||
@@ -1178,9 +1194,10 @@ impl Document {
|
||||
if store != self.libraries.store {
|
||||
Arc::make_mut(&mut self.libraries).store = store;
|
||||
}
|
||||
self.pages.retain(|p| self.nodes.get(p).is_some_and(|n| n.is_page()) && Some(*p) != store);
|
||||
// A page listed twice would be imported, exported and walked once per listing.
|
||||
let mut listed = std::collections::BTreeSet::new();
|
||||
self.pages.retain(|p| self.nodes.get(p).is_some_and(|n| n.is_page()) && Some(*p) != store && listed.insert(*p));
|
||||
// Unlisted pages join the list; a set keeps many pages from making this quadratic (#1078).
|
||||
let mut listed: std::collections::BTreeSet<NodeId> = self.pages.iter().copied().collect();
|
||||
for (k, n) in self.nodes.iter() {
|
||||
if n.is_page() && Some(*k) != store && listed.insert(*k) {
|
||||
self.pages.push(*k);
|
||||
|
||||
+40
-4
@@ -660,7 +660,7 @@ pub struct Glass {
|
||||
pub depth: f64,
|
||||
/// Colour splitting along the curved edge (0–1).
|
||||
pub dispersion: f64,
|
||||
/// Blur of the backdrop (a blur radius, document units).
|
||||
/// Blur of the backdrop (a blur radius, document units, 0–[`Self::MAX_FROST`]).
|
||||
pub frost: f64,
|
||||
/// How widely the light spreads over the glass (0–1).
|
||||
pub splay: f64,
|
||||
@@ -673,6 +673,34 @@ impl Default for Glass {
|
||||
}
|
||||
|
||||
impl Glass {
|
||||
/// The most frost a glass takes, as the reference tool's Frost field (0–100).
|
||||
pub const MAX_FROST: f64 = 100.0;
|
||||
|
||||
/// The fields a variable binds on a glass effect (`effects/<i>/<field>`), see [`Self::set_bound`].
|
||||
pub const BOUND_FIELDS: [&'static str; 7] = ["lightAngle", "lightIntensity", "refraction", "depth", "dispersion", "radius", "splay"];
|
||||
|
||||
/// Sets `field` (one of [`Self::BOUND_FIELDS`]) from a bound number variable, read as the
|
||||
/// Design panel's field shows it: intensity, refraction, dispersion and splay in percent, the
|
||||
/// frost as `radius`, each clamped to the field's range. False for a field glass doesn't have
|
||||
/// or a value that isn't finite (nothing changes).
|
||||
pub fn set_bound(&mut self, field: &str, x: f64) -> bool {
|
||||
if !x.is_finite() {
|
||||
return false;
|
||||
}
|
||||
let pct = (x / 100.0).clamp(0.0, 1.0);
|
||||
match field {
|
||||
"lightAngle" => self.light_angle = x.clamp(-180.0, 180.0),
|
||||
"lightIntensity" => self.light_intensity = pct,
|
||||
"refraction" => self.refraction = pct,
|
||||
"depth" => self.depth = x.clamp(1.0, 1000.0),
|
||||
"dispersion" => self.dispersion = pct,
|
||||
"radius" => self.frost = x.clamp(0.0, Self::MAX_FROST),
|
||||
"splay" => self.splay = pct,
|
||||
_ => return false,
|
||||
}
|
||||
true
|
||||
}
|
||||
|
||||
/// The values clamped to their ranges (non-finite ones at their defaults).
|
||||
pub fn sanitized(&self) -> Glass {
|
||||
let d = Glass::default();
|
||||
@@ -683,15 +711,23 @@ impl Glass {
|
||||
refraction: ok(self.refraction, d.refraction, 0.0, 1.0),
|
||||
depth: ok(self.depth, d.depth, 1.0, 1000.0),
|
||||
dispersion: ok(self.dispersion, d.dispersion, 0.0, 1.0),
|
||||
frost: ok(self.frost, d.frost, 0.0, 1000.0),
|
||||
frost: ok(self.frost, d.frost, 0.0, Self::MAX_FROST),
|
||||
splay: ok(self.splay, d.splay, 0.0, 1.0),
|
||||
}
|
||||
}
|
||||
|
||||
/// Furthest the curved edge moves the backdrop (document units).
|
||||
/// How far `dispersion` splits the colour channels, as a share of the bend: at full dispersion
|
||||
/// red moves up to this much further and blue as much less. Matched to the reference tool:
|
||||
/// across a black-to-white edge in the bend, red and blue part about 4.7 px at 100% and 2.4 px
|
||||
/// at 50% (at 2×, depth 20, refraction 80%).
|
||||
pub const DISPERSION_SPREAD: f64 = 0.16;
|
||||
|
||||
/// Furthest the curved edge moves the backdrop (document units): at most `depth` × `refraction`
|
||||
/// (all of it a bevel in from the edge), and red's dispersion steps up to
|
||||
/// [`Self::DISPERSION_SPREAD`] × `dispersion` times that again.
|
||||
pub fn max_bend(&self) -> f64 {
|
||||
let g = self.sanitized();
|
||||
g.refraction * g.depth * (1.0 + g.dispersion * 0.25)
|
||||
g.refraction * g.depth * (1.0 + Self::DISPERSION_SPREAD * g.dispersion)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -12,6 +12,8 @@ use crate::{CollectionId, ModeId, VariableValue, Variables};
|
||||
pub const MAX_EXPR_DEPTH: usize = 32;
|
||||
/// Longest string an expression builds (characters).
|
||||
const MAX_STRING: usize = 10_000;
|
||||
/// The most string bytes one operation's operands may hold together (generous: results cap at `MAX_STRING`).
|
||||
const MAX_OPERAND_BYTES: usize = 1 << 20;
|
||||
|
||||
/// An expression over variables.
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
||||
@@ -115,7 +117,19 @@ impl Expr {
|
||||
}
|
||||
Expr::Op { op, args } => (*op, args),
|
||||
};
|
||||
let vals: Vec<VariableValue> = args.iter().map(|a| a.eval_at(vars, modes, depth + 1)).collect::<Option<_>>()?;
|
||||
// Retained operands are bounded by bytes, so repeated references to one long string can't multiply it.
|
||||
let mut text_bytes = 0usize;
|
||||
let mut vals = Vec::with_capacity(args.len());
|
||||
for a in args {
|
||||
let v = a.eval_at(vars, modes, depth + 1)?;
|
||||
if let VariableValue::String(s) = &v {
|
||||
text_bytes = text_bytes.saturating_add(s.len());
|
||||
if text_bytes > MAX_OPERAND_BYTES {
|
||||
return None;
|
||||
}
|
||||
}
|
||||
vals.push(v);
|
||||
}
|
||||
apply(op, &vals)
|
||||
}
|
||||
|
||||
@@ -259,10 +273,18 @@ fn apply(op: ExprOp, vals: &[VariableValue]) -> Option<VariableValue> {
|
||||
match op {
|
||||
Add if vals.iter().any(|v| matches!(v, VariableValue::String(_))) => {
|
||||
let mut s = String::new();
|
||||
let mut chars = 0;
|
||||
for v in vals {
|
||||
s.push_str(&as_text(v)?);
|
||||
// Every operand is checked (a colour makes the whole expression None); only the
|
||||
// characters it adds are counted, and appending stops at the cap.
|
||||
let t = as_text(v)?;
|
||||
if chars < MAX_STRING {
|
||||
let before = s.len();
|
||||
s.extend(t.chars().take(MAX_STRING - chars));
|
||||
chars += s[before..].chars().count();
|
||||
}
|
||||
}
|
||||
Some(VariableValue::String(s.chars().take(MAX_STRING).collect()))
|
||||
Some(VariableValue::String(s))
|
||||
}
|
||||
Add => fold(|a, b| Some(a + b)),
|
||||
Subtract => fold(|a, b| Some(a - b)),
|
||||
|
||||
@@ -124,6 +124,13 @@ fn deep_and_hostile_expressions_are_bounded() {
|
||||
let joined = Expr::op(ExprOp::Add, vec![s(&long), s(&long)]);
|
||||
let Some(VariableValue::String(t)) = eval(&joined) else { panic!() };
|
||||
assert_eq!(t.chars().count(), 10_000, "capped");
|
||||
// Past the cap a colour operand still fails the expression, and empty operands add nothing.
|
||||
let color = Expr::Value(VariableValue::Color(Color::BLACK));
|
||||
let mut ops = vec![s(&"x".repeat(10_000))];
|
||||
ops.extend((0..50).map(|_| s("")));
|
||||
assert!(matches!(eval(&Expr::op(ExprOp::Add, ops.clone())), Some(VariableValue::String(t)) if t.chars().count() == 10_000));
|
||||
ops.push(color);
|
||||
assert_eq!(eval(&Expr::op(ExprOp::Add, ops)), None, "a colour past the cap is still a type error");
|
||||
}
|
||||
|
||||
fn nav(id: u64) -> Action {
|
||||
@@ -199,3 +206,12 @@ fn serde_round_trip_and_old_files() {
|
||||
let old: Action = serde_json::from_str(r#"{"type":"setVariable","variable":"n","value":2}"#).unwrap_or(Action::Back);
|
||||
assert_eq!(old, Action::SetVariable { variable: "n".into(), value: serde_json::json!(2), expr: None });
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn operands_holding_too_many_string_bytes_are_refused() {
|
||||
let long = "x".repeat(300_000);
|
||||
let few = Expr::op(ExprOp::Add, vec![s(&long), s(&long)]);
|
||||
assert!(eval(&few).is_some());
|
||||
let many = Expr::op(ExprOp::Add, (0..8).map(|_| s(&long)).collect());
|
||||
assert_eq!(eval(&many), None);
|
||||
}
|
||||
@@ -348,6 +348,20 @@ fn repair_drops_cycles_and_repeated_children() {
|
||||
assert_eq!(bad.subtree(p), vec![p, r]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn repair_lists_a_page_once_however_often_the_file_lists_it() {
|
||||
let mut d = Document::new("x");
|
||||
let p = page(&d);
|
||||
let q = d.add_page("Two");
|
||||
let mut v = serde_json::to_value(&d).unwrap();
|
||||
v["pages"] = serde_json::json!([p, q, p, q, p]);
|
||||
let mut bad: Document = serde_json::from_value(v).unwrap();
|
||||
assert!(bad.validate().iter().any(|i| i.contains("listed twice")), "{:?}", bad.validate());
|
||||
bad.repair();
|
||||
assert!(bad.validate().is_empty(), "{:?}", bad.validate());
|
||||
assert_eq!(bad.pages, vec![p, q]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn validate_caps_the_issue_list() {
|
||||
let mut d = Document::new("x");
|
||||
@@ -846,3 +860,17 @@ fn the_colour_walker_visits_calculation_literals() {
|
||||
let ColorOperand::Literal { literal } = from else { panic!("literal operand") };
|
||||
assert_eq!(literal.a, 0.5, "the mix's stored literal was converted like every other colour");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn remove_children_removes_every_subtree_and_keeps_the_parent() {
|
||||
let mut doc = Document::new("T");
|
||||
let page = doc.first_page().unwrap();
|
||||
let frame = doc.create(page, NodeKind::Frame, "F", 0.0, 0.0, 100.0, 100.0).unwrap();
|
||||
let inner = doc.create(frame, NodeKind::Frame, "Inner", 0.0, 0.0, 10.0, 10.0).unwrap();
|
||||
let leaf = doc.create(inner, NodeKind::Rectangle, "Leaf", 0.0, 0.0, 5.0, 5.0).unwrap();
|
||||
let other = doc.create(page, NodeKind::Rectangle, "Other", 0.0, 0.0, 5.0, 5.0).unwrap();
|
||||
doc.remove_children(frame).unwrap();
|
||||
assert!(doc.contains(frame) && doc.contains(other));
|
||||
assert!(!doc.contains(inner) && !doc.contains(leaf));
|
||||
assert!(doc.get(frame).unwrap().children.is_empty());
|
||||
}
|
||||
@@ -147,6 +147,10 @@ pub fn inside_instance(doc: &Document, id: NodeId) -> bool {
|
||||
/// main layer's, for files from before `modes` was an override group. Copies follow their main
|
||||
/// layer's modes, so a layer on other modes chose them itself.
|
||||
pub fn mark_layer_modes(doc: &mut Document) {
|
||||
// Without an instance nothing can be inside one: skip the per-layer ancestry lookups.
|
||||
if !doc.nodes().any(|n| matches!(n.kind, NodeKind::Instance { .. })) {
|
||||
return;
|
||||
}
|
||||
let chose: Vec<NodeId> = doc
|
||||
.nodes()
|
||||
.filter(|n| !n.overrides.contains("modes") && n.source.and_then(|s| doc.node(s)).is_some_and(|m| m.var_modes != n.var_modes))
|
||||
|
||||
@@ -277,8 +277,16 @@ pub fn default_selection(doc: &Document, prev: Option<&LibraryManifest>) -> Sele
|
||||
fn alias_closure(vars: &Variables, seeds: impl IntoIterator<Item = VariableId>) -> BTreeSet<VariableId> {
|
||||
let mut out = BTreeSet::new();
|
||||
let mut stack: Vec<VariableId> = seeds.into_iter().collect();
|
||||
if stack.is_empty() {
|
||||
return out;
|
||||
}
|
||||
// Indexed once (the first of equal ids, as `get_by_id` finds it): a scan per step is quadratic on a long alias chain.
|
||||
let mut by_id = std::collections::HashMap::new();
|
||||
for v in &vars.variables {
|
||||
by_id.entry(v.id.as_str()).or_insert(v);
|
||||
}
|
||||
while let Some(cur) = stack.pop() {
|
||||
let Some(v) = vars.get_by_id(&cur) else { continue };
|
||||
let Some(v) = by_id.get(cur.as_str()).copied() else { continue };
|
||||
if out.len() >= MAX_ASSETS || !out.insert(v.id.clone()) {
|
||||
continue;
|
||||
}
|
||||
|
||||
@@ -79,10 +79,13 @@ pub fn usage(doc: &Document, library: &str) -> Usage {
|
||||
let records: std::collections::BTreeMap<NodeId, NodeId> =
|
||||
doc.libraries.components.iter().filter(|r| r.library == library).map(|r| (r.root, r.key)).collect();
|
||||
if !records.is_empty() {
|
||||
// One component's asset root is looked up once, however many instances use it.
|
||||
let mut roots = std::collections::BTreeMap::<NodeId, Option<NodeId>>::new();
|
||||
for n in doc.nodes() {
|
||||
if let NodeKind::Instance { component, .. } = &n.kind
|
||||
&& store.is_none_or(|st| doc.page_of(n.id) != Some(st))
|
||||
&& let Some(key) = crate::library::asset_root(doc, *component).and_then(|r| records.get(&r))
|
||||
&& let Some(key) =
|
||||
roots.entry(*component).or_insert_with(|| crate::library::asset_root(doc, *component)).and_then(|r| records.get(&r))
|
||||
{
|
||||
let c = counts.entry(*key).or_default();
|
||||
*c = c.saturating_add(1);
|
||||
|
||||
@@ -33,6 +33,7 @@ pub fn field_type(kind: &StyleKind, key: &str) -> Option<VariableType> {
|
||||
(EffectKind::DropShadow(_) | EffectKind::InnerShadow(_), "color") => Some(Color),
|
||||
(EffectKind::DropShadow(_) | EffectKind::InnerShadow(_), "radius" | "spread" | "offsetX" | "offsetY") => Some(Number),
|
||||
(EffectKind::LayerBlur(_) | EffectKind::BackgroundBlur(_), "radius" | "startRadius") => Some(Number),
|
||||
(EffectKind::Glass(_), f) if figcraft_doc::Glass::BOUND_FIELDS.contains(&f) => Some(Number),
|
||||
_ => None,
|
||||
},
|
||||
(StyleKind::Grid { grids }, Some((BoundList::Grids, i, "size" | "count" | "gutter" | "offset"))) => grids.get(i).map(|_| Number),
|
||||
|
||||
@@ -156,14 +156,20 @@ impl BatchScope {
|
||||
lookup(result, path).cloned().map_err(|why| fail(format!("{who}'s result has no `{path}`{why}")))
|
||||
}
|
||||
|
||||
/// Most step names a missing-reference error lists.
|
||||
const NAME_HINTS: usize = 12;
|
||||
|
||||
fn known_names(&self) -> String {
|
||||
let mut names: Vec<_> = self.names.iter().collect();
|
||||
names.sort_by_key(|(_, i)| **i);
|
||||
if names.is_empty() {
|
||||
return "no step has an `as` name".into();
|
||||
}
|
||||
let list: Vec<_> = names.iter().map(|(name, i)| format!("\"{name}\" is step {i}")).collect();
|
||||
list.join(", ")
|
||||
// A few of them: the list is built for every missing reference and, with `onError:
|
||||
// continue`, kept for each, so a long table would cost its length per failed step.
|
||||
let list: Vec<_> = names.iter().take(Self::NAME_HINTS).map(|(name, i)| format!("\"{name}\" is step {i}")).collect();
|
||||
let more = names.len().saturating_sub(Self::NAME_HINTS);
|
||||
if more > 0 { format!("{}, {more} more", list.join(", ")) } else { list.join(", ") }
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -98,6 +98,41 @@ fn effect_moves_and_removals_reject_junk() {
|
||||
assert_eq!(s.doc().unwrap().node(r).unwrap().effects.len(), 1);
|
||||
}
|
||||
|
||||
fn glass(s: &Session, r: NodeId) -> figcraft_doc::Glass {
|
||||
match s.doc().unwrap().node(r).unwrap().effects.first().map(|e| &e.kind) {
|
||||
Some(EffectKind::Glass(g)) => g.clone(),
|
||||
k => panic!("{k:?}"),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn glass_fields_take_number_variables() {
|
||||
let (mut s, r) = setup();
|
||||
ex(&mut s, "effect.add", json!({"ids": [r], "type": "glass"}));
|
||||
// Percent fields read the variable as the Design panel shows them; `radius` is the frost.
|
||||
ex(&mut s, "variable.bind", json!({"ids": [r], "field": "effects/0/splay", "variable": "large"}));
|
||||
ex(&mut s, "variable.bind", json!({"ids": [r], "field": "effects/0/radius", "variable": "small"}));
|
||||
ex(&mut s, "variable.bind", json!({"ids": [r], "field": "effects/0/depth", "variable": "large"}));
|
||||
let g = glass(&s, r);
|
||||
assert_eq!((g.splay, g.frost, g.depth), (0.3, 2.0, 30.0));
|
||||
// A new value follows, clamped to the field's range (frost stops at 100).
|
||||
ex(&mut s, "variable.set", json!({"variable": "small", "value": 150}));
|
||||
ex(&mut s, "variable.set", json!({"variable": "large", "value": 75}));
|
||||
let g = glass(&s, r);
|
||||
assert_eq!((g.splay, g.frost, g.depth), (0.75, figcraft_doc::Glass::MAX_FROST, 75.0));
|
||||
// A colour variable doesn't fit a glass field.
|
||||
assert!(s.execute("variable.bind", &json!({"ids": [r], "field": "effects/0/refraction", "variable": "brand"})).is_err());
|
||||
// An effect style binds them too, and every layer using it follows.
|
||||
let fx = ex_value(&mut s, "style.create", json!({"type": "effect", "name": "Pane", "from": r}))["id"].as_str().unwrap().to_string();
|
||||
ex(&mut s, "style.bind", json!({"style": fx, "field": "effects/0/refraction", "variable": "large"}));
|
||||
assert_eq!(glass(&s, r).refraction, 0.75);
|
||||
assert!(s.execute("style.bind", &json!({"style": fx, "field": "effects/0/spread", "variable": "large"})).is_err(), "glass has no spread");
|
||||
}
|
||||
|
||||
fn ex_value(s: &mut Session, cmd: &str, p: serde_json::Value) -> serde_json::Value {
|
||||
s.execute(cmd, &p).unwrap_or_else(|e| panic!("{cmd}: {e}"))
|
||||
}
|
||||
|
||||
fn fill_hex(s: &Session, r: NodeId) -> Vec<String> {
|
||||
s.doc().unwrap().node(r).unwrap().fills.iter().filter_map(|p| p.solid_color()).map(|c| c.to_hex()).collect()
|
||||
}
|
||||
|
||||
@@ -109,7 +109,9 @@ pub fn eligible(doc: &Document, ids: &[NodeId]) -> Vec<NodeId> {
|
||||
out.push(id);
|
||||
}
|
||||
}
|
||||
let ids: Vec<NodeId> = ids.iter().copied().filter(|i| doc.contains(*i)).collect();
|
||||
// Each id counts once: a repeated group must not be walked once per repeat.
|
||||
let mut seen = std::collections::BTreeSet::new();
|
||||
let ids: Vec<NodeId> = ids.iter().copied().filter(|i| doc.contains(*i) && seen.insert(*i)).collect();
|
||||
let mut out = Vec::new();
|
||||
for id in roots(doc, &ids) {
|
||||
walk(doc, id, 0, &mut out);
|
||||
|
||||
@@ -465,7 +465,8 @@ pub fn scale_node(doc: &mut Document, id: NodeId, k: f64) -> Result<()> {
|
||||
}
|
||||
EffectKind::Glass(g) => {
|
||||
g.depth *= k;
|
||||
g.frost *= k;
|
||||
// From the frost it draws with (an older file's past 100 draws at 100).
|
||||
g.frost = (g.sanitized().frost * k).min(figcraft_doc::Glass::MAX_FROST);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -373,10 +373,11 @@ fn listed<'s>(cmd: &str, s: &'s Session, p: &Value, who: &str, people: &[&str])
|
||||
|
||||
/// Add the names `text` @mentions to `named` as `{name, known, you}`, each once.
|
||||
fn push_mentions(named: &mut Vec<Value>, text: &str, people: &[&str], user: &str) {
|
||||
// `known` and `you` follow from the name, so the name alone tells a repeat.
|
||||
let mut seen: std::collections::BTreeSet<String> = named.iter().filter_map(|v| v.get("name")?.as_str().map(str::to_string)).collect();
|
||||
for (name, known) in mentioned(text, people) {
|
||||
let v = json!({"name": name, "known": known, "you": known && name.eq_ignore_ascii_case(user)});
|
||||
if !named.contains(&v) {
|
||||
named.push(v);
|
||||
if seen.insert(name.to_string()) {
|
||||
named.push(json!({"name": name, "known": known, "you": known && name.eq_ignore_ascii_case(user)}));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -115,6 +115,8 @@ pub(crate) fn enum_of<T: serde::de::DeserializeOwned>(v: &Value) -> Option<T> {
|
||||
let norm: String = {
|
||||
let mut out = String::new();
|
||||
let mut up = false;
|
||||
// Once, not per character: a long value made this quadratic before it was refused.
|
||||
let no_lowercase = s.chars().all(|c| !c.is_lowercase() || !c.is_alphabetic());
|
||||
for (i, ch) in s.trim().chars().enumerate() {
|
||||
if ch == '_' || ch == '-' || ch == ' ' {
|
||||
up = true;
|
||||
@@ -125,7 +127,7 @@ pub(crate) fn enum_of<T: serde::de::DeserializeOwned>(v: &Value) -> Option<T> {
|
||||
} else if up {
|
||||
out.extend(ch.to_uppercase());
|
||||
up = false;
|
||||
} else if s.chars().all(|c| !c.is_lowercase() || !c.is_alphabetic()) {
|
||||
} else if no_lowercase {
|
||||
out.extend(ch.to_lowercase());
|
||||
} else {
|
||||
out.push(ch);
|
||||
|
||||
@@ -53,7 +53,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
spec!(
|
||||
"style.bind",
|
||||
"Bind variable in style",
|
||||
"{style, field, variable? (id or name; none: unbind)} bind a variable to a field of the style's value: a paint style's `fills/<i>/color` (or `fill`: its first paint) and `fills/<i>/stops/<j>/color`, an effect style's `effects/<i>/<color|radius|spread|offsetX|offsetY|startRadius>`, a grid style's `layoutGrids/<i>/<size|count|gutter|offset>`, a text style's `fontSize|lineHeight|letterSpacing` (numbers, px) and `fontFamily|fontStyle` (strings). Every layer using the style shows the field resolved in its own modes; the style keeps it resolved in the default modes",
|
||||
"{style, field, variable? (id or name; none: unbind)} bind a variable to a field of the style's value: a paint style's `fills/<i>/color` (or `fill`: its first paint) and `fills/<i>/stops/<j>/color`, an effect style's `effects/<i>/<color|radius|spread|offsetX|offsetY|startRadius>` (glass: `lightAngle|lightIntensity|refraction|depth|dispersion|radius|splay`), a grid style's `layoutGrids/<i>/<size|count|gutter|offset>`, a text style's `fontSize|lineHeight|letterSpacing` (numbers, px) and `fontFamily|fontStyle` (strings). Every layer using the style shows the field resolved in its own modes; the style keeps it resolved in the default modes",
|
||||
true,
|
||||
bind_style
|
||||
),
|
||||
@@ -196,7 +196,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
spec!(
|
||||
"variable.bind",
|
||||
"Bind variable",
|
||||
"{ids?, field (fill|stroke (first paint)|fills/<i>/color|strokes/<i>/color|fills/<i>/stops/<j>/color (gradient stops)|effects/<i>/<offsetX|offsetY|radius|startRadius|spread|color>|layoutGrids/<i>/<size|count|gutter|offset>|componentProperties/<name> (instances: boolean/text properties; variant properties take string variables naming a value)|width|height|opacity (percent)|cornerRadius|gap|paddingHorizontal|characters|visible|fontSize…; list indices bottom first), variable (null unbinds)}",
|
||||
"{ids?, field (fill|stroke (first paint)|fills/<i>/color|strokes/<i>/color|fills/<i>/stops/<j>/color (gradient stops)|effects/<i>/<offsetX|offsetY|radius|startRadius|spread|color|lightAngle|lightIntensity|refraction|depth|dispersion|splay> (glass: `radius` is its frost; intensity, refraction, dispersion and splay in percent)|layoutGrids/<i>/<size|count|gutter|offset>|componentProperties/<name> (instances: boolean/text properties; variant properties take string variables naming a value)|width|height|opacity (percent)|cornerRadius|gap|paddingHorizontal|characters|visible|fontSize…; list indices bottom first), variable (null unbinds)}",
|
||||
true,
|
||||
bind
|
||||
),
|
||||
@@ -1304,6 +1304,9 @@ pub(crate) fn set_effect_field(effects: &mut [Effect], i: usize, prop: &str, val
|
||||
(EffectKind::DropShadow(s) | EffectKind::InnerShadow(s), "color", _, VariableValue::Color(c)) => s.color = *c,
|
||||
(EffectKind::LayerBlur(b) | EffectKind::BackgroundBlur(b), "radius", Some(x), _) => b.radius = x.max(0.0),
|
||||
(EffectKind::LayerBlur(b) | EffectKind::BackgroundBlur(b), "startRadius", Some(x), _) => b.start_radius = x.max(0.0),
|
||||
(EffectKind::Glass(g), field, Some(x), _) => {
|
||||
g.set_bound(field, x);
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -189,14 +189,21 @@ fn fill_layers(s: &mut Session, copy: NodeId, (key, value): (&str, &Value), miss
|
||||
/// Export each copy into `dir` as `<name>.<format>` at `scale`, adding `files` (and `errors`) to
|
||||
/// `out`.
|
||||
fn export_copies(s: &mut Session, ids: &[(NodeId, String)], dir: &str, (format, scale): (&str, f64), out: &mut Value) {
|
||||
let (mut files, mut errors, mut used) = (Vec::new(), Vec::new(), Vec::<String>::new());
|
||||
let (mut files, mut errors) = (Vec::new(), Vec::new());
|
||||
let mut used = std::collections::BTreeSet::<String>::new();
|
||||
// The next number to try per base, so many copies of one name don't retry from 2 each time.
|
||||
let mut next = std::collections::BTreeMap::<String, u64>::new();
|
||||
for (copy, name) in ids {
|
||||
// One file per copy: same or same-looking names get " 2", " 3"… (case-insensitively,
|
||||
// as macOS and Windows file systems compare names).
|
||||
let base = file_name(name);
|
||||
let stem =
|
||||
(1..).map(|k| if k == 1 { base.clone() } else { format!("{base} {k}") }).find(|n| !used.contains(&n.to_lowercase())).unwrap_or(base);
|
||||
used.push(stem.to_lowercase());
|
||||
let from = next.get(&base.to_lowercase()).copied().unwrap_or(1);
|
||||
let (k, stem) = (from..)
|
||||
.map(|k| (k, if k == 1 { base.clone() } else { format!("{base} {k}") }))
|
||||
.find(|(_, n)| !used.contains(&n.to_lowercase()))
|
||||
.unwrap_or((from, base.clone()));
|
||||
next.insert(base.to_lowercase(), k + 1);
|
||||
used.insert(stem.to_lowercase());
|
||||
let path = std::path::Path::new(dir).join(format!("{stem}.{format}")).to_string_lossy().to_string();
|
||||
match s.execute("file.export", &json!({"ids": [copy.0], "format": format, "scale": scale, "path": path})) {
|
||||
Ok(_) => files.push(path),
|
||||
|
||||
@@ -34,7 +34,7 @@ pub use css::{CssNames, css_var_name, css_var_of};
|
||||
use css::{css, tok};
|
||||
pub(crate) use flutter::{FLUTTER_IMPORT, Place, flutter, flutter_indent};
|
||||
use html::html;
|
||||
pub(crate) use html::{Markup, class_name};
|
||||
pub(crate) use html::{Markup, Names, class_name};
|
||||
pub(crate) use swift::swift;
|
||||
|
||||
pub fn specs() -> Vec<CommandSpec> {
|
||||
|
||||
@@ -30,7 +30,7 @@ fn kind_word(n: &Node) -> &str {
|
||||
/// `rogeuin-hwamyeon`, кнопка → `knopka`, über → `uber` (per-codepoint transliteration, the slug
|
||||
/// libraries' way); a name left with nothing (symbols only) takes `kind`, and one starting with a
|
||||
/// digit keeps the `layer-` prefix.
|
||||
pub(crate) fn class_name(name: &str, kind: &str, used: &mut Vec<String>) -> String {
|
||||
pub(crate) fn class_name(name: &str, kind: &str, used: &mut Names) -> String {
|
||||
let mut base = String::new();
|
||||
for c in deunicode::deunicode(name).chars().flat_map(char::to_lowercase) {
|
||||
if c.is_ascii_alphanumeric() {
|
||||
@@ -57,11 +57,30 @@ pub(crate) fn class_name(name: &str, kind: &str, used: &mut Vec<String>) -> Stri
|
||||
} else {
|
||||
base.to_string()
|
||||
};
|
||||
let name = (1..).map(|k| if k == 1 { base.clone() } else { format!("{base}-{k}") }).find(|n| !used.contains(n)).unwrap_or(base);
|
||||
used.push(name.clone());
|
||||
let from = used.next.get(&base).copied().unwrap_or(1);
|
||||
let (k, name) = (from..)
|
||||
.map(|k| (k, if k == 1 { base.clone() } else { format!("{base}-{k}") }))
|
||||
.find(|(_, n)| !used.used.contains(n))
|
||||
.unwrap_or((from, base.clone()));
|
||||
used.next.insert(base, k + 1);
|
||||
used.insert(name.clone());
|
||||
name
|
||||
}
|
||||
|
||||
/// The names [`class_name`] has given out, and the next suffix to try per base, so many layers
|
||||
/// sharing one name don't each retry every suffix from 2 (that was cubic in their number).
|
||||
#[derive(Default)]
|
||||
pub(crate) struct Names {
|
||||
used: std::collections::BTreeSet<String>,
|
||||
next: std::collections::BTreeMap<String, u64>,
|
||||
}
|
||||
|
||||
impl Names {
|
||||
pub fn insert(&mut self, name: String) {
|
||||
self.used.insert(name);
|
||||
}
|
||||
}
|
||||
|
||||
fn html_escape(s: &str) -> String {
|
||||
s.replace('&', "&").replace('<', "<").replace('>', ">").replace('\n', "<br>")
|
||||
}
|
||||
@@ -90,7 +109,10 @@ pub(super) fn html(doc: &Document, id: NodeId) -> String {
|
||||
let ctx = Ctx::new(doc, id);
|
||||
let mut out = Markup::new(&ctx, CodeLang::Html);
|
||||
out.node(id, None, 0, "");
|
||||
format!("{}\n<style>\n{}{}</style>\n", out.markup, out.tokens.root_rule(), out.styles)
|
||||
// Document text can reach the stylesheet through any property: `<\/` reads back as `</` inside a CSS
|
||||
// string and can never close the element early.
|
||||
let css = format!("{}{}", out.tokens.root_rule(), out.styles).replace("</", "<\\/");
|
||||
format!("{}\n<style>\n{css}</style>\n", out.markup)
|
||||
}
|
||||
|
||||
/// Markup being built for a layer tree: HTML (`class`), React JSX (`className`), Vue
|
||||
@@ -101,7 +123,7 @@ pub(crate) struct Markup<'c, 'a> {
|
||||
ctx: &'c Ctx<'a>,
|
||||
/// Html, React, Vue or Leptos.
|
||||
lang: CodeLang,
|
||||
used: Vec<String>,
|
||||
used: Names,
|
||||
pub markup: String,
|
||||
pub styles: String,
|
||||
pub tokens: Tokens,
|
||||
@@ -158,7 +180,7 @@ impl<'c, 'a> Markup<'c, 'a> {
|
||||
Markup {
|
||||
ctx,
|
||||
lang,
|
||||
used: Vec::new(),
|
||||
used: Names::default(),
|
||||
markup: String::new(),
|
||||
styles: String::new(),
|
||||
tokens: Tokens::default(),
|
||||
@@ -273,7 +295,7 @@ impl<'c, 'a> Markup<'c, 'a> {
|
||||
let root = n.id == self.ctx.root;
|
||||
let class = match self.root_class.take().filter(|_| root) {
|
||||
Some(c) => {
|
||||
self.used.push(c.clone());
|
||||
self.used.insert(c.clone());
|
||||
c
|
||||
}
|
||||
None => {
|
||||
@@ -329,7 +351,7 @@ impl<'c, 'a> Markup<'c, 'a> {
|
||||
let open = open("div");
|
||||
let slot_ident = slot.map(|p| match self.ctx.comp {
|
||||
Some(c) => crate::component_codegen::slot_name(c, p),
|
||||
None => class_name(&p.ident, "slot", &mut Vec::new()),
|
||||
None => class_name(&p.ident, "slot", &mut Names::default()),
|
||||
});
|
||||
if let Some(p) = slot.filter(|_| kids.is_empty()) {
|
||||
let content = if leptos {
|
||||
|
||||
@@ -11,7 +11,9 @@ use figcraft_doc::{Document, NodeId, NodeKind, PropDef};
|
||||
use serde_json::{Value, json};
|
||||
|
||||
use crate::cmd::CommandSpec;
|
||||
use crate::codegen::{CodeLang, Ctx, FLUTTER_IMPORT, Markup, Place, arkui, class_name, compose, flutter, flutter_indent, indent, literal, swift};
|
||||
use crate::codegen::{
|
||||
CodeLang, Ctx, FLUTTER_IMPORT, Markup, Names, Place, arkui, class_name, compose, flutter, flutter_indent, indent, literal, swift,
|
||||
};
|
||||
use crate::components::{prop_default_value, slot_edited, slots_of, variant_options, variant_props, variant_set};
|
||||
use crate::params::{id_of, string, targets};
|
||||
use crate::{bad, spec};
|
||||
@@ -616,14 +618,14 @@ pub(crate) fn value_expr(doc: &Document, c: &Component, p: &Param, value: &Value
|
||||
/// The `<slot name="…">` of a slot parameter: unique among the component's slot parameters, unlike
|
||||
/// `class_name` called with a fresh list per parameter (two idents can lowercase alike).
|
||||
pub(crate) fn slot_name(c: &Component, p: &Param) -> String {
|
||||
let mut used = Vec::new();
|
||||
let mut used = Names::default();
|
||||
for q in c.params.iter().filter(|q| matches!(q.kind, ParamKind::Slot)) {
|
||||
let name = class_name(&q.ident, "slot", &mut used);
|
||||
if q.ident == p.ident {
|
||||
return name;
|
||||
}
|
||||
}
|
||||
class_name(&p.ident, "slot", &mut Vec::new())
|
||||
class_name(&p.ident, "slot", &mut Names::default())
|
||||
}
|
||||
|
||||
/// The values an instance sets for `c`'s parameters, in order (`None` for other layers): variant
|
||||
@@ -720,7 +722,7 @@ pub(crate) fn usage_with_styles(doc: &Document, id: NodeId, lang: CodeLang, dept
|
||||
.filter(|(name, _, _)| is_slot(name))
|
||||
.map(|(name, expr, _)| {
|
||||
let slot = c.params.iter().find(|q| q.ident == *name);
|
||||
let name = slot.map(|p| slot_name(&c, p)).unwrap_or_else(|| class_name(name, "slot", &mut Vec::new()));
|
||||
let name = slot.map(|p| slot_name(&c, p)).unwrap_or_else(|| class_name(name, "slot", &mut Names::default()));
|
||||
format!("{pad} <template #{name}>\n{expr}{pad} </template>\n")
|
||||
})
|
||||
.collect();
|
||||
@@ -823,7 +825,7 @@ pub fn definition(doc: &Document, c: &Component, lang: CodeLang) -> String {
|
||||
|
||||
/// `data-*` attribute names for variant parameters, unique among them (in order).
|
||||
fn data_attrs(variants: &[&Param]) -> Vec<String> {
|
||||
let mut used = Vec::new();
|
||||
let mut used = Names::default();
|
||||
variants.iter().map(|p| format!("data-{}", class_name(&p.prop, "prop", &mut used))).collect()
|
||||
}
|
||||
|
||||
@@ -832,7 +834,7 @@ fn data_attrs(variants: &[&Param]) -> Vec<String> {
|
||||
fn web(doc: &Document, c: &Component, lang: CodeLang) -> (String, String, String) {
|
||||
let ctx = Ctx { doc, root: c.comp, comp: Some(c), base: 2 };
|
||||
let root_name = c.set.and_then(|s| doc.node(s)).or_else(|| doc.node(c.comp)).map(|n| n.name.clone()).unwrap_or_default();
|
||||
let root_class = class_name(&root_name, "component", &mut Vec::new());
|
||||
let root_class = class_name(&root_name, "component", &mut Names::default());
|
||||
let variants: Vec<&Param> = c.params.iter().filter(|p| matches!(p.kind, ParamKind::Variant(_))).collect();
|
||||
let attr_names = data_attrs(&variants);
|
||||
let pass = |root: NodeId| {
|
||||
|
||||
@@ -288,8 +288,10 @@ pub fn layer_changes(before: &Document, now: &Document, id: NodeId) -> Vec<PropC
|
||||
fn order(before: &Document, now: &Document, id: NodeId) -> Option<(usize, usize)> {
|
||||
let parent = now.node(id)?.parent?;
|
||||
let (pb, pa) = (before.node(parent)?, now.node(parent)?);
|
||||
let common_b: Vec<NodeId> = pb.children.iter().rev().copied().filter(|c| pa.children.contains(c)).collect();
|
||||
let common_a: Vec<NodeId> = pa.children.iter().rev().copied().filter(|c| pb.children.contains(c)).collect();
|
||||
let (in_b, in_a): (std::collections::BTreeSet<NodeId>, std::collections::BTreeSet<NodeId>) =
|
||||
(pb.children.iter().copied().collect(), pa.children.iter().copied().collect());
|
||||
let common_b: Vec<NodeId> = pb.children.iter().rev().copied().filter(|c| in_a.contains(c)).collect();
|
||||
let common_a: Vec<NodeId> = pa.children.iter().rev().copied().filter(|c| in_b.contains(c)).collect();
|
||||
let (ib, ia) = (common_b.iter().position(|c| *c == id)?, common_a.iter().position(|c| *c == id)?);
|
||||
(ib != ia).then_some((ib + 1, ia + 1))
|
||||
}
|
||||
|
||||
@@ -475,7 +475,7 @@ pub fn properties_with(doc: &Document, id: NodeId, fmt: ColorFormat) -> Vec<Sect
|
||||
pct(g.refraction),
|
||||
num(g.depth),
|
||||
pct(g.dispersion),
|
||||
num(g.frost),
|
||||
num(g.sanitized().frost),
|
||||
pct(g.splay)
|
||||
),
|
||||
),
|
||||
|
||||
@@ -95,6 +95,32 @@ fn scaling_scales_grain_and_glass() {
|
||||
assert_eq!((g.refraction, nz.density), (d.refraction, 0.5));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn scaling_a_frost_from_an_older_file_starts_from_what_it_draws() {
|
||||
// A frost of 150, saved before the 0–100 range, draws at 100: halved, it draws at 50.
|
||||
let mut s = Session::new();
|
||||
let r = rect(&mut s);
|
||||
s.execute("effect.add", &json!({"ids": [r], "type": "glass"})).unwrap();
|
||||
s.execute("effect.set", &json!({"ids": [r], "index": 0, "effect": {"type": "glass", "frost": 150}})).unwrap();
|
||||
s.execute("transform.scale", &json!({"ids": [r], "factor": 0.5})).unwrap();
|
||||
let EffectKind::Glass(g) = &s.doc().unwrap().node(r).unwrap().effects[0].kind else { panic!() };
|
||||
assert_eq!(g.frost, 50.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn inspect_shows_a_frost_from_an_older_file_as_it_draws() {
|
||||
// A frost of 150, saved before the 0–100 range, draws at 100: Dev Mode says 100 as CSS does.
|
||||
let mut s = Session::new();
|
||||
let r = rect(&mut s);
|
||||
s.execute("effect.add", &json!({"ids": [r], "type": "glass"})).unwrap();
|
||||
s.execute("effect.set", &json!({"ids": [r], "index": 0, "effect": {"type": "glass", "frost": 150}})).unwrap();
|
||||
let doc = s.doc().unwrap();
|
||||
let sections = crate::devinspect::properties(doc, r);
|
||||
let glass = §ions.iter().find(|s| s.title == "Effects").unwrap().rows[0];
|
||||
assert!(glass.value.contains(" frost 100 "), "{}", glass.value);
|
||||
assert!(code_for(doc, r, CodeLang::Css).contains("backdrop-filter: blur(50px);"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn inspect_and_css_show_the_new_effects() {
|
||||
let mut s = Session::new();
|
||||
|
||||
@@ -127,12 +127,15 @@ pub fn topics(v: Option<&Value>) -> Result<Vec<String>, String> {
|
||||
for t in list {
|
||||
let Some(s) = t.as_str() else { return Err("`topics` must be an array of strings".into()) };
|
||||
match s {
|
||||
// Each once: the list is scanned for every retained event under the log's lock, so
|
||||
// a long list of repeats would multiply that work.
|
||||
"comments" | "document" | "all" if out.iter().any(|t| t == s) => {}
|
||||
"comments" | "document" | "all" => out.push(s.to_string()),
|
||||
other => return Err(format!("unknown topic `{other}` (comments, document, all)")),
|
||||
}
|
||||
}
|
||||
if out.is_empty() {
|
||||
out.push("all".into());
|
||||
if out.is_empty() || out.iter().any(|t| t == "all") {
|
||||
out = vec!["all".into()];
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
@@ -193,6 +193,10 @@ fn topics_parse_and_reject_unknown_names() {
|
||||
assert_eq!(events::topics(Some(&json!([]))).unwrap(), vec!["all".to_string()]);
|
||||
assert_eq!(events::topics(Some(&json!(["comments", "document"]))).unwrap(), vec!["comments".to_string(), "document".to_string()]);
|
||||
assert!(events::topics(Some(&json!(["nope"]))).is_err());
|
||||
// Repeats collapse (the list is scanned per event under the log's lock), and `all` is all.
|
||||
let many: Vec<&str> = std::iter::repeat_n("comments", 10_000).chain(["document"]).collect();
|
||||
assert_eq!(events::topics(Some(&json!(many))).unwrap(), vec!["comments".to_string(), "document".to_string()]);
|
||||
assert_eq!(events::topics(Some(&json!(["comments", "all", "document"]))).unwrap(), vec!["all".to_string()]);
|
||||
assert!(events::topics(Some(&json!("comments"))).is_err());
|
||||
}
|
||||
|
||||
|
||||
@@ -149,6 +149,16 @@ fn refusal(m: &Manifest, command: &str, params: &Value) -> Option<String> {
|
||||
if DENIED.iter().any(|p| command.starts_with(p)) && !ALLOWED.contains(&command) {
|
||||
return Some(format!("`{command}` isn't available to plugins"));
|
||||
}
|
||||
// A preview runs its inner command, which the plugin's permissions and the denied list must cover too.
|
||||
// An inner command that can't be previewed (a nested preview) is refused by the preview itself,
|
||||
// before it runs: descending into its parameters first would only rescan them.
|
||||
if command == "text.preview"
|
||||
&& let Some(inner) = get(params, "command").and_then(Value::as_str)
|
||||
&& crate::textpreview::PREVIEWABLE.contains(&inner)
|
||||
&& let Some(why) = refusal(m, inner, get(params, "params").unwrap_or(&Value::Null))
|
||||
{
|
||||
return Some(why);
|
||||
}
|
||||
// A widget's own data is FigCraft's to write, so no plugin can forge or retarget a widget.
|
||||
if writes_widget_data(params, 0) {
|
||||
return Some(format!("plugins can't write `{}…` layer data", crate::widgets::DATA_PREFIX));
|
||||
|
||||
@@ -157,8 +157,9 @@ fn state_of(doc: &Document, w: NodeId) -> Map<String, Value> {
|
||||
/// fields), each once, in layer order.
|
||||
fn names(doc: &Document, w: NodeId, key: &str) -> Vec<String> {
|
||||
let mut out: Vec<String> = Vec::new();
|
||||
let mut seen = std::collections::BTreeSet::new();
|
||||
for t in doc.subtree(w).into_iter().filter_map(|i| doc.node(i)?.plugin_data.get(key).cloned()) {
|
||||
if !out.contains(&t) {
|
||||
if seen.insert(t.clone()) {
|
||||
out.push(t);
|
||||
}
|
||||
}
|
||||
@@ -243,9 +244,7 @@ fn build(s: &mut Session, plugin: &str, w: NodeId, r: &WidgetRender) -> Result<(
|
||||
if !is_widget(n) || n.plugin_data.get(PLUGIN).map(String::as_str) != Some(plugin) {
|
||||
return Err(bad(cmd, "the layer is no longer this plugin's widget"));
|
||||
}
|
||||
for c in n.children.clone() {
|
||||
doc.remove(c)?;
|
||||
}
|
||||
doc.remove_children(w)?;
|
||||
crate::cmd::props::apply(cmd, doc, w, &props(&r.root, true))?;
|
||||
let n = doc.get_mut(w)?;
|
||||
n.locked = false;
|
||||
|
||||
@@ -73,6 +73,20 @@ fn non_ascii_layer_names_transliterate_into_readable_classes() {
|
||||
assert!(code.contains("<p class=\"rogeuin\">") && code.contains("<p class=\"rogeuin-2\">"), "{code}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn many_layers_with_one_name_get_numbered_in_linear_time() {
|
||||
// Each name used to retry every suffix from 2 against a list: cubic in their number.
|
||||
let mut used = crate::codegen::Names::default();
|
||||
let start = std::time::Instant::now();
|
||||
let names: Vec<String> = (0..20_000).map(|_| crate::codegen::class_name("Card / Title", "frame", &mut used)).collect();
|
||||
assert!(start.elapsed() < std::time::Duration::from_secs(5), "{:?}", start.elapsed());
|
||||
assert_eq!(names[0], "card-title");
|
||||
assert_eq!(names[1], "card-title-2");
|
||||
assert_eq!(names[19_999], "card-title-20000");
|
||||
let distinct: std::collections::BTreeSet<&String> = names.iter().collect();
|
||||
assert_eq!(distinct.len(), names.len());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn other_scripts_and_symbol_names_transliterate_or_fall_back_to_the_kind() {
|
||||
let mut s = Session::new();
|
||||
@@ -163,3 +177,16 @@ fn rem_preserves_text_property_default() {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_stylesheet_never_contains_a_closing_style_tag_from_document_text() {
|
||||
let mut s = Session::new();
|
||||
let f = id(s.execute("frame.create", &json!({"x": 0, "y": 0, "width": 100, "height": 100})).unwrap());
|
||||
let t = id(s.execute("text.create", &json!({"text": "x", "x": 0, "y": 0})).unwrap());
|
||||
s.execute("node.set", &json!({"id": t, "props": {"fontFamily": "a</style><script>alert(1)</script>"}})).unwrap();
|
||||
s.execute("node.reparent", &json!({"ids": [t], "parent": f})).unwrap();
|
||||
let code = code_for(s.doc().unwrap(), f, CodeLang::Html);
|
||||
let (_, css) = code.split_once("<style>").unwrap();
|
||||
assert_eq!(css.matches("</style>").count(), 1, "{code}");
|
||||
assert!(!code.contains("<script>"), "{code}");
|
||||
}
|
||||
@@ -277,6 +277,11 @@ fn renaming_several_layers_by_the_documented_codes() {
|
||||
assert_eq!(r(None, "$n", Some(1e30), "a"), "1000000000000");
|
||||
assert_eq!(r(None, "$n", Some(f64::NAN), "a"), "1");
|
||||
assert_eq!(r(Some("é"), "e", None, "café é"), "cafe e");
|
||||
// A template is expanded once per match, so its length is capped (1,000 characters).
|
||||
let long = "$nn".repeat(400);
|
||||
assert!(crate::rename::BatchRename::new(Some("a"), false, &long, None, None).is_err());
|
||||
assert!(crate::rename::BatchRename::new(None, false, "x", Some(&long), None).is_err_and(|e| e.contains("pattern")));
|
||||
assert!(crate::rename::BatchRename::new(Some("a"), false, &"$nn".repeat(300), None, None).is_ok());
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -153,6 +153,30 @@ fn read_only_plugins_and_allowlists_are_enforced() {
|
||||
assert_eq!(node(&s, a).name, "Rectangle");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_preview_is_held_to_the_permissions_of_the_command_it_shows() {
|
||||
let mut s = Session::new();
|
||||
let a = rect(&mut s, 0.0);
|
||||
// Only text.preview is allowed: the node.set it would run is not.
|
||||
install(
|
||||
&mut s,
|
||||
manifest("org.test.previewer", "write", &["text.preview"]),
|
||||
&script(&[("text.preview", json!({"command": "node.set", "params": {"id": a, "props": {"name": "x"}}}))], OnRefusal::Fail, ""),
|
||||
);
|
||||
let e = run_err(&mut s, "org.test.previewer");
|
||||
assert!(e.contains("`node.set` isn't in the commands"), "{e}");
|
||||
assert_eq!(node(&s, a).name, "Rectangle");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_nested_preview_is_refused_by_the_preview_itself() {
|
||||
let mut s = Session::new();
|
||||
let nested = json!({"command": "text.preview", "params": {"command": "node.set", "params": {"props": {"name": "x"}}}});
|
||||
install(&mut s, manifest("org.test.nested", "write", &["text.preview"]), &script(&[("text.preview", nested)], OnRefusal::Fail, ""));
|
||||
let e = run_err(&mut s, "org.test.nested");
|
||||
assert!(e.contains("can't be previewed"), "{e}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn files_dialogs_history_and_plugins_are_off_limits() {
|
||||
let mut s = Session::new();
|
||||
|
||||
@@ -9,6 +9,9 @@ use figcraft_doc::{Document, NodeId};
|
||||
|
||||
/// Longest match pattern accepted (characters).
|
||||
const MAX_FIND: usize = 1_000;
|
||||
/// Longest replacement or pattern template accepted (characters): each is expanded again for
|
||||
/// every match, so its length multiplies the work of a rename.
|
||||
const MAX_TEMPLATE: usize = 1_000;
|
||||
/// Longest name a rename produces (characters).
|
||||
const MAX_NAME: usize = 10_000;
|
||||
/// Widest zero padding of a number code.
|
||||
@@ -50,6 +53,12 @@ impl BatchRename {
|
||||
}
|
||||
Some(f) => Some(Find::Text(f.to_string())),
|
||||
};
|
||||
if replace.chars().count() > MAX_TEMPLATE {
|
||||
return Err(format!("the replacement is longer than {MAX_TEMPLATE} characters"));
|
||||
}
|
||||
if pattern.is_some_and(|p| p.chars().count() > MAX_TEMPLATE) {
|
||||
return Err(format!("the pattern is longer than {MAX_TEMPLATE} characters"));
|
||||
}
|
||||
let start = start.filter(|s| s.is_finite()).map_or(1, |s| s.clamp(0.0, 1e12).round() as u64);
|
||||
Ok(Self { find, replace: replace.to_string(), pattern: pattern.map(str::to_string), start })
|
||||
}
|
||||
|
||||
@@ -217,6 +217,15 @@ fn remove_mode_and_escape() {
|
||||
assert!(s.execute("shapeBuilder.mode", &json!({"mode": "sideways"})).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_group_named_many_times_is_walked_once() {
|
||||
let mut s = Session::new();
|
||||
let (a, b) = squares(&mut s);
|
||||
let g = id(&ex(&mut s, "object.group", json!({"ids": [a, b]})));
|
||||
let r = ex(&mut s, "shapeBuilder.regions", json!({"ids": vec![g; 500]}));
|
||||
assert_eq!(r["sources"], json!([a, b]));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn groups_rotated_and_ineligible_layers() {
|
||||
let mut s = Session::new();
|
||||
|
||||
@@ -72,6 +72,9 @@ use kiwi::{Kv, Schema};
|
||||
/// Largest `canvas.fig` member read, and largest decompressed chunk.
|
||||
const MAX_CANVAS: u64 = 256 * 1024 * 1024;
|
||||
const MAX_CHUNK: u64 = 512 * 1024 * 1024;
|
||||
/// Largest decompressed schema chunk: Figma's schema unpacks to well under 1 MB, so a schema that
|
||||
/// inflates past this is refused before its definitions are decoded.
|
||||
const MAX_SCHEMA: u64 = 16 * 1024 * 1024;
|
||||
/// Largest image member read.
|
||||
const MAX_IMAGE: u64 = figcraft_doc::ImageData::MAX_BYTES;
|
||||
/// Total decompressed ZIP image bytes read per import: the native image budget (`IMAGE_BUDGET`) on
|
||||
@@ -324,7 +327,7 @@ fn decode_canvas(canvas: &[u8]) -> Result<(Schema, Vec<u8>), FormatError> {
|
||||
let (Some(schema), Some(message)) = (it.next(), it.next()) else {
|
||||
return Err(corrupt("canvas.fig needs a schema and a message chunk"));
|
||||
};
|
||||
let schema = Schema::decode(&inflate(schema)?).map_err(|e| corrupt(e.to_string()))?;
|
||||
let schema = Schema::decode(&inflate_within(schema, MAX_SCHEMA)?).map_err(|e| corrupt(e.to_string()))?;
|
||||
Ok((schema, inflate(message)?))
|
||||
}
|
||||
|
||||
@@ -347,18 +350,23 @@ fn chunks(canvas: &[u8]) -> Result<Vec<&[u8]>, FormatError> {
|
||||
|
||||
/// Decompress a chunk: zstd (by its magic number), else raw deflate, else zlib.
|
||||
fn inflate(data: &[u8]) -> Result<Vec<u8>, FormatError> {
|
||||
fn capped(r: impl Read) -> Option<Vec<u8>> {
|
||||
inflate_within(data, MAX_CHUNK)
|
||||
}
|
||||
|
||||
/// [`inflate`] refusing a chunk that unpacks to more than `max` bytes.
|
||||
fn inflate_within(data: &[u8], max: u64) -> Result<Vec<u8>, FormatError> {
|
||||
let capped = |r: &mut dyn Read| -> Option<Vec<u8>> {
|
||||
let mut out = Vec::new();
|
||||
r.take(MAX_CHUNK + 1).read_to_end(&mut out).ok()?;
|
||||
(out.len() as u64 <= MAX_CHUNK).then_some(out)
|
||||
}
|
||||
r.take(max.saturating_add(1)).read_to_end(&mut out).ok()?;
|
||||
(out.len() as u64 <= max).then_some(out)
|
||||
};
|
||||
if data.starts_with(&[0x28, 0xB5, 0x2F, 0xFD]) {
|
||||
let mut src = data;
|
||||
let dec = ruzstd::decoding::StreamingDecoder::new(&mut src).map_err(|e| corrupt(format!("zstd: {e}")))?;
|
||||
return capped(dec).ok_or_else(|| corrupt("damaged or oversized zstd chunk"));
|
||||
let mut dec = ruzstd::decoding::StreamingDecoder::new(&mut src).map_err(|e| corrupt(format!("zstd: {e}")))?;
|
||||
return capped(&mut dec).ok_or_else(|| corrupt("damaged or oversized zstd chunk"));
|
||||
}
|
||||
capped(flate2::read::DeflateDecoder::new(data))
|
||||
.or_else(|| capped(flate2::read::ZlibDecoder::new(data)))
|
||||
capped(&mut flate2::read::DeflateDecoder::new(data))
|
||||
.or_else(|| capped(&mut flate2::read::ZlibDecoder::new(data)))
|
||||
.ok_or_else(|| corrupt("damaged or oversized deflate chunk"))
|
||||
}
|
||||
|
||||
|
||||
@@ -234,7 +234,7 @@ impl<'d> Exporter<'d> {
|
||||
}
|
||||
EffectKind::Glass(g) => {
|
||||
self.warn("glass effects keep only their frost");
|
||||
f.extend([("type", e("GLASS")), ("radius", fl(g.frost))]);
|
||||
f.extend([("type", e("GLASS")), ("radius", fl(g.sanitized().frost))]);
|
||||
}
|
||||
}
|
||||
o(f)
|
||||
|
||||
@@ -1243,6 +1243,25 @@ fn local_samples_round_trip() {
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_glass_frost_is_written_as_it_draws() {
|
||||
// A frost saved before the 0–100 range (or not a number) is written at what it draws: 100, or
|
||||
// the default.
|
||||
for (frost, written) in [(12.0, 12.0), (500.0, Glass::MAX_FROST), (f64::NAN, Glass::default().frost)] {
|
||||
let mut doc = Document::new("glass");
|
||||
let page = doc.first_page().unwrap();
|
||||
let r = doc.create(page, NodeKind::Rectangle, "Pane", 0.0, 0.0, 24.0, 24.0).unwrap();
|
||||
doc.get_mut(r).unwrap().effects = vec![Effect { kind: EffectKind::Glass(Glass { frost, ..Glass::default() }), visible: true }];
|
||||
let (bytes, _) = export(&doc, None).unwrap();
|
||||
let archive = Archive::open(&bytes).unwrap();
|
||||
let (schema, message) = decode_canvas(&archive.canvas).unwrap();
|
||||
let msg = schema.decode_message(schema.find("Message").unwrap(), &message).unwrap();
|
||||
let pane = msg.get("nodeChanges").unwrap().list().iter().find(|nc| nc.get("name").and_then(Kv::str) == Some("Pane")).unwrap();
|
||||
let radius = pane.get("effects").unwrap().list()[0].get("radius").and_then(Kv::f64).unwrap();
|
||||
assert_eq!(radius, written, "frost {frost}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_vector_drawable_export_setting_is_written_as_svg_with_a_warning() {
|
||||
let mut doc = Document::new("vd");
|
||||
|
||||
@@ -6,6 +6,7 @@
|
||||
//! Everything here reads untrusted bytes: reads are bounds-checked, nesting is capped, array
|
||||
//! counts can't exceed the bytes left, and the total number of decoded values is capped.
|
||||
|
||||
use std::collections::HashMap;
|
||||
use std::fmt;
|
||||
|
||||
/// Deepest struct/message nesting decoded.
|
||||
@@ -32,6 +33,9 @@ const MAX_VALUES: usize = 32 << 20;
|
||||
/// Most definitions in a schema, and fields in one definition.
|
||||
const MAX_DEFS: usize = 10_000;
|
||||
const MAX_FIELDS: usize = 10_000;
|
||||
/// Most fields in a schema, every definition together: Figma's own schema has a few thousand, and
|
||||
/// without a total a schema of [`MAX_DEFS`] wide definitions could hold 100 million field records.
|
||||
const MAX_SCHEMA_FIELDS: usize = 200_000;
|
||||
|
||||
#[derive(Debug, PartialEq, Eq)]
|
||||
pub struct KiwiError(pub String);
|
||||
@@ -252,6 +256,7 @@ impl Schema {
|
||||
}
|
||||
let mut defs = Vec::with_capacity(count);
|
||||
let mut raw_types = Vec::new();
|
||||
let mut total_fields = 0usize;
|
||||
for _ in 0..count {
|
||||
let name = r.string()?;
|
||||
let kind = match r.byte()? {
|
||||
@@ -261,7 +266,8 @@ impl Schema {
|
||||
k => return err(format!("schema: unknown definition kind {k}")),
|
||||
};
|
||||
let n = r.var_uint()? as usize;
|
||||
if n > MAX_FIELDS || n > r.left() {
|
||||
total_fields = total_fields.saturating_add(n);
|
||||
if n > MAX_FIELDS || n > r.left() || total_fields > MAX_SCHEMA_FIELDS {
|
||||
return err("schema: too many fields");
|
||||
}
|
||||
let mut fields = Vec::with_capacity(n);
|
||||
@@ -308,7 +314,7 @@ impl Schema {
|
||||
|
||||
/// [`Self::decode_message`] within `budget` values (see [`value_budget`]).
|
||||
pub fn decode_message_within<'s>(&'s self, root: usize, data: &[u8], budget: usize) -> Result<Kv<'s>, KiwiError> {
|
||||
let mut d = Decoder { schema: self, r: Reader { data, pos: 0 }, budget };
|
||||
let mut d = Decoder { schema: self, r: Reader { data, pos: 0 }, budget, ids: vec![None; self.defs.len()] };
|
||||
d.def(root, 0)
|
||||
}
|
||||
}
|
||||
@@ -322,6 +328,10 @@ struct Decoder<'s, 'b> {
|
||||
schema: &'s Schema,
|
||||
r: Reader<'b>,
|
||||
budget: usize,
|
||||
/// Per definition, the index of the first field with each id (message field ids, enum
|
||||
/// values), built the first time the definition is decoded: a message can carry many tags
|
||||
/// against a wide definition, and a scan per tag would multiply the two.
|
||||
ids: Vec<Option<HashMap<u32, usize>>>,
|
||||
}
|
||||
|
||||
impl<'s> Decoder<'s, '_> {
|
||||
@@ -330,6 +340,19 @@ impl<'s> Decoder<'s, '_> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// The first field of definition `i` with id (or enum value) `id`.
|
||||
fn field_by_id(&mut self, i: usize, id: u32) -> Option<&'s Field> {
|
||||
let fields = &self.schema.defs.get(i)?.fields;
|
||||
let ids = self.ids.get_mut(i)?.get_or_insert_with(|| {
|
||||
let mut m = HashMap::with_capacity(fields.len());
|
||||
for (j, f) in fields.iter().enumerate() {
|
||||
m.entry(f.value).or_insert(j);
|
||||
}
|
||||
m
|
||||
});
|
||||
fields.get(*ids.get(&id)?)
|
||||
}
|
||||
|
||||
fn def(&mut self, i: usize, depth: usize) -> Result<Kv<'s>, KiwiError> {
|
||||
if depth > MAX_DEPTH {
|
||||
return err("message: nested too deeply");
|
||||
@@ -340,7 +363,7 @@ impl<'s> Decoder<'s, '_> {
|
||||
match d.kind {
|
||||
Kind::Enum => {
|
||||
let v = self.r.var_uint()?;
|
||||
Ok(d.fields.iter().find(|f| f.value == v).map_or(Kv::Uint(u64::from(v)), |f| Kv::Enum(f.name.as_str())))
|
||||
Ok(self.field_by_id(i, v).map_or(Kv::Uint(u64::from(v)), |f| Kv::Enum(f.name.as_str())))
|
||||
}
|
||||
Kind::Struct => {
|
||||
let mut out = Vec::with_capacity(d.fields.len());
|
||||
@@ -358,7 +381,7 @@ impl<'s> Decoder<'s, '_> {
|
||||
out.shrink_to_fit();
|
||||
return Ok(Kv::Object(out));
|
||||
}
|
||||
let f = d.fields.iter().find(|f| f.value == id).ok_or_else(|| KiwiError(format!("message: {} has no field {id}", d.name)))?;
|
||||
let f = self.field_by_id(i, id).ok_or_else(|| KiwiError(format!("message: {} has no field {id}", d.name)))?;
|
||||
out.push((f.name.as_str(), self.field(f, depth)?));
|
||||
}
|
||||
}
|
||||
@@ -379,8 +402,9 @@ impl<'s> Decoder<'s, '_> {
|
||||
if n > self.r.left() {
|
||||
return err("message: array longer than the data");
|
||||
}
|
||||
// The field itself counts, so empty arrays can't pile up for free.
|
||||
self.spend(1)?;
|
||||
if ty == Type::Byte {
|
||||
self.spend(1)?;
|
||||
return Ok(Kv::Bytes(self.r.take(n)?.to_vec()));
|
||||
}
|
||||
self.spend(n)?;
|
||||
|
||||
@@ -1179,6 +1179,60 @@ fn scalar_fields_count_against_the_value_budget() {
|
||||
assert!(sc.decode_message_within(0, &data, 1001).is_ok());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn empty_arrays_count_against_the_value_budget() {
|
||||
// 1000 empty `uint[]` fields: each field is a value even with no elements, so a small budget
|
||||
// can't be outgrown by piling up empty containers.
|
||||
let fields = vec![Field { name: "a".into(), ty: Some(Type::Uint), array: true, value: 1 }];
|
||||
let sc = Schema { defs: vec![Def { name: "Message".into(), kind: Kind::Message, fields }] };
|
||||
let mut data = [1u8, 0].repeat(1000);
|
||||
data.push(0);
|
||||
let e = sc.decode_message_within(0, &data, 10).unwrap_err();
|
||||
assert_eq!(e.0, "message: too many values");
|
||||
assert!(sc.decode_message_within(0, &data, 1001).is_ok());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn message_tags_find_their_field_by_id_in_a_wide_definition() {
|
||||
// A wide definition: every tag is looked up by id, and the first field with an id wins, as
|
||||
// before the lookup was indexed.
|
||||
let mut fields: Vec<Field> = (1..=5000).map(|i| Field { name: format!("f{i}"), ty: Some(Type::Bool), array: false, value: i }).collect();
|
||||
fields.push(Field { name: "shadow".into(), ty: Some(Type::Bool), array: false, value: 7 });
|
||||
let sc = Schema { defs: vec![Def { name: "Message".into(), kind: Kind::Message, fields }] };
|
||||
let mut w = encode::Writer::default();
|
||||
for _ in 0..20_000 {
|
||||
w.var_uint(5000);
|
||||
w.byte(1);
|
||||
}
|
||||
w.var_uint(7);
|
||||
w.byte(0);
|
||||
w.var_uint(0);
|
||||
let Kv::Object(out) = sc.decode_message(0, &w.0).unwrap() else { panic!() };
|
||||
assert_eq!(out.len(), 20_001);
|
||||
assert!(out.iter().take(20_000).all(|(n, v)| *n == "f5000" && *v == Kv::Bool(true)));
|
||||
assert_eq!(out.last().map(|(n, _)| *n), Some("f7"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_schema_is_refused_past_its_total_field_count() {
|
||||
// 25 definitions of 10 000 fields each: every one is within the per-definition cap, but
|
||||
// together they pass the schema's total.
|
||||
let mut w = encode::Writer::default();
|
||||
w.var_uint(25);
|
||||
for d in 0..25 {
|
||||
w.string(&format!("D{d}"));
|
||||
w.byte(0);
|
||||
w.var_uint(10_000);
|
||||
for i in 0..10_000u32 {
|
||||
w.string("");
|
||||
w.var_int(0);
|
||||
w.byte(0);
|
||||
w.var_uint(i);
|
||||
}
|
||||
}
|
||||
assert_eq!(Schema::decode(&w.0).unwrap_err().0, "schema: too many fields");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hostile_input_is_refused() {
|
||||
// A message that contains itself, nested past the depth cap.
|
||||
|
||||
@@ -1028,6 +1028,11 @@ pub fn write_file_atomic(path: &std::path::Path, bytes: &[u8]) -> std::io::Resul
|
||||
let tmp = std::path::PathBuf::from(name);
|
||||
match std::fs::OpenOptions::new().write(true).create_new(true).open(&tmp) {
|
||||
Ok(mut file) => {
|
||||
// The replacement keeps the destination's permissions from the start, so a private
|
||||
// file's content is never readable under default ones (the open handle still writes).
|
||||
if let Ok(old) = std::fs::metadata(path) {
|
||||
let _ = file.set_permissions(old.permissions());
|
||||
}
|
||||
if let Err(e) = file.write_all(bytes) {
|
||||
let _ = std::fs::remove_file(&tmp);
|
||||
return Err(e);
|
||||
|
||||
@@ -226,11 +226,16 @@ impl<'b> Archive<'b> {
|
||||
};
|
||||
let refs = document.get("pages").and_then(Value::as_array).map(Vec::as_slice).unwrap_or_default();
|
||||
let mut pages = Vec::new();
|
||||
let mut seen = std::collections::HashSet::new();
|
||||
for r in refs.iter().take(MAX_PAGES) {
|
||||
let Some(id) = r.get("_ref").and_then(Value::as_str).and_then(|s| s.strip_prefix("pages/")).filter(|id| valid_id(id)) else {
|
||||
warnings.push("pages the document lists without a valid reference were skipped".into());
|
||||
continue;
|
||||
};
|
||||
// A page listed twice is read once: a repeated reference must not repeat the unpacking.
|
||||
if !seen.insert(id) {
|
||||
continue;
|
||||
}
|
||||
match json_member(&mut z, &format!("pages/{id}.json"), max_member, &mut total) {
|
||||
Ok(page) if page.is_object() => pages.push((id.to_string(), page)),
|
||||
Ok(_) => warnings.push("pages that aren't JSON objects were skipped".into()),
|
||||
|
||||
@@ -35,6 +35,13 @@ fn pages_become_pages_in_document_order() {
|
||||
assert_eq!(page_names(&doc), ["Beta", "Alpha"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_page_listed_twice_is_imported_once() {
|
||||
let z = sketch_zip("50.2", 103, document(&["A", "A", "A"]), &[page("A", "Alpha", vec![])], &[]);
|
||||
let (doc, _) = import(&z, "f").unwrap();
|
||||
assert_eq!(page_names(&doc), ["Alpha"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn older_than_48_is_refused() {
|
||||
let z = sketch_zip("47.1", 95, document(&["P"]), &[page("P", "P", vec![])], &[]);
|
||||
|
||||
@@ -123,3 +123,17 @@ fn a_failed_write_leaves_the_destination_alone_and_cleans_up() {
|
||||
}
|
||||
let _ = std::fs::remove_dir_all(&d);
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn a_replaced_file_keeps_its_permissions() {
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
let d = dir("mode");
|
||||
let path = d.join("a.figcraft");
|
||||
std::fs::write(&path, b"old").unwrap();
|
||||
std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o600)).unwrap();
|
||||
write_file_atomic(&path, b"new").unwrap();
|
||||
assert_eq!(std::fs::read(&path).unwrap(), b"new");
|
||||
assert_eq!(std::fs::metadata(&path).unwrap().permissions().mode() & 0o777, 0o600);
|
||||
let _ = std::fs::remove_dir_all(&d);
|
||||
}
|
||||
@@ -629,14 +629,26 @@ fn distribute(items: &mut [Item], mut open: Vec<usize>, free: f64) {
|
||||
.collect();
|
||||
let violation: f64 = sized.iter().map(|(_, want, v)| v - want).sum();
|
||||
let frozen = |want: f64, v: f64| violation.abs() < 1e-9 || (violation > 0.0 && v > want + 1e-9) || (violation < 0.0 && v < want - 1e-9);
|
||||
let mut progressed = false;
|
||||
for (i, want, v) in &sized {
|
||||
if frozen(*want, *v)
|
||||
&& let Some(it) = items.get_mut(*i)
|
||||
{
|
||||
it.main = *v;
|
||||
free -= *v;
|
||||
progressed = true;
|
||||
}
|
||||
}
|
||||
if !progressed {
|
||||
// Several clampings each under the tolerance added up past it, so none froze: settle
|
||||
// them all as clamped rather than go round again with nothing changed.
|
||||
for (i, _, v) in &sized {
|
||||
if let Some(it) = items.get_mut(*i) {
|
||||
it.main = *v;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
free = free.max(0.0);
|
||||
open = sized.into_iter().filter(|(_, want, v)| !frozen(*want, *v)).map(|(i, _, _)| i).collect();
|
||||
}
|
||||
|
||||
@@ -447,3 +447,24 @@ fn grid_hostile_values() {
|
||||
assert!(x.is_finite() && y.is_finite() && w.is_finite() && h.is_finite());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fill_children_whose_tiny_clampings_add_up_past_the_tolerance_still_settle() {
|
||||
// Three fill children sharing 300 px, each with a minimum 5e-10 over its 100 px share: no
|
||||
// single clamping passes the 1e-9 tolerance, but together they do, so no child froze and the
|
||||
// distribution loop went round forever without changing anything.
|
||||
let mut d = Document::new("t");
|
||||
let p = d.first_page().unwrap();
|
||||
let f = d.create(p, NodeKind::Frame, "F", 0.0, 0.0, 300.0, 100.0).unwrap();
|
||||
d.get_mut(f).unwrap().layout = Some(AutoLayout { mode: LayoutMode::Horizontal, gap: 0.0, padding: [0.0; 4], ..Default::default() });
|
||||
let kids: Vec<NodeId> = (0..3).map(|i| d.create(f, NodeKind::Rectangle, "K", 0.0, 0.0, 10.0, 20.0 + i as f64).unwrap()).collect();
|
||||
for k in &kids {
|
||||
let n = d.get_mut(*k).unwrap();
|
||||
n.child_layout.sizing_h = Sizing::Fill;
|
||||
n.child_layout.min_w = Some(100.0 + 5e-10);
|
||||
}
|
||||
layout_frame(&mut d, f, &NoMeasure);
|
||||
for k in &kids {
|
||||
assert!((pos(&d, *k).2 - 100.0).abs() < 1e-6, "{:?}", pos(&d, *k));
|
||||
}
|
||||
}
|
||||
@@ -128,7 +128,7 @@ pub fn get(name: &str, args: &Value) -> Result<Value, String> {
|
||||
if !(args.is_object() || args.is_null()) {
|
||||
return Err("`arguments` must be an object of strings".into());
|
||||
}
|
||||
let mut text = p.template.replace("{verify}", VERIFY);
|
||||
let mut values: Vec<(&str, String)> = vec![("verify", VERIFY.to_string())];
|
||||
for a in p.args {
|
||||
let v = match args.get(a.name) {
|
||||
Some(Value::String(s)) if !s.trim().is_empty() => s.clone(),
|
||||
@@ -142,7 +142,49 @@ pub fn get(name: &str, args: &Value) -> Result<Value, String> {
|
||||
Some(Value::String(_)) => p.defaults.iter().find(|(k, _)| *k == a.name).map(|(_, d)| (*d).to_string()).unwrap_or_default(),
|
||||
Some(_) => return Err(format!("argument `{}` must be a string", a.name)),
|
||||
};
|
||||
text = text.replace(&format!("{{{}}}", a.name), &v);
|
||||
values.push((a.name, v));
|
||||
}
|
||||
// One pass over the template, so an argument's text is never read as `{…}` syntax itself (a
|
||||
// value holding placeholders used to be expanded again by every later replacement).
|
||||
let mut text = String::with_capacity(p.template.len());
|
||||
let mut rest = p.template;
|
||||
while let Some(open) = rest.find('{') {
|
||||
text.push_str(rest.get(..open).unwrap_or_default());
|
||||
let after = rest.get(open..).unwrap_or_default();
|
||||
let found = after.find('}').and_then(|close| {
|
||||
let key = after.get(1..close)?;
|
||||
values.iter().find(|(k, _)| *k == key).map(|(_, v)| (close, v.as_str()))
|
||||
});
|
||||
match found {
|
||||
Some((close, v)) => {
|
||||
text.push_str(v);
|
||||
rest = after.get(close + 1..).unwrap_or_default();
|
||||
}
|
||||
None => {
|
||||
text.push('{');
|
||||
rest = after.get(1..).unwrap_or_default();
|
||||
}
|
||||
}
|
||||
}
|
||||
text.push_str(rest);
|
||||
Ok(json!({"description": p.description, "messages": [{"role": "user", "content": {"type": "text", "text": text}}]}))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn arguments_are_text_not_template_syntax() {
|
||||
let text = |args: Value| get("mobile_screen", &args).unwrap()["messages"][0]["content"]["text"].as_str().unwrap().to_string();
|
||||
let plain = text(json!({"screen": "login"}));
|
||||
assert!(plain.contains("Design a login screen") && plain.contains("iPhone 16") && plain.ends_with(VERIFY), "{plain}");
|
||||
assert!(!plain.contains("{screen}") && !plain.contains("{verify}"), "{plain}");
|
||||
// A value made of placeholders stays as typed, however many there are: it is never
|
||||
// expanded again by the replacements after it (that multiplied the output without bound).
|
||||
let bomb = "{device}{brand_color}{verify}".repeat(1000);
|
||||
let out = text(json!({"screen": bomb.clone()}));
|
||||
assert!(out.contains(&bomb));
|
||||
assert!(out.len() < 3 * bomb.len(), "{}", out.len());
|
||||
}
|
||||
}
|
||||
@@ -131,7 +131,9 @@ pub fn outline(path: &BezPath, width: f64, props: &StrokeProps, brush: &Brush) -
|
||||
let p = preset(&brush.preset)?;
|
||||
let unit = shape(p.id)?;
|
||||
let lines = polylines(path)?;
|
||||
let scale = |t: f64| width * props.profile().map_or(1.0, |pr| pr.scale_at(t));
|
||||
// Sanitized once: at most 64 points, so each sample's symmetry scan stays cheap.
|
||||
let profile = props.profile().map(|pr| pr.sanitized());
|
||||
let scale = |t: f64| width * profile.as_ref().map_or(1.0, |pr| pr.scale_at(t));
|
||||
let mut out = BezPath::new();
|
||||
match p.kind {
|
||||
BrushKind::Stretch => {
|
||||
|
||||
@@ -72,3 +72,14 @@ fn a_width_profile_scales_the_brush() {
|
||||
let (first, last) = (parts.first().unwrap().bounding_box(), parts.last().unwrap().bounding_box());
|
||||
assert!(last.width() > first.width() * 3.0, "{first:?} {last:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_unsanitized_profile_is_bounded_before_sampling() {
|
||||
// 100k points, all past the 64-point cap and out of range: the brush reads the clamped profile.
|
||||
let raw = WidthProfile { points: (0..100_000).map(|i| figcraft_doc::WidthPoint::new(f64::from(i), 1e300)).collect() };
|
||||
let b = brush("taper");
|
||||
let mut p = props(1.0, &b);
|
||||
p.width_profile = Some(raw);
|
||||
let out = outline(&line(50.0), 1.0, &p, &b).unwrap();
|
||||
assert!(out.bounding_box().height() <= 2.0 * WidthProfile::MAX_SCALE);
|
||||
}
|
||||
+13
-3
@@ -1,7 +1,7 @@
|
||||
//! Text: real, selectable text in embedded (subset) fonts, positioned glyph by glyph from the
|
||||
//! `figcraft_text` layout the renderer uses, with outline fallbacks.
|
||||
|
||||
use std::collections::BTreeSet;
|
||||
use std::collections::{BTreeMap, BTreeSet};
|
||||
use std::ops::Range;
|
||||
use std::sync::Arc;
|
||||
|
||||
@@ -56,14 +56,24 @@ pub(crate) fn draw_text(ex: &mut Exporter, s: &mut Surface, n: &Node, xf: Affine
|
||||
let styles: BTreeSet<usize> = layout.glyphs.iter().map(|g| g.style).chain(layout.decorations.iter().map(|d| d.style)).collect();
|
||||
// Every run's fills, then the inner shadows over them, then the strokes on top.
|
||||
let mut stroked = Vec::new();
|
||||
// Glyphs and decorations are grouped by style in one pass; each style's paths are built (and
|
||||
// dropped) inside its own iteration, so only one style's paths are held at a time.
|
||||
let mut decoration_of: BTreeMap<usize, Vec<usize>> = BTreeMap::new();
|
||||
for (i, d) in layout.decorations.iter().enumerate() {
|
||||
decoration_of.entry(d.style).or_default().push(i);
|
||||
}
|
||||
let mut glyph_of: BTreeMap<usize, Vec<usize>> = BTreeMap::new();
|
||||
for (i, g) in layout.glyphs.iter().enumerate() {
|
||||
glyph_of.entry(g.style).or_default().push(i);
|
||||
}
|
||||
for k in styles {
|
||||
let fills = layout.styles.get(k).and_then(|st| st.fills.as_ref()).unwrap_or(&n.fills);
|
||||
let mut decorations = BezPath::new();
|
||||
for d in layout.decorations.iter().filter(|d| d.style == k) {
|
||||
for d in decoration_of.remove(&k).unwrap_or_default().into_iter().filter_map(|i| layout.decorations.get(i)) {
|
||||
decorations.extend(d.path());
|
||||
}
|
||||
let mut outlines = BezPath::new();
|
||||
for g in layout.glyphs.iter().filter(|g| g.style == k) {
|
||||
for g in glyph_of.remove(&k).unwrap_or_default().into_iter().filter_map(|i| layout.glyphs.get(i)) {
|
||||
outlines.extend(g.path());
|
||||
}
|
||||
outlines.extend(decorations.iter());
|
||||
|
||||
@@ -1031,6 +1031,11 @@ fn masked_area(ctx: &Ctx, pix: &Pixmap, mask_id: NodeId, content: &[NodeId], xf:
|
||||
/// Mask `m` drawn as if it weren't a mask into a `w` × `h` pixmap at `xf` (a vector mask: its
|
||||
/// outline, fully opaque).
|
||||
fn mask_pixels(ctx: &Ctx, m: &Node, (w, h): (u32, u32), xf: Affine, depth: usize) -> Option<Pixmap> {
|
||||
// A mask's content is drawn here, not through `draw_layer`, so a chain of masks inside
|
||||
// masks needs the nesting limit checked here too, or it runs down the stack.
|
||||
if depth > crate::MAX_EXPORT_DEPTH {
|
||||
return None;
|
||||
}
|
||||
let mut mask_px = Pixmap::new(w, h)?;
|
||||
let mut m2 = m.clone();
|
||||
m2.is_mask = false;
|
||||
|
||||
@@ -78,6 +78,20 @@ fn decoding_is_capped() {
|
||||
assert!(images::decode_frames(&huge).is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_large_partial_frame_plays_when_two_whole_frames_fit() {
|
||||
// Canvas 4000 x 3000 (48 MB a frame, two fit the cap) with a 3500 x 2800 second frame: the
|
||||
// decoder's canvas, composited output and partial frame together need more than the cap.
|
||||
let mut out = Vec::new();
|
||||
{
|
||||
let mut enc = GifEncoder::new(&mut out);
|
||||
enc.set_repeat(Repeat::Infinite).unwrap();
|
||||
let frame = |w, h, c| Frame::from_parts(RgbaImage::from_pixel(w, h, image::Rgba(c)), 0, 0, Delay::from_numer_denom_ms(100, 1));
|
||||
enc.encode_frames([frame(4000, 3000, RED), frame(3500, 2800, GREEN)]).unwrap();
|
||||
}
|
||||
assert_eq!(images::decode_frames(&out).map(|f| f.len()), Some(2));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_first_frame_draws_unless_time_moves_on() {
|
||||
let mut d = Document::new("t");
|
||||
@@ -98,3 +112,16 @@ fn the_first_frame_draws_unless_time_moves_on() {
|
||||
d.get_mut(id).unwrap().visible = false;
|
||||
assert!(images::animation_clock(&d, page, 0.15).is_none(), "hidden layers don't keep the presenter awake");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_frame_descriptor_bigger_than_the_canvas_is_refused_before_it_is_allocated() {
|
||||
// A 4 × 4 canvas whose first frame descriptor claims 16,383 × 16,383 (a gigabyte of RGBA):
|
||||
// the decoder's limits refuse the frame buffer instead of allocating it.
|
||||
let mut bytes = gif(&[(RED, 100), (GREEN, 100)], 4, 4);
|
||||
let at = bytes.windows(9).position(|w| w == [0x2c, 0, 0, 0, 0, 4, 0, 4, 0]).expect("an image descriptor for a 4 × 4 frame");
|
||||
let (w, h) = ((16_383u16).to_le_bytes(), (16_383u16).to_le_bytes());
|
||||
bytes[at + 5..at + 9].copy_from_slice(&[w[0], w[1], h[0], h[1]]);
|
||||
let start = std::time::Instant::now();
|
||||
assert!(images::decode_frames(&bytes).is_none());
|
||||
assert!(start.elapsed() < std::time::Duration::from_secs(5), "{:?}", start.elapsed());
|
||||
}
|
||||
+175
-17
@@ -1,9 +1,12 @@
|
||||
//! The glass effect: the backdrop seen through a pane whose edges curve down like a lens.
|
||||
//!
|
||||
//! Within `depth` of the outline the surface curves: the backdrop there is bent towards the inside
|
||||
//! (strongest at the very edge, `refraction` × `depth` far), each colour channel by a slightly
|
||||
//! different amount (`dispersion`, a rainbow fringe), and the rim catches the light: brightest
|
||||
//! where it faces `light_angle`, half as bright on the opposite side, spread wider by `splay`.
|
||||
//! Within `depth` of the outline the surface curves like a thick lens: the backdrop there is bent
|
||||
//! towards the inside, most a [`BEVEL`] in from the edge (`refraction` × `depth` far), falling off
|
||||
//! as the 3.5th power of the way out of the curve and gone `depth` further in, with a fifth as
|
||||
//! much on the bevel itself ([`bend_at`]). Each colour channel bends by a different amount
|
||||
//! (`dispersion`, a rainbow fringe: red furthest, blue least, each smeared along the bend), and the
|
||||
//! rim catches the light: brightest where it faces `light_angle`, half as bright on the opposite
|
||||
//! side, spread wider by `splay`.
|
||||
//! `frost` blurs the backdrop first. Distances to the outline come from an exact Euclidean
|
||||
//! distance transform of the shape's coverage.
|
||||
//!
|
||||
@@ -162,6 +165,70 @@ fn smooth_normals(dist: &[f32], w: usize, h: usize, r: usize) -> Vec<(f32, f32)>
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// The bevel along a glass's edge (document units): where the bend eases off before the edge.
|
||||
pub(crate) const BEVEL: f64 = 1.0;
|
||||
|
||||
/// How sharply the bend falls off going in: the 3.5th power of the way out of the curve.
|
||||
const PROFILE_EXP: f32 = 3.5;
|
||||
|
||||
/// The furthest the backdrop moves, as a share of `depth`.
|
||||
const MAX_BEND: f32 = 0.999;
|
||||
|
||||
/// The bend on the bevel itself, as a share of [`MAX_BEND`] × `depth` × `refraction`.
|
||||
const RIM_BEND: f32 = 0.2;
|
||||
|
||||
/// Steps of the dispersion window: each channel is sampled this many times along the bend, weighted
|
||||
/// by a triangle (the two end steps weigh nothing and are skipped).
|
||||
const DISPERSION_STEPS: usize = 8;
|
||||
|
||||
/// `x` from `a` to `b` as 0 to 1, clamped (a span under 1e-5 counts as 1e-5).
|
||||
fn lin(a: f32, b: f32, x: f32) -> f32 {
|
||||
((x - a) / (b - a).max(1e-5)).clamp(0.0, 1.0)
|
||||
}
|
||||
|
||||
/// How far the backdrop moves at `x` pixels in from the edge, for a glass `depth` and [`BEVEL`]
|
||||
/// `bevel` deep (pixels) and `refraction` (0–1): a thick lens's profile, the most a bevel in from
|
||||
/// the edge, falling off as the 3.5th power of the way out of the curve to nothing `depth` further
|
||||
/// in, and a fifth as much on the bevel itself, eased between the two over its outer 70%.
|
||||
pub(crate) fn bend_at(x: f32, depth: f32, bevel: f32, refraction: f32) -> f32 {
|
||||
// Past the curve (and the bevel's easing) nothing bends: the flat inside of the pane.
|
||||
if x >= depth.max(1e-4) + bevel {
|
||||
return 0.0;
|
||||
}
|
||||
let sd = -x;
|
||||
let t = lin(-depth - bevel, -bevel, sd);
|
||||
let most = MAX_BEND * depth;
|
||||
let core = (t.powf(PROFILE_EXP) * depth * refraction).clamp(-most, most);
|
||||
let rim = refraction * RIM_BEND * most;
|
||||
let u = lin(-bevel - 1e-4, -0.3 * bevel, sd);
|
||||
core + (rim - core) * u
|
||||
}
|
||||
|
||||
/// The backdrop seen at pixel coordinates (`x`, `y`) moved by (`dx`, `dy`), its channels split by
|
||||
/// `k` (dispersion, 0–1): red moves up to `k` further, blue up to `k` less, each smeared along the
|
||||
/// move by a triangular window of [`DISPERSION_STEPS`]. One sample when `k` is too small to show.
|
||||
fn dispersed(frosted: &Pixmap, x: f32, y: f32, dx: f32, dy: f32, k: f32) -> [f32; 4] {
|
||||
let at = |s: f32| sample(frosted, x + dx * s, y + dy * s);
|
||||
if k < 0.001 {
|
||||
let s = at(1.0);
|
||||
return [s[0].min(s[3]), s[1].min(s[3]), s[2].min(s[3]), s[3]];
|
||||
}
|
||||
let last = (DISPERSION_STEPS - 1) as f32;
|
||||
let (mut acc, mut sum) = ([0.0f32; 4], 0.0f32);
|
||||
for i in 1..DISPERSION_STEPS - 1 {
|
||||
let t = i as f32 / last - 0.5;
|
||||
let w = 1.0 - (2.0 * t).abs();
|
||||
let (r, g, b) = (at(1.0 + (t + 0.5) * k), at(1.0 + t * k), at(1.0 + (t - 0.5) * k));
|
||||
acc[0] += r[0] * w;
|
||||
acc[1] += g[1] * w;
|
||||
acc[2] += b[2] * w;
|
||||
acc[3] += r[3].max(g[3]).max(b[3]) * w;
|
||||
sum += w;
|
||||
}
|
||||
let a = acc[3] / sum;
|
||||
[(acc[0] / sum).min(a), (acc[1] / sum).min(a), (acc[2] / sum).min(a), a]
|
||||
}
|
||||
|
||||
/// Bilinear sample of premultiplied `p` at pixel coordinates `(x, y)` (centres at +0.5), each
|
||||
/// channel 0..=255; transparent outside.
|
||||
fn sample(p: &Pixmap, x: f32, y: f32) -> [f32; 4] {
|
||||
@@ -411,20 +478,20 @@ pub fn glass(g: &Glass, frame: EffectFrame<'_>) -> Option<Pixmap> {
|
||||
let EffectFrame { shape, back, pad, size: (w, h), xf, scale } = frame;
|
||||
let g = g.sanitized();
|
||||
let depth = (g.depth * scale).clamp(1.0, 1024.0);
|
||||
let bevel = (BEVEL * scale).min(1024.0);
|
||||
let band = (depth * (0.15 + 0.35 * g.splay)).max(1.0);
|
||||
let reach = light_reach(band, g.light_intensity);
|
||||
let r = (depth * 0.1).clamp(1.0, 8.0) as usize;
|
||||
// Coverage with a margin, so wherever the layer is cut every distance the pixels read is
|
||||
// exact: the bend's (within `depth`), the light's (within `reach`) and those the normals are
|
||||
// smoothed from (2r + 1 further).
|
||||
let m = depth.max(reach).ceil() as u32 + 4 * r as u32 + 4;
|
||||
// exact: the bend's (within `depth` + `bevel`), the light's (within `reach`) and those the
|
||||
// normals are smoothed from (2r + 1 further).
|
||||
let m = (depth + bevel).max(reach).ceil() as u32 + 4 * r as u32 + 4;
|
||||
let (fields, shift) = shape_fields(shape, xf, w, h, m, r)?;
|
||||
let mut frosted = back.clone();
|
||||
fx::blur(&mut frosted, g.frost / 2.0 * scale);
|
||||
let ang = g.light_angle.to_radians();
|
||||
let light = (ang.sin() as f32, -ang.cos() as f32);
|
||||
let bend_max = (g.refraction * depth) as f32;
|
||||
let fringe = (g.dispersion * 0.25) as f32;
|
||||
let (refraction, dispersion, bevel) = (g.refraction as f32, (g.dispersion * Glass::DISPERSION_SPREAD) as f32, bevel as f32);
|
||||
let power = (6.0 - 5.0 * g.splay) as f32;
|
||||
let (band, reach) = (band as f32, reach as f32);
|
||||
// The falloff, lowered by its value at `reach` and scaled back to 1 at the edge, so the light
|
||||
@@ -441,19 +508,15 @@ pub fn glass(g: &Glass, frame: EffectFrame<'_>) -> Option<Pixmap> {
|
||||
if c <= 0.0 {
|
||||
continue;
|
||||
}
|
||||
let t = (d / depth).min(1.0);
|
||||
let bend = bend_max * (1.0 - t) * (1.0 - t);
|
||||
let bend = bend_at(d, depth, bevel, refraction);
|
||||
let (bx, by) = (x as f32 + pad as f32 + 0.5, y as f32 + pad as f32 + 0.5);
|
||||
let base = if bend == 0.0 {
|
||||
// Nothing bends (past `depth`, or no refraction): the three channels' samples are
|
||||
// at the same point, so one sample.
|
||||
// Nothing bends (past `depth` + `bevel`, or no refraction): the channels' samples
|
||||
// are at the same point, so one sample.
|
||||
let s = sample(&frosted, bx, by);
|
||||
[s[0].min(s[3]), s[1].min(s[3]), s[2].min(s[3]), s[3]]
|
||||
} else {
|
||||
let at = |k: f32| sample(&frosted, bx + inward.0 * bend * k, by + inward.1 * bend * k);
|
||||
let (rs, gs, bs) = (at(1.0 - fringe), at(1.0), at(1.0 + fringe));
|
||||
let a = rs[3].max(gs[3]).max(bs[3]);
|
||||
[rs[0].min(a), gs[1].min(a), bs[2].min(a), a]
|
||||
dispersed(&frosted, bx, by, inward.0 * bend, inward.1 * bend, dispersion)
|
||||
};
|
||||
// The rim catches the light where it faces it, and half as much opposite. It fades out
|
||||
// by `reach` and is none past it, wherever the layer is cut.
|
||||
@@ -479,6 +542,101 @@ pub fn glass(g: &Glass, frame: EffectFrame<'_>) -> Option<Pixmap> {
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
/// The bend at depth 20, refraction 0.8 and a 1-unit bevel, x units in from the edge: the
|
||||
/// reference profile's values.
|
||||
#[test]
|
||||
fn the_bend_follows_the_thick_lens_profile() {
|
||||
let table = [
|
||||
(0.10, 3.1968),
|
||||
(0.25, 3.1968),
|
||||
(0.50, 6.8543),
|
||||
(0.75, 11.4263),
|
||||
(1.00, 15.9982),
|
||||
(2.0, 13.3707),
|
||||
(4.0, 9.0591),
|
||||
(6.0, 5.8457),
|
||||
(8.0, 3.5426),
|
||||
(10.0, 1.9742),
|
||||
(16.0, 0.1250),
|
||||
(20.0, 0.0004),
|
||||
(21.0, 0.0),
|
||||
(40.0, 0.0),
|
||||
];
|
||||
for (x, want) in table {
|
||||
let got = bend_at(x, 20.0, 1.0, 0.8);
|
||||
assert!((got - want).abs() < 1e-3, "x {x}: {got} vs {want}");
|
||||
}
|
||||
// No refraction, no bend; never more than 0.999 × depth, never outwards.
|
||||
assert_eq!(bend_at(0.5, 20.0, 1.0, 0.0), 0.0);
|
||||
for i in 0..400 {
|
||||
let x = i as f32 * 0.1;
|
||||
let b = bend_at(x, 20.0, 1.0, 1.0);
|
||||
assert!((0.0..=0.999 * 20.0).contains(&b), "x {x}: {b}");
|
||||
}
|
||||
// A depth thinner than the bevel (zoomed far in) still gives numbers.
|
||||
assert!(bend_at(0.5, 1.0, 8.0, 1.0).is_finite());
|
||||
// `Glass::max_bend`, which sizes the backdrop read around a pane, bounds the whole bend.
|
||||
for refraction in [0.3, 0.8, 1.0] {
|
||||
let most = (0..800).map(|i| bend_at(i as f32 * 0.05, 20.0, 1.0, refraction as f32)).fold(0.0f32, f32::max);
|
||||
let bound = Glass { refraction, depth: 20.0, dispersion: 0.0, ..Glass::default() }.max_bend();
|
||||
assert!(f64::from(most) <= bound + 1e-4, "refraction {refraction}: {most} past {bound}");
|
||||
}
|
||||
}
|
||||
|
||||
/// Dispersion off is one sample at the moved point; on, the channels split along the move, red
|
||||
/// further and blue less, and a flat backdrop stays flat.
|
||||
#[test]
|
||||
fn dispersion_splits_the_channels_along_the_bend() {
|
||||
// A 40 × 1 ramp: red, green and blue all rise with x.
|
||||
let mut p = Pixmap::new(40, 1).unwrap();
|
||||
for (i, px) in p.data_mut().chunks_exact_mut(4).enumerate() {
|
||||
let v = (i * 6) as u8;
|
||||
px.copy_from_slice(&[v, v, v, 255]);
|
||||
}
|
||||
let one = sample(&p, 10.5 + 8.0, 0.5);
|
||||
let off = dispersed(&p, 10.5, 0.5, 8.0, 0.0, 0.0);
|
||||
assert_eq!(off, [one[0], one[1], one[2], one[3]]);
|
||||
let on = dispersed(&p, 10.5, 0.5, 8.0, 0.0, 1.0);
|
||||
assert!(on[0] > on[1] && on[1] > on[2], "{on:?}");
|
||||
assert!((on[1] - one[1]).abs() < 1e-3, "green stays centred on the move: {on:?} vs {one:?}");
|
||||
let mut flat = Pixmap::new(40, 1).unwrap();
|
||||
flat.fill(tiny_skia::Color::from_rgba8(90, 120, 200, 255));
|
||||
let f = dispersed(&flat, 10.5, 0.5, 8.0, 0.0, 1.0);
|
||||
assert!(f.iter().zip([90.0, 120.0, 200.0, 255.0]).all(|(a, b)| (a - b).abs() < 1e-3), "{f:?}");
|
||||
// One white pixel on black: only the weighted steps that reach it pick it up, red and green
|
||||
// from opposite ends of their windows (the same amount), blue none.
|
||||
let mut impulse = Pixmap::new(40, 1).unwrap();
|
||||
impulse.fill(tiny_skia::Color::BLACK);
|
||||
impulse.data_mut()[20 * 4..21 * 4].copy_from_slice(&[255, 255, 255, 255]);
|
||||
let spread = dispersed(&impulse, 10.5, 0.5, 8.0, 0.0, 1.0);
|
||||
assert!((spread[0] - 33.392857).abs() < 1e-3 && (spread[1] - 33.392857).abs() < 1e-3, "{spread:?}");
|
||||
assert_eq!(spread[2], 0.0);
|
||||
}
|
||||
|
||||
/// At full dispersion red's furthest step stays within `Glass::max_bend` of the pixel, all
|
||||
/// along the bend, so the backdrop read around a pane covers it: one white pixel further out
|
||||
/// than that is never seen.
|
||||
#[test]
|
||||
fn full_dispersion_reads_no_further_than_max_bend() {
|
||||
let bound = Glass { refraction: 1.0, depth: 20.0, dispersion: 1.0, ..Glass::default() }.max_bend() as f32;
|
||||
let k = Glass::DISPERSION_SPREAD as f32;
|
||||
let mut furthest = 0usize;
|
||||
for i in 0..100 {
|
||||
let bend = bend_at(i as f32 * 0.25, 20.0, 1.0, 1.0);
|
||||
for at in 0..40 {
|
||||
let mut impulse = Pixmap::new(40, 1).unwrap();
|
||||
impulse.fill(tiny_skia::Color::BLACK);
|
||||
impulse.data_mut()[at * 4..at * 4 + 4].copy_from_slice(&[255, 255, 255, 255]);
|
||||
let s = dispersed(&impulse, 0.5, 0.5, bend, 0.0, k);
|
||||
if s[0].max(s[1]).max(s[2]) > 0.0 {
|
||||
furthest = furthest.max(at);
|
||||
}
|
||||
}
|
||||
}
|
||||
// A sample `o` pixels along picks up the pixel `at` while |o − at| < 1.
|
||||
assert!(furthest > 0 && (furthest as f32) < bound + 1.0, "pixel {furthest} seen, past {bound}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn distance_of_a_square() {
|
||||
let mut p = Pixmap::new(21, 21).unwrap();
|
||||
|
||||
@@ -293,12 +293,21 @@ pub fn decode_frames(bytes: &[u8]) -> Option<Vec<(Pixmap, f64)>> {
|
||||
if image::guess_format(bytes).ok()? != image::ImageFormat::Gif {
|
||||
return None;
|
||||
}
|
||||
let dec = image::codecs::gif::GifDecoder::new(std::io::Cursor::new(bytes)).ok()?;
|
||||
let mut dec = image::codecs::gif::GifDecoder::new(std::io::Cursor::new(bytes)).ok()?;
|
||||
let (w, h) = dec.dimensions();
|
||||
let frame_bytes = u64::from(w) * u64::from(h) * 4;
|
||||
if frame_bytes == 0 || w > MAX_SIDE || h > MAX_SIDE {
|
||||
return None;
|
||||
}
|
||||
// A frame's own descriptor can ask for a far larger buffer than the canvas: the decoder
|
||||
// reserves each frame and canvas buffer against these limits before allocating it.
|
||||
let mut limits = image::Limits::default();
|
||||
limits.max_image_width = Some(MAX_SIDE);
|
||||
limits.max_image_height = Some(MAX_SIDE);
|
||||
// The decoder charges its canvas, its composited output and the partial frame against this
|
||||
// together, besides the frames kept (capped by `most` below): one frame of working room.
|
||||
limits.max_alloc = Some(MAX_ANIMATION_BYTES.saturating_add(frame_bytes));
|
||||
dec.set_limits(limits).ok()?;
|
||||
let most = (MAX_ANIMATION_BYTES / frame_bytes).min(MAX_FRAMES as u64) as usize;
|
||||
let mut out = Vec::new();
|
||||
for f in dec.into_frames().take(most) {
|
||||
|
||||
@@ -139,3 +139,24 @@ fn a_deep_nest_of_isolated_layers_stays_within_the_budget() {
|
||||
// The outer levels still draw (the innermost, past the budget, are left out).
|
||||
assert_ne!(&pix.data()[..4], &[255, 255, 255, 255]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn masks_nested_inside_masks_stop_at_the_nesting_limit() {
|
||||
// A mask's content is drawn straight from `mask_pixels`, not through `draw_layer`, so a mask
|
||||
// group inside a mask group inside… used to recurse past the limit and down the stack.
|
||||
let mut d = Document::new("deep masks");
|
||||
let p = d.first_page().unwrap();
|
||||
let mut parent = p;
|
||||
for _ in 0..2000 {
|
||||
let g = d.create(parent, NodeKind::Group, "Masking group", 0.0, 0.0, 1.0, 1.0).unwrap();
|
||||
let n = d.get_mut(g).unwrap();
|
||||
n.is_mask = true;
|
||||
n.mask_type = MaskType::Alpha;
|
||||
parent = g;
|
||||
}
|
||||
shape(&mut d, parent, NodeKind::Rectangle, (0.0, 0.0, 100.0, 100.0), "2040E0");
|
||||
shape(&mut d, p, NodeKind::Rectangle, (0.0, 0.0, 100.0, 100.0), "E04020");
|
||||
let v = View { origin: (0.0, 0.0), scale: 1.0, width: 50, height: 50 };
|
||||
let pix = render(&d, p, &v, false);
|
||||
assert_eq!(pix.width(), 50);
|
||||
}
|
||||
@@ -103,11 +103,34 @@ pub(crate) struct Ctx<'a> {
|
||||
pattern_depth: usize,
|
||||
/// Tiles drawn so far, by pattern and scale (see [`paint`]'s `render_tile`).
|
||||
tiles: HashMap<(*const usvg::Pattern, u64), Option<paint::Tile>>,
|
||||
/// The document image key of each embedded image's bytes already added, so an image a
|
||||
/// pattern paints on many shapes is hashed once, not once per shape.
|
||||
image_keys: HashMap<*const Vec<u8>, String>,
|
||||
}
|
||||
|
||||
impl<'a> Ctx<'a> {
|
||||
pub(crate) fn new(doc: &'a mut Document) -> Self {
|
||||
Ctx { doc, count: 0, anonymous: HashSet::new(), notes: BTreeSet::new(), fonts: None, pattern_depth: 0, tiles: HashMap::new() }
|
||||
Ctx {
|
||||
doc,
|
||||
count: 0,
|
||||
anonymous: HashSet::new(),
|
||||
notes: BTreeSet::new(),
|
||||
fonts: None,
|
||||
pattern_depth: 0,
|
||||
tiles: HashMap::new(),
|
||||
image_keys: HashMap::new(),
|
||||
}
|
||||
}
|
||||
|
||||
/// [`add_image`] for `bytes`, once per distinct buffer.
|
||||
pub(crate) fn image(&mut self, bytes: std::sync::Arc<Vec<u8>>, w: f64, h: f64) -> String {
|
||||
if let Some(k) = self.image_keys.get(&std::sync::Arc::as_ptr(&bytes)) {
|
||||
return k.clone();
|
||||
}
|
||||
let ptr = std::sync::Arc::as_ptr(&bytes);
|
||||
let key = add_image(self.doc, bytes, w, h);
|
||||
self.image_keys.insert(ptr, key.clone());
|
||||
key
|
||||
}
|
||||
|
||||
pub(crate) fn full(&self) -> bool {
|
||||
@@ -605,7 +628,7 @@ fn image(cx: &mut Ctx, img: &usvg::Image, id: &str, parent: NodeId, base: Affine
|
||||
let size = img.size();
|
||||
let (iw, ih) = (f64::from(size.width()), f64::from(size.height()));
|
||||
let (transform, w, h) = place(world, Point::ZERO, iw, ih).unwrap_or((world, iw, ih));
|
||||
let hash = add_image(cx.doc, bytes, iw, ih);
|
||||
let hash = cx.image(bytes, iw, ih);
|
||||
let mut n = Node::new(cx.doc.alloc_id(), NodeKind::Rectangle, layer_name(id, "Image"), w, h);
|
||||
n.transform = transform;
|
||||
let mut fill = Paint::image(hash, ImageScaleMode::Fill);
|
||||
|
||||
@@ -44,6 +44,11 @@ fn inflate(data: &[u8], limit: usize) -> Result<Vec<u8>, String> {
|
||||
if out.len() > limit {
|
||||
return Err(format!("compressed SVG expands past {} MiB", limit >> 20));
|
||||
}
|
||||
// usvg gunzips what it is handed, with no limit: one layer is unpacked here, within the
|
||||
// budget, and what comes out must be the document itself.
|
||||
if gzipped(&out) {
|
||||
return Err("compressed SVG holds another compressed file, not a document".into());
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
@@ -72,7 +77,15 @@ fn embedded(used: &Used, limits: &Limits, data: &[u8], opts: &Options) -> Option
|
||||
return None;
|
||||
}
|
||||
let left = limits.embedded.saturating_sub(used.bytes.load(Ordering::Relaxed));
|
||||
let plain = inflate(data, left).ok()?;
|
||||
let plain = match inflate(data, left) {
|
||||
Ok(plain) => plain,
|
||||
// What a refused document unpacked before it was refused was work too: it uses up what is
|
||||
// left, so the next image can't repeat it.
|
||||
Err(_) => {
|
||||
used.bytes.fetch_add(left, Ordering::Relaxed);
|
||||
return None;
|
||||
}
|
||||
};
|
||||
used.bytes.fetch_add(plain.len(), Ordering::Relaxed);
|
||||
if super::too_deep(&plain) {
|
||||
return None;
|
||||
|
||||
@@ -111,3 +111,31 @@ fn linked_files_and_other_mime_types_stay_unresolved() {
|
||||
);
|
||||
assert_eq!(layers(data.as_bytes(), Limits::default()).unwrap(), layers(svg("").as_bytes(), Limits::default()).unwrap());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_document_compressed_twice_is_refused_not_unpacked_again() {
|
||||
// One gzip layer is unpacked within the budget; usvg would unpack a second one without any.
|
||||
let twice = gzip(&gzip(svg(&" ".repeat(1 << 20)).as_bytes()));
|
||||
let e = layers(&twice, Limits { document: 4 << 20, ..Limits::default() }).unwrap_err();
|
||||
assert!(e.contains("another compressed file"), "{e}");
|
||||
// Embedded, the same is dropped.
|
||||
let inner = svg(r##"<rect width="10" height="10"/>"##);
|
||||
let data = svg(&format!(
|
||||
r##"<image width="10" height="10" xlink:href="data:image/svg+xml;base64,{}"/>"##,
|
||||
base64::engine::general_purpose::STANDARD.encode(gzip(&gzip(inner.as_bytes())))
|
||||
))
|
||||
.into_bytes();
|
||||
assert_eq!(layers(&data, Limits::default()).unwrap(), layers(svg("").as_bytes(), Limits::default()).unwrap());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_refused_embedded_bomb_uses_up_the_budget_for_the_images_after_it() {
|
||||
let bomb = gzip(svg(&" ".repeat(1 << 20)).as_bytes());
|
||||
let inner = svg(r##"<rect width="10" height="10"/>"##);
|
||||
let image = |href: String| format!(r##"<image width="10" height="10" xlink:href="{href}"/>"##);
|
||||
let bomb_uri = format!("data:image/svg+xml;base64,{}", base64::engine::general_purpose::STANDARD.encode(&bomb));
|
||||
let data = svg(&format!("{}{}", image(bomb_uri).repeat(8), image(uri(inner.as_bytes())))).into_bytes();
|
||||
let limits = Limits { embedded: 4096, ..Limits::default() };
|
||||
let empty = layers(svg("").as_bytes(), limits).unwrap();
|
||||
assert_eq!(layers(&data, limits).unwrap(), empty, "the first bomb spends the allowance; nothing after it unpacks");
|
||||
}
|
||||
@@ -133,7 +133,7 @@ fn pattern(cx: &mut Ctx, pat: &usvg::Pattern, t: Target) -> Option<Paint> {
|
||||
let s = img.size();
|
||||
let (iw, ih) = (f64::from(s.width()), f64::from(s.height()));
|
||||
let b = figcraft_geom::transform_rect_bbox(m, Rect::new(0.0, 0.0, iw, ih));
|
||||
(tile_rect.contains(b.origin()) && tile_rect.contains(Point::new(b.x1, b.y1))).then(|| (add_image(cx.doc, bytes, iw, ih), iw, ih, m))
|
||||
(tile_rect.contains(b.origin()) && tile_rect.contains(Point::new(b.x1, b.y1))).then(|| (cx.image(bytes, iw, ih), iw, ih, m))
|
||||
});
|
||||
let (hash, iw, ih, content) = match lone {
|
||||
Some(l) => l,
|
||||
|
||||
@@ -153,8 +153,9 @@ fn an_image_stretched_into_its_box_stays_stretched() {
|
||||
|
||||
#[test]
|
||||
fn linked_files_are_never_read() {
|
||||
let dir = std::env::temp_dir().join("figcraft-svg-linked");
|
||||
std::fs::create_dir_all(&dir).unwrap();
|
||||
let dir = std::env::temp_dir().join(format!("figcraft-svg-linked-{}", std::process::id()));
|
||||
// `create_dir` refuses a directory or link someone else planted at this name.
|
||||
std::fs::create_dir(&dir).unwrap();
|
||||
let png = dir.join("secret.png");
|
||||
std::fs::write(&png, base64::Engine::decode(&base64::engine::general_purpose::STANDARD, PNG).unwrap()).unwrap();
|
||||
let href = png.to_string_lossy().replace('\\', "/");
|
||||
|
||||
@@ -139,7 +139,10 @@ fn macos_font_assets_are_found_in_the_asset_store() {
|
||||
let _ = std::fs::remove_dir_all(&self.0);
|
||||
}
|
||||
}
|
||||
let tmp = TempDir(std::env::temp_dir().join(format!("figcraft-font-assets-{}", std::process::id())));
|
||||
// Created fresh: a directory or link already at this predictable name is refused, and not removed.
|
||||
let root = std::env::temp_dir().join(format!("figcraft-font-assets-{}", std::process::id()));
|
||||
std::fs::create_dir(&root).unwrap();
|
||||
let tmp = TempDir(root);
|
||||
let store = tmp.0.join("AssetsV2");
|
||||
let fonts = store.join("com_apple_MobileAsset_Font7");
|
||||
let data = |kind: &std::path::Path| kind.join("0f1e2d.asset").join("AssetData");
|
||||
|
||||
@@ -1698,11 +1698,22 @@ fn shape_segment(chars: &[char], seg: &Segment, face: &Arc<Face>, features: &[Fe
|
||||
}
|
||||
let (script_scale, script_shift) = synth.map_or((1.0, 0.0), |(_, up)| if up { face.superscript } else { face.subscript });
|
||||
let n = raw.len();
|
||||
// Cluster end: the next larger cluster value, else the segment end. A glyph in the same
|
||||
// cluster as the next one shares its end, so many glyphs of one cluster aren't rescanned.
|
||||
let mut cends = vec![0usize; n];
|
||||
for gi in (0..n).rev() {
|
||||
let Some(&(_, cl, ..)) = raw.get(gi) else { continue };
|
||||
let cl = cl as usize;
|
||||
let shared = raw.get(gi + 1).filter(|r| r.1 as usize == cl).and_then(|_| cends.get(gi + 1).copied());
|
||||
let cend = shared.unwrap_or_else(|| raw.iter().skip(gi + 1).map(|r| r.1 as usize).find(|c| *c > cl).unwrap_or(end).max(cl + 1));
|
||||
if let Some(slot) = cends.get_mut(gi) {
|
||||
*slot = cend;
|
||||
}
|
||||
}
|
||||
for gi in 0..n {
|
||||
let Some(&(gid, cl, xa, xo, yo)) = raw.get(gi) else { continue };
|
||||
let cl = cl as usize;
|
||||
// Cluster end: the next larger cluster value, else the segment end.
|
||||
let cend = raw.iter().skip(gi + 1).map(|r| r.1 as usize).find(|c| *c > cl).unwrap_or(end).max(cl + 1);
|
||||
let cend = cends.get(gi).copied().unwrap_or(cl + 1);
|
||||
let last_in_cluster = raw.get(gi + 1).is_none_or(|r| r.1 as usize != cl);
|
||||
let ch = chars.get(cl).copied().unwrap_or(' ');
|
||||
let scale = if small_at(cl) { SMALL_CAP_SCALE } else { 1.0 } * script_scale;
|
||||
|
||||
@@ -6,12 +6,7 @@ use super::{
|
||||
impl FigApp {
|
||||
pub fn save_as_dialog(&mut self) {
|
||||
if self.services.downloads() {
|
||||
if let Some(r) = self.run("file.saveAs", json!({"data": true}))
|
||||
&& self.download(r["name"].as_str().unwrap_or_default(), &r)
|
||||
{
|
||||
self.run("file.markSaved", json!({}));
|
||||
dialogs::file_saved(self, &r);
|
||||
}
|
||||
self.save_download(None);
|
||||
return;
|
||||
}
|
||||
let Ok(name) = self.session.doc().map(|d| d.name.clone()) else { return };
|
||||
@@ -43,6 +38,17 @@ impl FigApp {
|
||||
});
|
||||
}
|
||||
|
||||
/// Save by handing the file over as a download. `keep`: the name a Save of a host-opened
|
||||
/// document keeps; `None` is a Save As, under the document's own name.
|
||||
fn save_download(&mut self, keep: Option<&str>) {
|
||||
if let Some(r) = self.run("file.saveAs", json!({"data": true}))
|
||||
&& self.download(keep.unwrap_or_else(|| r["name"].as_str().unwrap_or_default()), &r)
|
||||
{
|
||||
self.run("file.markSaved", json!({}));
|
||||
dialogs::file_saved(self, &r);
|
||||
}
|
||||
}
|
||||
|
||||
pub fn save(&mut self) {
|
||||
// A branch tab saves its main file.
|
||||
let tab = figcraft_engine::branches::file_tab(&self.session);
|
||||
@@ -57,6 +63,9 @@ impl FigApp {
|
||||
if self.run("file.save", json!({})).is_some() {
|
||||
self.toast(i18n::tr("Saved"));
|
||||
}
|
||||
} else if let Some(name) = self.services.host_file().filter(|n| is_document_file(n)) {
|
||||
// A host-opened document is saved as the file the host gave: the host updates that file.
|
||||
self.save_download(Some(&name));
|
||||
} else {
|
||||
self.save_as_dialog();
|
||||
}
|
||||
@@ -299,3 +308,8 @@ impl FigApp {
|
||||
failed
|
||||
}
|
||||
}
|
||||
|
||||
/// A `.figcraft` file name: the document format a Save writes (a `.fig` is an export copy).
|
||||
fn is_document_file(name: &str) -> bool {
|
||||
Path::new(name).extension().and_then(OsStr::to_str).is_some_and(|e| e.eq_ignore_ascii_case("figcraft"))
|
||||
}
|
||||
@@ -185,6 +185,33 @@ fn drag_id() -> Id {
|
||||
Id::unique("figcraft_handle_drag")
|
||||
}
|
||||
|
||||
/// Whether a gradient handle or stop on the canvas is being dragged, the press that starts it
|
||||
/// included: those are the open colour picker's own controls, so the picker stays through the drag
|
||||
/// instead of taking the press for one outside it (#1852).
|
||||
pub fn gradient_dragging(ctx: &egui::Context) -> bool {
|
||||
matches!(ctx.data(|d| d.get_temp::<Drag>(drag_id())), Some(Drag::Gradient { .. }))
|
||||
}
|
||||
|
||||
/// Whether the document has a gesture open: a handle drag edits only inside its own.
|
||||
fn gesture_open(app: &FigApp) -> bool {
|
||||
app.session.ds().is_ok_and(|d| d.interaction.is_some())
|
||||
}
|
||||
|
||||
/// A handle drag whose button went up wherever the pointer was (off the canvas, over a panel, the
|
||||
/// colour picker or a ruler, outside the window) ends as a release on the handle would: the edit
|
||||
/// commits now, instead of waiting, uncommitted, to move the handle to wherever the pointer next
|
||||
/// presses. So does one whose gesture Escape or Undo closed under the held button: it stops there
|
||||
/// rather than editing on with no gesture open, an undo step a frame. True when a drag ended.
|
||||
pub fn end_released_drag(app: &mut FigApp, ctx: &egui::Context) -> bool {
|
||||
let stashed = ctx.data(|d| d.get_temp::<Drag>(drag_id())).is_some();
|
||||
if !stashed || (ctx.input(|i| i.pointer.primary_down()) && gesture_open(app)) {
|
||||
return false;
|
||||
}
|
||||
let _ = app.session.commit_interaction();
|
||||
ctx.data_mut(|d| d.remove::<Drag>(drag_id()));
|
||||
true
|
||||
}
|
||||
|
||||
/// The gradient being edited (single node, picker open on a gradient paint).
|
||||
fn gradient_target(app: &FigApp) -> Option<(NodeId, bool, usize, figcraft_color::Gradient)> {
|
||||
let Some(PickerTarget::Paint { fills, index, ids }) = &app.ui.picker else { return None };
|
||||
@@ -516,6 +543,11 @@ pub fn input(app: &mut FigApp, ctx: &egui::Context, pos: Pos2) -> bool {
|
||||
});
|
||||
let dragging: Option<Drag> = ctx.data(|d| d.get_temp(drag_id()));
|
||||
if let Some(drag) = dragging {
|
||||
// Escape or Undo closed the gesture under the held button: the drag is over.
|
||||
if !gesture_open(app) {
|
||||
ctx.data_mut(|d| d.remove::<Drag>(drag_id()));
|
||||
return true;
|
||||
}
|
||||
if down {
|
||||
apply(app, &drag, pos, shift);
|
||||
ctx.set_cursor_icon(egui::CursorIcon::Grabbing);
|
||||
|
||||
@@ -183,6 +183,8 @@ pub(super) fn input(app: &mut FigApp, ui: &mut Ui, resp: &egui::Response) -> boo
|
||||
if !ctx.input(|i| i.pointer.button_down(egui::PointerButton::Middle) || i.pointer.primary_down()) {
|
||||
app.canvas.middle_pan = None;
|
||||
}
|
||||
// So is a handle drag.
|
||||
crate::handles::end_released_drag(app, &ctx);
|
||||
return true;
|
||||
};
|
||||
// A press on the canvas gives the keyboard back to it (arrows nudge again).
|
||||
@@ -230,6 +232,12 @@ pub(super) fn input(app: &mut FigApp, ui: &mut Ui, resp: &egui::Response) -> boo
|
||||
}
|
||||
return true;
|
||||
}
|
||||
// A handle drag whose button went up ends first, wherever on the canvas the pointer is: over a
|
||||
// ruler or a comment pin, which take the pointer below, or over something drawn above the
|
||||
// canvas (the colour picker, a card). The handle had the press, so it has the release too.
|
||||
if crate::handles::end_released_drag(app, &ctx) {
|
||||
return false;
|
||||
}
|
||||
if !app.canvas.dragging && (resp.hovered() || app.ui.comments.dragging()) && crate::comments::input(app, &ctx, pos) {
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -215,3 +215,160 @@ fn a_press_in_the_gradient_variable_picker_keeps_the_colour_picker_open() {
|
||||
assert!(u.app.ui.picker.is_some(), "the child variable picker is part of the interaction");
|
||||
u.button(at, false);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn dragging_a_gradient_handle_on_the_canvas_keeps_the_picker_open() {
|
||||
// #1852: the handles belong to the picker, so the press that starts a drag is not a press
|
||||
// outside it: the picker and the handles stay, the drag is one undo step, and a press elsewhere
|
||||
// on the layer still closes it.
|
||||
let mut s = Session::new();
|
||||
let a = NodeId(s.execute("shape.rectangle", &json!({"x": 100, "y": 100, "width": 200, "height": 200})).unwrap()["id"].as_u64().unwrap());
|
||||
s.execute("fill.set", &json!({"id": a, "paint": {"type": "linearGradient", "stops": ["#ff0000", "#0000ff"]}})).unwrap();
|
||||
s.execute("select.set", &json!({"ids": [a]})).unwrap();
|
||||
let mut u = Ui::new(s);
|
||||
let target = PickerTarget::Paint { fills: true, index: 0, ids: vec![a] };
|
||||
u.app.open_picker(target.clone(), None);
|
||||
for _ in 0..5 {
|
||||
u.frame(vec![]);
|
||||
}
|
||||
assert_eq!(u.app.ui.picker, Some(target.clone()));
|
||||
let depth = u.app.session.undo_depth().0;
|
||||
let from_handle = |u: &Ui| match &u.app.session.doc().unwrap().node(a).unwrap().fills[0].kind {
|
||||
figcraft_color::PaintKind::Gradient(g) => g.from,
|
||||
_ => panic!("the fill is a gradient"),
|
||||
};
|
||||
assert_eq!(from_handle(&u), (0.5, 0.0), "a linear gradient starts at the top middle");
|
||||
// Drag the start handle from the top middle of the layer to its left middle.
|
||||
let from = u.app.to_screen(200.0, 100.0);
|
||||
let to = u.app.to_screen(100.0, 200.0);
|
||||
u.button(from, true);
|
||||
assert_eq!(u.app.ui.picker, Some(target.clone()), "the press on the handle keeps the picker open");
|
||||
for _ in 0..2 {
|
||||
u.frame(vec![egui::Event::PointerMoved(to)]);
|
||||
}
|
||||
assert_eq!(u.app.ui.picker, Some(target.clone()), "and so does the drag");
|
||||
let (x, y) = from_handle(&u);
|
||||
assert!(x.abs() < 0.02 && (y - 0.5).abs() < 0.02, "the handle followed the pointer: ({x}, {y})");
|
||||
u.button(to, false);
|
||||
u.frame(vec![]);
|
||||
assert_eq!(u.app.ui.picker, Some(target.clone()), "released, the picker is still open");
|
||||
assert_eq!(u.app.session.undo_depth().0, depth + 1, "the drag is one undo step");
|
||||
// A press on the layer away from its handles is still a press outside the picker.
|
||||
let body = u.app.to_screen(250.0, 250.0);
|
||||
u.button(body, true);
|
||||
u.button(body, false);
|
||||
u.frame(vec![]);
|
||||
assert!(u.app.ui.picker.is_none(), "a plain canvas press closes it");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_gradient_drag_released_off_the_canvas_ends_there() {
|
||||
// A handle drag whose button goes up over the sidebar or over the picker itself ends there:
|
||||
// the edit commits, the picker stays, and the next press on the canvas is a plain press (it
|
||||
// closes the picker) rather than a move of the handle to wherever it landed.
|
||||
for over in ["sidebar", "picker"] {
|
||||
let mut s = Session::new();
|
||||
let a = NodeId(s.execute("shape.rectangle", &json!({"x": 100, "y": 100, "width": 200, "height": 200})).unwrap()["id"].as_u64().unwrap());
|
||||
s.execute("fill.set", &json!({"id": a, "paint": {"type": "linearGradient", "stops": ["#ff0000", "#0000ff"]}})).unwrap();
|
||||
s.execute("select.set", &json!({"ids": [a]})).unwrap();
|
||||
let mut u = Ui::new(s);
|
||||
let target = PickerTarget::Paint { fills: true, index: 0, ids: vec![a] };
|
||||
u.app.open_picker(target.clone(), None);
|
||||
for _ in 0..5 {
|
||||
u.frame(vec![]);
|
||||
}
|
||||
let depth = u.app.session.undo_depth().0;
|
||||
let from_handle = |u: &Ui| match &u.app.session.doc().unwrap().node(a).unwrap().fills[0].kind {
|
||||
figcraft_color::PaintKind::Gradient(g) => g.from,
|
||||
_ => panic!("the fill is a gradient"),
|
||||
};
|
||||
u.button(u.app.to_screen(200.0, 100.0), true);
|
||||
u.frame(vec![egui::Event::PointerMoved(u.app.to_screen(100.0, 200.0))]);
|
||||
assert!(crate::handles::gradient_dragging(&u.ctx), "{over}: the handle is being dragged");
|
||||
let spot = match over {
|
||||
"sidebar" => u.app.ui.right_panel_rect.unwrap().center(),
|
||||
_ => u.app.ui.picker_popover.as_ref().unwrap().rect.center(),
|
||||
};
|
||||
if over == "picker" {
|
||||
assert!(u.app.canvas.rect.contains(spot), "the picker lies over the canvas");
|
||||
} else {
|
||||
assert!(!u.app.canvas.rect.contains(spot), "the sidebar is off the canvas");
|
||||
}
|
||||
u.button(spot, false);
|
||||
u.frame(vec![]);
|
||||
assert!(!crate::handles::gradient_dragging(&u.ctx), "{over}: the release ended the drag");
|
||||
assert_eq!(u.app.ui.picker, Some(target.clone()), "{over}: the picker is still open");
|
||||
assert_eq!(u.app.session.undo_depth().0, depth + 1, "{over}: the drag is one undo step");
|
||||
let moved = from_handle(&u);
|
||||
assert!(moved.0.abs() < 0.02 && (moved.1 - 0.5).abs() < 0.02, "{over}: the handle stayed where it was dragged: {moved:?}");
|
||||
// The next press on the layer is a plain one: the handle stays put and the picker closes.
|
||||
let body = u.app.to_screen(250.0, 250.0);
|
||||
u.button(body, true);
|
||||
u.frame(vec![]);
|
||||
assert_eq!(from_handle(&u), moved, "{over}: a later press doesn't move the handle");
|
||||
assert!(u.app.ui.picker.is_none(), "{over}: a later press closes the picker as any outside press does");
|
||||
u.button(body, false);
|
||||
}
|
||||
}
|
||||
|
||||
/// A rectangle with a linear gradient fill, selected, its picker open and the canvas settled; a
|
||||
/// second layer drawn after it leaves an undo step that isn't the gradient's. Rulers on or off.
|
||||
fn gradient_ui(rulers: bool) -> Ui {
|
||||
let mut s = Session::new();
|
||||
if rulers {
|
||||
s.execute("view.rulers", &json!({"on": true})).unwrap();
|
||||
}
|
||||
let a = NodeId(s.execute("shape.rectangle", &json!({"x": 100, "y": 100, "width": 200, "height": 200})).unwrap()["id"].as_u64().unwrap());
|
||||
s.execute("fill.set", &json!({"id": a, "paint": {"type": "linearGradient", "stops": ["#ff0000", "#0000ff"]}})).unwrap();
|
||||
s.execute("shape.rectangle", &json!({"x": 400, "y": 100, "width": 20, "height": 20})).unwrap();
|
||||
s.execute("select.set", &json!({"ids": [a]})).unwrap();
|
||||
let mut u = Ui::new(s);
|
||||
u.app.open_picker(PickerTarget::Paint { fills: true, index: 0, ids: vec![a] }, None);
|
||||
for _ in 0..5 {
|
||||
u.frame(vec![]);
|
||||
}
|
||||
u
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_gradient_drag_released_over_a_ruler_ends_there() {
|
||||
// The rulers take the pointer on the canvas before the handles do: the release still ends the
|
||||
// drag, as one undo step, instead of leaving it waiting for the next press.
|
||||
let mut u = gradient_ui(true);
|
||||
let depth = u.app.session.undo_depth().0;
|
||||
u.button(u.app.to_screen(200.0, 100.0), true);
|
||||
u.frame(vec![egui::Event::PointerMoved(u.app.to_screen(100.0, 200.0))]);
|
||||
assert!(crate::handles::gradient_dragging(&u.ctx), "the handle is being dragged");
|
||||
let r = u.app.canvas.rect;
|
||||
let ruler = egui::Pos2::new(r.min.x + 5.0, r.center().y);
|
||||
assert!(!u.app.ui.picker_popover.as_ref().unwrap().rect.contains(ruler), "the ruler is not under the picker");
|
||||
u.button(ruler, false);
|
||||
assert!(!crate::handles::gradient_dragging(&u.ctx), "the release over the ruler ended the drag");
|
||||
assert_eq!(u.app.session.undo_depth().0, depth + 1, "the drag is one undo step");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_gradient_drag_whose_gesture_closes_under_the_held_button_stops_editing() {
|
||||
// Escape (the picker closes and commits) or Undo ends the gesture while the button is still
|
||||
// down: moving on edits nothing more, rather than adding an undo step every frame.
|
||||
for close in ["escape", "undo"] {
|
||||
let mut u = gradient_ui(false);
|
||||
u.button(u.app.to_screen(200.0, 100.0), true);
|
||||
u.frame(vec![egui::Event::PointerMoved(u.app.to_screen(100.0, 200.0))]);
|
||||
assert!(crate::handles::gradient_dragging(&u.ctx), "{close}: the handle is being dragged");
|
||||
if close == "escape" {
|
||||
crate::colorpicker::close(&mut u.app);
|
||||
} else {
|
||||
assert!(u.app.session.undo().unwrap(), "{close}: there is a step to undo");
|
||||
}
|
||||
let depth = u.app.session.undo_depth().0;
|
||||
let doc = u.app.session.doc().unwrap().clone();
|
||||
for k in 1..=4 {
|
||||
u.frame(vec![egui::Event::PointerMoved(u.app.to_screen(100.0 + 20.0 * f64::from(k), 200.0))]);
|
||||
}
|
||||
assert!(!crate::handles::gradient_dragging(&u.ctx), "{close}: the drag is over");
|
||||
assert_eq!(u.app.session.undo_depth().0, depth, "{close}: no undo step a frame");
|
||||
assert!(*u.app.session.doc().unwrap() == doc, "{close}: the gradient stays where the gesture left it");
|
||||
u.button(u.app.to_screen(180.0, 200.0), false);
|
||||
}
|
||||
}
|
||||
@@ -247,6 +247,8 @@ const SORT_ARROW_W: f32 = 12.0;
|
||||
/// Padding inside each cell, on each side.
|
||||
const CELL_PAD: f32 = 6.0;
|
||||
const NAME_MIN_W: f32 = 110.0;
|
||||
/// The narrowest a credits column can be dragged.
|
||||
const MIN_COLUMN: f32 = 28.0;
|
||||
|
||||
/// About ▸ Contributors: a name toggle, a sort, and the list as a grab bag or a table.
|
||||
pub fn contributors_ui(ui: &mut egui::Ui) {
|
||||
@@ -341,13 +343,17 @@ fn column_width<'a>(ui: &egui::Ui, header: &str, cells: impl Iterator<Item = &'a
|
||||
}
|
||||
|
||||
/// A credits table: columns of `widths`, the `None` one taking what the others leave (at least
|
||||
/// `flex_min`). The header stays put while the rows scroll, within `height` (header included). Too
|
||||
/// narrow for every column, it scrolls sideways rather than clip one.
|
||||
/// [`NAME_MIN_W`]). The header stays put while the rows scroll, within `height` (header included). Too
|
||||
/// narrow for every column, it scrolls sideways rather than clip one. Every
|
||||
/// column edge can be dragged, down to [`MIN_COLUMN`] (the `None` column to [`NAME_MIN_W`]): widening
|
||||
/// a column grows the table, as in a spreadsheet, and only then does it scroll sideways. When the
|
||||
/// window, a column's width or `flex_text` (the width the `None` column's text needs) changes, the
|
||||
/// columns go back to this fit, dropping any dragged widths.
|
||||
fn credits_table(
|
||||
ui: &mut egui::Ui,
|
||||
id: &str,
|
||||
widths: &[Option<f32>],
|
||||
flex_min: f32,
|
||||
flex_text: f32,
|
||||
height: f32,
|
||||
header: impl FnOnce(egui_extras::TableRow<'_, '_>),
|
||||
body: impl FnOnce(egui_extras::TableBody<'_>),
|
||||
@@ -358,21 +364,31 @@ fn credits_table(
|
||||
// The table puts a row gap under its header.
|
||||
let body_h = (height - TABLE_HEADER_H - ui.spacing().item_spacing.y).max(TABLE_ROW_H);
|
||||
egui::ScrollArea::horizontal().id_salt((id, "h")).auto_shrink([false, true]).show(ui, |ui| {
|
||||
let flex = (ui.available_width() - fixed).max(flex_min);
|
||||
let flex = (ui.available_width() - fixed).max(NAME_MIN_W);
|
||||
// No gaps between cells: their padding spaces them, and the header rule runs unbroken.
|
||||
ui.spacing_mut().item_spacing.x = 0.0;
|
||||
// The table keeps its own column widths, so a change in what they were fitted to has to clear
|
||||
// them. Scrolling can nudge the available width, so this compares the clip rect, which scrolling
|
||||
// never moves.
|
||||
let fit = egui::Id::unique(("credits_fit", id));
|
||||
let measured = (widths.to_vec(), flex_text, ui.clip_rect().width());
|
||||
let refit = ui.data_mut(|d| d.get_temp::<(Vec<Option<f32>>, f32, f32)>(fit)).as_ref() != Some(&measured);
|
||||
ui.data_mut(|d| d.insert_temp(fit, measured));
|
||||
let mut b = egui_extras::TableBuilder::new(ui)
|
||||
.id_salt(id)
|
||||
.striped(true)
|
||||
.resizable(false)
|
||||
.resizable(true)
|
||||
.auto_shrink([false, false])
|
||||
.min_scrolled_height(body_h)
|
||||
.max_scroll_height(body_h)
|
||||
.cell_layout(egui::Layout::left_to_right(egui::Align::Center));
|
||||
if refit {
|
||||
b.reset();
|
||||
}
|
||||
for w in widths {
|
||||
b = b.column(match w {
|
||||
Some(w) => egui_extras::Column::exact(*w),
|
||||
None => egui_extras::Column::exact(flex).clip(true),
|
||||
Some(w) => egui_extras::Column::initial(*w).at_least(MIN_COLUMN).clip(true),
|
||||
None => egui_extras::Column::initial(flex).at_least(NAME_MIN_W).clip(true),
|
||||
});
|
||||
}
|
||||
b.header(TABLE_HEADER_H, header).body(body);
|
||||
@@ -395,11 +411,13 @@ fn table(ui: &mut egui::Ui, list: &[&Contributor], v: &mut View, height: f32) {
|
||||
let t = Tokens::get(ui.ctx());
|
||||
let names = v.names;
|
||||
let widths = contributor_widths(ui, list);
|
||||
let shown: Vec<String> = list.iter().map(|c| c.name(names)).collect();
|
||||
let name_text = column_width(ui, SortKey::Name.label().1, shown.iter().map(String::as_str));
|
||||
credits_table(
|
||||
ui,
|
||||
"credits_table",
|
||||
&widths,
|
||||
NAME_MIN_W,
|
||||
name_text,
|
||||
height,
|
||||
|mut header| {
|
||||
for k in SortKey::ALL {
|
||||
@@ -522,12 +540,13 @@ fn models_in(ui: &mut egui::Ui, models: &[Model], total_commits: u64) {
|
||||
let total = total_commits.max(models.iter().map(|m| m.commits).max().unwrap_or(0));
|
||||
let rows: Vec<[String; 6]> = models.iter().map(|m| model_cells(m, total)).collect();
|
||||
let widths = model_widths(ui, &rows);
|
||||
let model_text = column_width(ui, tr(MODEL_HEADS[1]), rows.iter().filter_map(|r| r.get(1)).map(String::as_str));
|
||||
let numeric = |i: usize| i >= 3;
|
||||
credits_table(
|
||||
ui,
|
||||
"credits_models",
|
||||
&widths,
|
||||
NAME_MIN_W,
|
||||
model_text,
|
||||
table_height(ui, rows.len()),
|
||||
|mut header| {
|
||||
for (i, h) in MODEL_HEADS.iter().enumerate() {
|
||||
|
||||
@@ -267,3 +267,122 @@ fn the_about_window_draws_every_tab() {
|
||||
assert_eq!(app.ui.about_tab, tab);
|
||||
}
|
||||
}
|
||||
|
||||
const WINDOW: f32 = 640.5;
|
||||
const WIDTHS: [Option<f32>; 3] = [None, Some(80.0), Some(80.0)];
|
||||
const NAME: f32 = 120.0;
|
||||
|
||||
/// One frame of a table long enough to scroll, in a window `width` wide; the rects of its header cells.
|
||||
fn table_frame(ctx: &egui::Context, width: f32, widths: &[Option<f32>], name: f32, events: Vec<egui::Event>) -> Vec<Rect> {
|
||||
let screen_rect = Some(Rect::from_min_size(egui::Pos2::ZERO, vec2(width, 300.0)));
|
||||
let raw = egui::RawInput { screen_rect, events, ..Default::default() };
|
||||
let mut cells = Vec::new();
|
||||
let out = ctx.run_ui(raw, |ui| {
|
||||
cells.clear();
|
||||
credits_table(
|
||||
ui,
|
||||
"test",
|
||||
widths,
|
||||
name,
|
||||
240.0,
|
||||
|mut header| {
|
||||
for _ in widths {
|
||||
header.col(|ui| cells.push(ui.max_rect()));
|
||||
}
|
||||
},
|
||||
|body| {
|
||||
body.rows(TABLE_ROW_H, 40, |mut row| {
|
||||
for _ in widths {
|
||||
row.col(|ui| {
|
||||
ui.label("x");
|
||||
});
|
||||
}
|
||||
});
|
||||
},
|
||||
);
|
||||
});
|
||||
out.drop_without_applying_deltas();
|
||||
cells
|
||||
}
|
||||
|
||||
/// [`table_frame`] at the usual size.
|
||||
fn settled_frame(ctx: &egui::Context) -> Vec<Rect> {
|
||||
table_frame(ctx, WINDOW, &WIDTHS, NAME, Vec::new())
|
||||
}
|
||||
|
||||
/// A new context with the table open and settled, and the rects of its header cells.
|
||||
fn opened_table() -> (egui::Context, Vec<Rect>) {
|
||||
let ctx = egui::Context::default();
|
||||
settled_frame(&ctx);
|
||||
let cells = settled_frame(&ctx);
|
||||
(ctx, cells)
|
||||
}
|
||||
|
||||
/// Drags a column's right edge (cells have no gap between them), then lets go.
|
||||
fn drag_edge(ctx: &egui::Context, cell: Rect, by: f32) {
|
||||
let start = egui::pos2(cell.right(), cell.center().y);
|
||||
let halfway = start + vec2(by / 2.0, 0.0);
|
||||
let end = start + vec2(by, 0.0);
|
||||
let moved = egui::Event::PointerMoved;
|
||||
let button = |pos, pressed| egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed, modifiers: egui::Modifiers::NONE };
|
||||
for event in [moved(start), button(start, true), moved(halfway), moved(end), button(end, false)] {
|
||||
table_frame(ctx, WINDOW, &WIDTHS, NAME, vec![event]);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn every_column_can_be_dragged_at_its_right_edge_and_stays_there() {
|
||||
let (_, opened) = opened_table();
|
||||
for (dragged, cell) in opened.iter().enumerate() {
|
||||
let (ctx, _) = opened_table();
|
||||
drag_edge(&ctx, *cell, -30.0);
|
||||
settled_frame(&ctx);
|
||||
let after = settled_frame(&ctx);
|
||||
for (column, (was, now)) in opened.iter().zip(&after).enumerate() {
|
||||
let want = if column == dragged { was.width() - 30.0 } else { was.width() };
|
||||
assert!((now.width() - want).abs() < 1.0, "dragging column {dragged}: column {column} is {now:?}, was {was:?}");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_changed_fit_replaces_the_column_widths() {
|
||||
let (ctx, opened) = opened_table();
|
||||
drag_edge(&ctx, opened[0], -30.0);
|
||||
let longer_name = table_frame(&ctx, WINDOW, &WIDTHS, NAME + 80.0, Vec::new());
|
||||
assert!((longer_name[0].width() - opened[0].width()).abs() < 1.0, "a longer name drops a dragged width: {longer_name:?}");
|
||||
let wider = table_frame(&ctx, WINDOW, &[None, Some(200.0), Some(80.0)], NAME, Vec::new());
|
||||
let widths: Vec<f32> = wider.iter().map(|c| c.width().round()).collect();
|
||||
assert!(widths.ends_with(&[200.0, 80.0]), "a longer cell widens its column: {widths:?}");
|
||||
// The table fills the window, which the layout rounds to whole points.
|
||||
assert!(wider[2].right() <= WINDOW.ceil(), "the table still fits the window: {wider:?}");
|
||||
let narrower = table_frame(&ctx, 400.0, &WIDTHS, NAME, Vec::new());
|
||||
assert!(narrower[2].right() <= 400.0, "a narrower window refits the table: {narrower:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn scrolling_sideways_keeps_dragged_widths() {
|
||||
let (ctx, opened) = opened_table();
|
||||
drag_edge(&ctx, opened[0], 100.0);
|
||||
settled_frame(&ctx);
|
||||
let dragged = settled_frame(&ctx);
|
||||
assert!((dragged[0].width() - opened[0].width() - 100.0).abs() < 1.0, "the drag took: {dragged:?}");
|
||||
table_frame(&ctx, WINDOW, &WIDTHS, NAME, vec![egui::Event::PointerMoved(dragged[0].center())]);
|
||||
let mut scrolled = false;
|
||||
for delta in [-13.3, -27.77, -41.1, 30.6] {
|
||||
let wheel = egui::Event::MouseWheel {
|
||||
source: egui::MouseWheelSource::Unknown,
|
||||
unit: egui::MouseWheelUnit::Point,
|
||||
delta: vec2(delta, 0.0),
|
||||
modifiers: egui::Modifiers::NONE,
|
||||
phase: egui::TouchPhase::Move,
|
||||
};
|
||||
table_frame(&ctx, WINDOW, &WIDTHS, NAME, vec![wheel]);
|
||||
for _ in 0..8 {
|
||||
let cells = settled_frame(&ctx);
|
||||
assert!((cells[0].width() - dragged[0].width()).abs() < 1.0, "scrolled by {delta}: {cells:?}");
|
||||
scrolled |= cells[0].left() < dragged[0].left() - 1.0;
|
||||
}
|
||||
}
|
||||
assert!(scrolled, "the wheel never moved the table sideways");
|
||||
}
|
||||
@@ -138,7 +138,7 @@ pub(crate) fn save_file(app: &mut FigApp, data: &Value) {
|
||||
let shown = name.clone();
|
||||
app.pick_save(tr("Save file"), &name, &exts, move |app, path| {
|
||||
let file = path.file_name().map(|f| f.to_string_lossy().to_string()).unwrap_or(shown);
|
||||
match std::fs::write(&path, &bytes) {
|
||||
match figcraft_engine::file_access::write(&path, &bytes) {
|
||||
Ok(()) => app.toast(trf("Saved {name}", &[("name", &file)])),
|
||||
Err(_) => app.toast(tr("Couldn't save the file")),
|
||||
}
|
||||
|
||||
@@ -667,11 +667,11 @@ fn the_glass_light_intensity_field_has_a_label() {
|
||||
u.ctx.data_mut(|d| d.insert_temp(Id::unique(("fx_open", 0usize)), true));
|
||||
u.frame(vec![]);
|
||||
let shapes = u.frame_output(vec![]).shapes;
|
||||
let lead = u.ctx.read_response(Id::unique(("fx_gi", 0usize)).with("lead")).expect("the intensity field is shown").rect;
|
||||
let lead = u.ctx.read_response(Id::unique(("fx", "lightIntensity", 0usize)).with("lead")).expect("the intensity field is shown").rect;
|
||||
let labels: Vec<(String, bool)> =
|
||||
painted_texts(&shapes).into_iter().filter(|(_, _, at)| lead.contains(at.center())).map(|(text, cut, _)| (text, cut)).collect();
|
||||
assert_eq!(labels, [("Intensity".to_string(), false)], "labelled, and not cut short");
|
||||
let field = u.ctx.read_response(Id::unique(("fx_gi", 0usize)).with("field")).expect("its value").rect;
|
||||
let field = u.ctx.read_response(Id::unique(("fx", "lightIntensity", 0usize)).with("field")).expect("its value").rect;
|
||||
assert_eq!(field.max.x - lead.min.x, GLASS_FIELD_W, "the width the next test measures against");
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,60 @@
|
||||
//! In a page host the browser hands files to the host: a Save of the document the host opened goes
|
||||
//! out under the host's file name, a Save As under the document's own name.
|
||||
|
||||
use std::sync::{Arc, Mutex};
|
||||
|
||||
use figcraft_engine::Session;
|
||||
use serde_json::json;
|
||||
|
||||
use crate::{FigApp, Services};
|
||||
|
||||
type Saved = Arc<Mutex<Vec<String>>>;
|
||||
|
||||
/// Services that save by downloads, with a document file the host opened.
|
||||
struct Host {
|
||||
got: Saved,
|
||||
file: Option<&'static str>,
|
||||
}
|
||||
|
||||
impl Services for Host {
|
||||
fn downloads(&self) -> bool {
|
||||
true
|
||||
}
|
||||
fn download(&mut self, name: &str, _bytes: &[u8]) -> bool {
|
||||
self.got.lock().unwrap().push(name.to_string());
|
||||
true
|
||||
}
|
||||
fn host_file(&self) -> Option<String> {
|
||||
self.file.map(str::to_string)
|
||||
}
|
||||
}
|
||||
|
||||
fn app(file: Option<&'static str>) -> (FigApp, Saved) {
|
||||
let got = Saved::default();
|
||||
let mut app = FigApp::new(Session::empty(), Box::new(Host { got: got.clone(), file }));
|
||||
app.session.execute("file.new", &json!({"name": "Original"})).unwrap();
|
||||
(app, got)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn save_keeps_the_name_the_host_opened() {
|
||||
let (mut app, got) = app(Some("client.figcraft"));
|
||||
app.save();
|
||||
assert_eq!(got.lock().unwrap().as_slice(), ["client.figcraft"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn save_as_uses_the_document_s_own_name() {
|
||||
let (mut app, got) = app(Some("client.figcraft"));
|
||||
app.save_as_dialog();
|
||||
assert_eq!(got.lock().unwrap().as_slice(), ["Original.figcraft"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn without_a_host_file_or_for_a_copy_format_save_is_a_save_as() {
|
||||
for file in [None, Some("design.json"), Some("export.fig")] {
|
||||
let (mut app, got) = app(file);
|
||||
app.save();
|
||||
assert_eq!(got.lock().unwrap().as_slice(), ["Original.figcraft"], "{file:?}");
|
||||
}
|
||||
}
|
||||
@@ -124,6 +124,8 @@ mod home_recents_tests;
|
||||
#[cfg(test)]
|
||||
mod home_tests;
|
||||
#[cfg(test)]
|
||||
mod host_save_tests;
|
||||
#[cfg(test)]
|
||||
mod idle_tests;
|
||||
#[cfg(test)]
|
||||
mod ime_tests;
|
||||
|
||||
@@ -108,7 +108,22 @@ pub(crate) fn effect_open(ctx: &egui::Context, i: usize) -> bool {
|
||||
|
||||
/// A number field of effect `i` that can be bound to a variable (`effects/<i>/<prop>`).
|
||||
fn fx_field(app: &mut FigApp, ui: &mut Ui, ids: &[NodeId], i: usize, prop: &str, lead: Lead, value: f64, width: f32) -> Option<FieldEdit> {
|
||||
crate::variable_ui::number_field(app, ui, ids, &format!("effects/{i}/{prop}"), Id::unique(("fx", prop, i)), lead, Some(value), "", width)
|
||||
fx_field_in(app, ui, ids, i, prop, lead, Some(value), "", width)
|
||||
}
|
||||
|
||||
/// [`fx_field`] showing `value` as given (a glass percentage) with `suffix` after it.
|
||||
fn fx_field_in(
|
||||
app: &mut FigApp,
|
||||
ui: &mut Ui,
|
||||
ids: &[NodeId],
|
||||
i: usize,
|
||||
prop: &str,
|
||||
lead: Lead,
|
||||
value: Option<f64>,
|
||||
suffix: &str,
|
||||
width: f32,
|
||||
) -> Option<FieldEdit> {
|
||||
crate::variable_ui::number_field(app, ui, ids, &format!("effects/{i}/{prop}"), Id::unique(("fx", prop, i)), lead, value, suffix, width)
|
||||
}
|
||||
|
||||
/// Draw type-specific effect fields for shadows, blurs, noise, texture and glass, using live
|
||||
@@ -290,29 +305,30 @@ fn effect_settings(app: &mut FigApp, ui: &mut Ui, ids: &[NodeId], i: usize, e: &
|
||||
}
|
||||
})
|
||||
};
|
||||
// Each field takes a variable (`effects/<i>/<field>`), read as the field shows it:
|
||||
// percentages for the 0–1 values, and the frost as `radius` (see `Glass::set_bound`).
|
||||
let pct = |v: f64| Some((v * 100.0).round());
|
||||
let unit = |v: f64| (v / 100.0).clamp(0.0, 1.0);
|
||||
row(ui, 32.0, |ui| {
|
||||
let ed =
|
||||
widgets::number_field(ui, Id::unique(("fx_gl", i)), Lead::Text(tr("Light|glass")), Some(g.light_angle.round()), "°", half, 1.0);
|
||||
let ed = fx_field_in(app, ui, ids, i, "lightAngle", Lead::Text(tr("Light|glass")), Some(g.light_angle.round()), "°", half);
|
||||
edit(app, ed, &|v| with(&|gl| gl.light_angle = v.clamp(-180.0, 180.0)));
|
||||
let ed = widgets::number_field(ui, Id::unique(("fx_gi", i)), Lead::Text(tr("Intensity")), pct(g.light_intensity), "%", half, 1.0);
|
||||
let ed = fx_field_in(app, ui, ids, i, "lightIntensity", Lead::Text(tr("Intensity")), pct(g.light_intensity), "%", half);
|
||||
edit(app, ed, &|v| with(&|gl| gl.light_intensity = unit(v)));
|
||||
});
|
||||
row(ui, 32.0, |ui| {
|
||||
let ed = widgets::number_field(ui, Id::unique(("fx_gr", i)), Lead::Text(tr("Refraction")), pct(g.refraction), "%", half, 1.0);
|
||||
let ed = fx_field_in(app, ui, ids, i, "refraction", Lead::Text(tr("Refraction")), pct(g.refraction), "%", half);
|
||||
edit(app, ed, &|v| with(&|gl| gl.refraction = unit(v)));
|
||||
let ed = widgets::number_field(ui, Id::unique(("fx_gd", i)), Lead::Text(tr("Depth")), Some(g.depth), "", half, 1.0);
|
||||
let ed = fx_field_in(app, ui, ids, i, "depth", Lead::Text(tr("Depth")), Some(g.depth), "", half);
|
||||
edit(app, ed, &|v| with(&|gl| gl.depth = v.clamp(1.0, 1000.0)));
|
||||
});
|
||||
row(ui, 32.0, |ui| {
|
||||
let ed = widgets::number_field(ui, Id::unique(("fx_gs", i)), Lead::Text(tr("Dispersion")), pct(g.dispersion), "%", half, 1.0);
|
||||
let ed = fx_field_in(app, ui, ids, i, "dispersion", Lead::Text(tr("Dispersion")), pct(g.dispersion), "%", half);
|
||||
edit(app, ed, &|v| with(&|gl| gl.dispersion = unit(v)));
|
||||
let ed = widgets::number_field(ui, Id::unique(("fx_gf", i)), Lead::Text(tr("Frost")), Some(g.frost), "", half, 1.0);
|
||||
edit(app, ed, &|v| with(&|gl| gl.frost = v.clamp(0.0, 1000.0)));
|
||||
let ed = fx_field_in(app, ui, ids, i, "radius", Lead::Text(tr("Frost")), Some(g.sanitized().frost), "", half);
|
||||
edit(app, ed, &|v| with(&|gl| gl.frost = v.clamp(0.0, Glass::MAX_FROST)));
|
||||
});
|
||||
row(ui, 32.0, |ui| {
|
||||
let ed = widgets::number_field(ui, Id::unique(("fx_gp", i)), Lead::Text(tr("Splay")), pct(g.splay), "%", half, 1.0);
|
||||
let ed = fx_field_in(app, ui, ids, i, "splay", Lead::Text(tr("Splay")), pct(g.splay), "%", half);
|
||||
edit(app, ed, &|v| with(&|gl| gl.splay = unit(v)));
|
||||
});
|
||||
}
|
||||
|
||||
@@ -24,6 +24,11 @@ pub trait Services {
|
||||
fn download(&mut self, _name: &str, _bytes: &[u8]) -> bool {
|
||||
false
|
||||
}
|
||||
/// The document file a host page opened, where the app runs inside one (the browser's host
|
||||
/// mode): a Save of that document keeps this name instead of the document's own.
|
||||
fn host_file(&self) -> Option<String> {
|
||||
None
|
||||
}
|
||||
/// A folder to write several files into.
|
||||
fn pick_folder(&mut self, _title: &str) -> DialogFuture {
|
||||
Box::pin(std::future::ready(None))
|
||||
|
||||
@@ -977,7 +977,10 @@ pub fn show(app: &mut FigApp, ctx: &egui::Context) {
|
||||
// Sampling a colour from the canvas — the eyedropper this picker's own button started, or the
|
||||
// colour it just sampled — is the press, not a press outside: neither may close the picker.
|
||||
let picking = app.session.tool.pick_only || app.session.tool.picked.is_some();
|
||||
pop = pop.close_on_outside(!picking);
|
||||
// Nor may a press on the open gradient's handles or stops on the canvas: they are this picker's
|
||||
// controls, and the canvas took the press before the picker drew (#1852).
|
||||
let own = picking || crate::handles::gradient_dragging(ctx);
|
||||
pop = pop.close_on_outside(!own);
|
||||
// Only the opening control is held out: any other sidebar or canvas press dismisses it.
|
||||
let mut held: Vec<Rect> = app.ui.picker_button.into_iter().collect();
|
||||
held.extend(crate::variable_ui::picker_rect(ctx));
|
||||
|
||||
@@ -24,6 +24,8 @@ pub(crate) struct Walker<'a> {
|
||||
opts: &'a VdOptions,
|
||||
warn: Warnings,
|
||||
names: std::collections::BTreeSet<String>,
|
||||
/// The next suffix to try for each base name (names only get taken, so none before it is free).
|
||||
next_suffix: std::collections::BTreeMap<String, usize>,
|
||||
}
|
||||
|
||||
/// Every coordinate of `p` finite and within [`MAX_COORD`].
|
||||
@@ -54,7 +56,7 @@ fn normal(b: BlendMode) -> bool {
|
||||
|
||||
impl<'a> Walker<'a> {
|
||||
pub fn new(doc: &'a Document, opts: &'a VdOptions) -> Self {
|
||||
Self { doc, opts, warn: Warnings::default(), names: Default::default() }
|
||||
Self { doc, opts, warn: Warnings::default(), names: Default::default(), next_suffix: Default::default() }
|
||||
}
|
||||
|
||||
/// Reports that the export drew nothing at all (named after `layer`).
|
||||
@@ -78,12 +80,25 @@ impl<'a> Walker<'a> {
|
||||
fn unique(&mut self, name: &str) -> String {
|
||||
let base: String = name.chars().take(200).collect();
|
||||
let base = if base.trim().is_empty() { "layer".to_string() } else { base };
|
||||
// Bounded: a set of n names leaves one of the first n + 1 candidates free.
|
||||
let tries = self.names.len().saturating_add(1);
|
||||
let name = (1..=tries)
|
||||
.map(|k| if k == 1 { base.clone() } else { format!("{base}_{k}") })
|
||||
.find(|n| !self.names.contains(n))
|
||||
.unwrap_or_else(|| format!("{base}_{}", tries.saturating_add(1)));
|
||||
let mut k = self.next_suffix.get(&base).copied().unwrap_or(1);
|
||||
let mut stem = base.clone();
|
||||
// Bounded: a set of n names leaves one of the first n + 1 candidates free. A counter
|
||||
// that has run out (`usize::MAX`) continues from a longer stem instead of repeating.
|
||||
let name = loop {
|
||||
let candidate = if k == 1 { stem.clone() } else { format!("{stem}_{k}") };
|
||||
if !self.names.contains(&candidate) {
|
||||
k = k.saturating_add(1);
|
||||
break candidate;
|
||||
}
|
||||
if k == usize::MAX {
|
||||
stem = candidate;
|
||||
k = 2;
|
||||
} else {
|
||||
k += 1;
|
||||
}
|
||||
};
|
||||
let longer = stem.len() > base.len();
|
||||
self.next_suffix.insert(base, if longer { usize::MAX } else { k });
|
||||
self.names.insert(name.clone());
|
||||
name
|
||||
}
|
||||
@@ -404,3 +419,20 @@ impl<'a> Walker<'a> {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod unique_tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn an_exhausted_suffix_counter_still_finds_a_free_name() {
|
||||
let (doc, opts) = (Document::new("File"), VdOptions::default());
|
||||
let mut w = Walker::new(&doc, &opts);
|
||||
w.next_suffix.insert("a".into(), usize::MAX);
|
||||
w.names.insert(format!("a_{}", usize::MAX));
|
||||
let first = w.unique("a");
|
||||
let second = w.unique("a");
|
||||
assert_ne!(first, second);
|
||||
assert!(w.names.len() == 3 && w.names.contains(&first) && w.names.contains(&second));
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user