mirror of
https://github.com/storytold/vectorcraft.git
synced 2026-11-19 10:17:58 +00:00
Changing Preferences › Hyphenation › Exceptions bumped each open document's revision, but the caches of laid-out type outside the text crate were keyed on the font generation alone. The renderer kept the glyph geometry, raster-effect pixels, live-effect and envelope art, pattern tiles and placed symbol art of unchanged type objects, so hyphenated area type kept its old line breaks on the canvas. The hit-test art of blends and envelopes, the Fit to Artwork Bounds answer, the layout caches of the Type and Touch Type tools and the out port's overflow mark were keyed the same way. vectorcraft_text::layout_inputs() returns a number that changes with the fonts and with the hyphenation exceptions. Every one of those caches now keys on it instead of FontDb::generation(), and envelope ink uses it in place of the private envelope_ink_inputs(). The hit-test key hashes it together with the plug-in revision. Tests: a renderer that drew hyphenated area type, alone, with a drop shadow, in a group with a Transform effect, in a symbol instance and in an envelope, draws it as a new renderer does after the exceptions change; the out port of selected area type shows the overflow that the new exceptions cause. The render test helpers that run a step again when the fonts change during it now also run it again when the exceptions change.
598 lines
32 KiB
Rust
598 lines
32 KiB
Rust
//! Type redraws in a font that becomes available while it is on screen (fonts added, Refresh Font
|
||
//! List).
|
||
|
||
use std::sync::{PoisonError, RwLock, RwLockReadGuard, RwLockWriteGuard};
|
||
|
||
use vectorcraft_doc::text::{CharStyle, TextKind, TextObject};
|
||
use vectorcraft_doc::{Node, NodeKind};
|
||
use vectorcraft_geom::{PathData, Point};
|
||
|
||
use crate::*;
|
||
|
||
/// Taken to add fonts, to look up an installed one by name (`FontDb::face` loads it, which
|
||
/// changes the fonts too) or to change the hyphenation exceptions. Renderers lay type out again
|
||
/// when the fonts or the exceptions change, so tests of what they keep between frames hold it
|
||
/// shared ([`fonts_steady`]) and the tests that change them hold it alone ([`adding_fonts`]).
|
||
static FONTS: RwLock<()> = RwLock::new(());
|
||
|
||
/// No fonts are added by these tests until the guard is dropped.
|
||
pub(crate) fn fonts_steady() -> RwLockReadGuard<'static, ()> {
|
||
// A test that failed holding it leaves nothing to undo.
|
||
FONTS.read().unwrap_or_else(PoisonError::into_inner)
|
||
}
|
||
|
||
/// No test holding [`fonts_steady`] runs until the guard is dropped.
|
||
pub(crate) fn adding_fonts() -> RwLockWriteGuard<'static, ()> {
|
||
FONTS.write().unwrap_or_else(PoisonError::into_inner)
|
||
}
|
||
|
||
/// What `step` returns from a run in which the fonts stayed the same. The fonts can change while
|
||
/// [`fonts_steady`] is held: the first lookup by family name catalogs the installed fonts, and
|
||
/// resolving a cataloged family, or a character no loaded font has, loads a face. `step` runs up
|
||
/// to 100 times, until [`vectorcraft_text::layout_inputs`] is the same after a run as before it.
|
||
pub(crate) fn with_fonts_unchanged<T>(mut step: impl FnMut() -> T) -> T {
|
||
for _ in 0..100 {
|
||
let before = vectorcraft_text::layout_inputs();
|
||
let out = step();
|
||
if vectorcraft_text::layout_inputs() == before {
|
||
return out;
|
||
}
|
||
}
|
||
panic!("the fonts changed during each of 100 runs");
|
||
}
|
||
|
||
/// The bundled Source Serif 4 renamed `family` (as long as the original name).
|
||
fn serif_as(family: &str) -> Vec<u8> {
|
||
let mut data = include_bytes!("../../../../assets/fonts/SourceSerif4-Regular.ttf").to_vec();
|
||
let utf16 = |s: &str| s.encode_utf16().flat_map(u16::to_be_bytes).collect::<Vec<u8>>();
|
||
for (from, to) in [(utf16("Source Serif 4"), utf16(family)), (b"Source Serif 4".to_vec(), family.as_bytes().to_vec())] {
|
||
assert_eq!(from.len(), to.len());
|
||
let mut i = 0;
|
||
while let Some(at) = data[i..].windows(from.len()).position(|w| w == from) {
|
||
data[i + at..i + at + to.len()].copy_from_slice(&to);
|
||
i += at + to.len();
|
||
}
|
||
}
|
||
data
|
||
}
|
||
|
||
#[test]
|
||
fn type_redraws_when_its_font_becomes_available() {
|
||
let _adding = adding_fonts();
|
||
const FAMILY: &str = "Arrival Serif4";
|
||
let mut d = Document::new(300.0, 150.0);
|
||
let style = CharStyle { size: 60.0, font_family: FAMILY.into(), ..Default::default() };
|
||
let mut n = Node::new(NodeId(0), NodeKind::Text(Box::new(TextObject::point(Point::new(10.0, 100.0), "Hamburg", style))));
|
||
n.id = d.alloc_id();
|
||
let l = d.layers[0].id;
|
||
d.insert(Some(l), 0, n).unwrap();
|
||
let opts = RenderOptions { background: Some([255, 255, 255, 255]), ..Default::default() };
|
||
let mut r = Renderer::new();
|
||
let before = r.render(&d, 300, 150, Affine::IDENTITY, &opts).pixels;
|
||
assert!(vectorcraft_text::FontDb::global().add_font(serif_as(FAMILY)) > 0);
|
||
let after = r.render(&d, 300, 150, Affine::IDENTITY, &opts).pixels;
|
||
assert_ne!(before, after, "drawn in the font that arrived");
|
||
assert_eq!(after, Renderer::new().render(&d, 300, 150, Affine::IDENTITY, &opts).pixels, "as a new renderer draws it");
|
||
}
|
||
|
||
/// Type with raster effects redraws in a font that becomes available: its drop shadow and its
|
||
/// blurred content are made again.
|
||
#[test]
|
||
fn type_with_raster_effects_redraws_when_its_font_becomes_available() {
|
||
let _adding = adding_fonts();
|
||
const FAMILY: &str = "Raster Serif 4";
|
||
let mut d = Document::new(300.0, 150.0);
|
||
let l = d.layers[0].id;
|
||
let effects =
|
||
[("stylize.dropShadow", serde_json::json!({"x": 4, "y": 4, "blur": 1, "opacity": 100})), ("blur.gaussian", serde_json::json!({"radius": 1}))];
|
||
for (i, (id, params)) in effects.into_iter().enumerate() {
|
||
let style = CharStyle { size: 50.0, font_family: FAMILY.into(), ..Default::default() };
|
||
let mut n = Node::new(d.alloc_id(), NodeKind::Text(Box::new(TextObject::point(Point::new(10.0, 60.0 + 70.0 * i as f64), "Hamburg", style))));
|
||
n.appearance.effects.push(vectorcraft_doc::Effect { id: id.into(), params, visible: true });
|
||
d.insert(Some(l), i, n).unwrap();
|
||
}
|
||
let opts = RenderOptions { background: Some([255, 255, 255, 255]), ..Default::default() };
|
||
let mut r = Renderer::new();
|
||
let before = r.render(&d, 300, 150, Affine::IDENTITY, &opts).pixels;
|
||
assert!(vectorcraft_text::FontDb::global().add_font(serif_as(FAMILY)) > 0);
|
||
let after = r.render(&d, 300, 150, Affine::IDENTITY, &opts).pixels;
|
||
assert_ne!(before, after, "drawn in the font that arrived");
|
||
assert_eq!(after, Renderer::new().render(&d, 300, 150, Affine::IDENTITY, &opts).pixels, "as a new renderer draws it");
|
||
}
|
||
|
||
/// Type with Variable Font settings is drawn in a face of their own, which is not a substitute:
|
||
/// Document Setup's highlight of substituted glyphs leaves it alone, and so does Highlight
|
||
/// Alternate Glyphs.
|
||
#[test]
|
||
fn variable_font_settings_are_not_highlighted_as_substituted_glyphs() {
|
||
use vectorcraft_text::test_fonts::{TWO_AXIS_FAMILY, two_axis_font};
|
||
let _adding = adding_fonts();
|
||
vectorcraft_text::FontDb::global().add_font(two_axis_font().unwrap());
|
||
let font_axes = [("wght".to_string(), 650.0)].into_iter().collect();
|
||
let style = CharStyle { size: 40.0, font_family: TWO_AXIS_FAMILY.into(), font_axes, ..Default::default() };
|
||
let t = TextObject::point(Point::new(10.0, 60.0), "lIn", style);
|
||
let g = text_geom(&t);
|
||
assert!(!g.all.elements().is_empty());
|
||
assert!(g.substituted_glyphs.elements().is_empty() && g.substituted_fonts.elements().is_empty());
|
||
assert!(g.alternate_glyphs(&t).elements().is_empty());
|
||
}
|
||
|
||
/// Type in a composite font draws each class of character in its part's face, which is not a
|
||
/// substitute: Document Setup's highlight of substituted glyphs leaves it alone.
|
||
#[test]
|
||
fn composite_font_parts_are_not_highlighted_as_substituted_glyphs() {
|
||
use vectorcraft_doc::{CompositeFont, CompositePart, CompositeParts};
|
||
let _adding = adding_fonts();
|
||
let db = vectorcraft_text::FontDb::global();
|
||
let mut parts = CompositeParts::all(CompositePart::new("Source Sans 3", "Regular"));
|
||
parts.roman = CompositePart::new("JetBrains Mono", "Regular");
|
||
parts.numerals = CompositePart::new("Inter", "Regular");
|
||
db.set_composite_font(&CompositeFont { name: "CF Highlight".into(), parts });
|
||
let style = CharStyle { size: 40.0, font_family: "CF Highlight".into(), ..Default::default() };
|
||
let t = TextObject::point(Point::new(10.0, 60.0), "Ab12", style);
|
||
let g = text_geom(&t);
|
||
db.remove_composite_font("CF Highlight");
|
||
assert!(!g.all.elements().is_empty());
|
||
assert!(g.substituted_glyphs.elements().is_empty() && g.substituted_fonts.elements().is_empty());
|
||
}
|
||
|
||
/// Type in one of a document's composite fonts draws in the document's definition when nothing has
|
||
/// registered it: in a render, an ink render, a thumbnail and a placed document's art, as type set
|
||
/// in the part's font draws.
|
||
/// The font database is left without it afterwards.
|
||
#[test]
|
||
fn a_documents_own_composite_font_draws_without_being_registered() {
|
||
use vectorcraft_doc::{CompositeFont, CompositePart, CompositeParts};
|
||
let _adding = adding_fonts();
|
||
const NAME: &str = "CF Unregistered";
|
||
let db = vectorcraft_text::FontDb::global();
|
||
let typed = |family: &str| {
|
||
let mut d = Document::new(300.0, 150.0);
|
||
let style = CharStyle { size: 60.0, font_family: family.into(), ..Default::default() };
|
||
let n = Node::new(d.alloc_id(), NodeKind::Text(Box::new(TextObject::point(Point::new(10.0, 100.0), "Hamburg", style))));
|
||
let l = d.layers[0].id;
|
||
let id = d.insert(Some(l), 0, n).unwrap();
|
||
(d, id)
|
||
};
|
||
let (mut composite, id) = typed(NAME);
|
||
let mut parts = CompositeParts::all(CompositePart::new("Source Sans 3", "Regular"));
|
||
parts.roman = CompositePart::new("JetBrains Mono", "Regular");
|
||
composite.composite_fonts.push(CompositeFont { name: NAME.into(), parts });
|
||
let (plain, plain_id) = typed("JetBrains Mono");
|
||
assert!(db.composite_font(NAME).is_none());
|
||
let opts = RenderOptions { background: Some([255, 255, 255, 255]), ..Default::default() };
|
||
let view = Affine::IDENTITY;
|
||
assert_eq!(
|
||
Renderer::new().render(&composite, 300, 150, view, &opts).pixels,
|
||
Renderer::new().render(&plain, 300, 150, view, &opts).pixels,
|
||
"rendered"
|
||
);
|
||
let region = Rect::new(0.0, 0.0, 300.0, 150.0);
|
||
assert_eq!(
|
||
Renderer::new().render_region_inks(&composite, region, 1.0, &opts),
|
||
Renderer::new().render_region_inks(&plain, region, 1.0, &opts),
|
||
"rendered as ink amounts"
|
||
);
|
||
let thumbnail = |d: &Document, id| Renderer::new().render_thumbnail(d, id, 64).map(|r| r.pixels);
|
||
assert_eq!(thumbnail(&composite, id), thumbnail(&plain, plain_id), "thumbnail");
|
||
let placed = |d: &Document| crate::placed_document::render_inside(&mut Renderer::new(), d, &d.layers[0], 300, 150, view).map(|r| r.pixels);
|
||
assert_eq!(placed(&composite), placed(&plain), "a placed document's art");
|
||
// A page that places the document, drawn exactly (no bitmap of the placed art).
|
||
let page = |d: &Document, id: NodeId, key: &str| {
|
||
use vectorcraft_doc::{ImageBlob, LinkInfo, PlacedDocument};
|
||
let blob = ImageBlob::new("application/json", key.as_bytes().to_vec());
|
||
let p = PlacedDocument {
|
||
link: LinkInfo::new("/art/type.vectorcraft"),
|
||
key: key.into(),
|
||
bounding: false,
|
||
page_box: Default::default(),
|
||
width: 300.0,
|
||
height: 150.0,
|
||
xf: Affine::IDENTITY,
|
||
placement: Default::default(),
|
||
};
|
||
let art = d.node(id).unwrap().clone();
|
||
vectorcraft_doc::placed_document::prime(&p, blob.bytes.clone(), (d.clone(), art, Rect::new(0.0, 0.0, 300.0, 150.0)));
|
||
let mut page = Document::new(300.0, 150.0);
|
||
page.images.insert(key.into(), blob);
|
||
let n = Node::new(page.alloc_id(), NodeKind::PlacedDocument(Box::new(p)));
|
||
let l = page.layers[0].id;
|
||
page.insert(Some(l), 0, n).unwrap();
|
||
Renderer::new().render(&page, 300, 150, view, &opts).pixels
|
||
};
|
||
assert_eq!(
|
||
page(&composite, id, "fontchange-composite-placed"),
|
||
page(&plain, plain_id, "fontchange-plain-placed"),
|
||
"a placed document's art drawn exactly"
|
||
);
|
||
assert!(db.composite_font(NAME).is_none(), "given back after each render");
|
||
}
|
||
|
||
/// A placed document draws its type in its own definition of a composite font that the document
|
||
/// placing it defines differently.
|
||
#[test]
|
||
fn a_placed_document_draws_its_own_definition_of_a_name_the_page_defines() {
|
||
use vectorcraft_doc::{CompositeFont, CompositePart, CompositeParts, ImageBlob, LinkInfo, PlacedDocument};
|
||
let _adding = adding_fonts();
|
||
const NAME: &str = "CF Placed Twice";
|
||
let definition = |roman: &str| {
|
||
let mut parts = CompositeParts::all(CompositePart::new("Source Sans 3", "Regular"));
|
||
parts.roman = CompositePart::new(roman, "Regular");
|
||
CompositeFont { name: NAME.into(), parts }
|
||
};
|
||
let typed = |family: &str| {
|
||
let mut d = Document::new(300.0, 150.0);
|
||
let style = CharStyle { size: 60.0, font_family: family.into(), ..Default::default() };
|
||
let n = Node::new(d.alloc_id(), NodeKind::Text(Box::new(TextObject::point(Point::new(10.0, 100.0), "Hamburg", style))));
|
||
let l = d.layers[0].id;
|
||
let id = d.insert(Some(l), 0, n).unwrap();
|
||
(d, id)
|
||
};
|
||
let opts = RenderOptions { background: Some([255, 255, 255, 255]), ..Default::default() };
|
||
// A page placing `d` (drawn exactly), defining `fonts`.
|
||
let page = |d: &Document, id: NodeId, key: &str, fonts: Vec<CompositeFont>| {
|
||
let blob = ImageBlob::new("application/json", key.as_bytes().to_vec());
|
||
let p = PlacedDocument {
|
||
link: LinkInfo::new("/art/type.vectorcraft"),
|
||
key: key.into(),
|
||
bounding: false,
|
||
page_box: Default::default(),
|
||
width: 300.0,
|
||
height: 150.0,
|
||
xf: Affine::IDENTITY,
|
||
placement: Default::default(),
|
||
};
|
||
let art = d.node(id).unwrap().clone();
|
||
vectorcraft_doc::placed_document::prime(&p, blob.bytes.clone(), (d.clone(), art, Rect::new(0.0, 0.0, 300.0, 150.0)));
|
||
let mut page = Document::new(300.0, 150.0);
|
||
page.composite_fonts.extend(fonts);
|
||
page.images.insert(key.into(), blob);
|
||
let n = Node::new(page.alloc_id(), NodeKind::PlacedDocument(Box::new(p)));
|
||
let l = page.layers[0].id;
|
||
page.insert(Some(l), 0, n).unwrap();
|
||
Renderer::new().render(&page, 300, 150, Affine::IDENTITY, &opts).pixels
|
||
};
|
||
let (mut placed, id) = typed(NAME);
|
||
placed.composite_fonts.push(definition("JetBrains Mono"));
|
||
let (plain, plain_id) = typed("JetBrains Mono");
|
||
let (inter, inter_id) = typed("Inter");
|
||
let own = page(&placed, id, "fontchange-placed-twice", vec![definition("Inter")]);
|
||
assert!(own == page(&plain, plain_id, "fontchange-placed-twice-plain", vec![]), "drawn in the placed document's definition");
|
||
assert!(own != page(&inter, inter_id, "fontchange-placed-twice-inter", vec![]), "not in the page's");
|
||
assert!(vectorcraft_text::FontDb::global().composite_font(NAME).is_none());
|
||
}
|
||
|
||
/// Type at 80% opacity, in Multiply and with a drop shadow redraws in a font that becomes
|
||
/// available: the glyph geometry kept for it is laid out again.
|
||
#[test]
|
||
fn translucent_blended_and_shadowed_type_redraws_when_its_font_becomes_available() {
|
||
let _adding = adding_fonts();
|
||
const FAMILY: &str = "Blended Serif4";
|
||
let mut d = Document::new(300.0, 150.0);
|
||
let l = d.layers[0].id;
|
||
for i in 0..3 {
|
||
let style = CharStyle { size: 36.0, font_family: FAMILY.into(), ..Default::default() };
|
||
let mut n = Node::new(d.alloc_id(), NodeKind::Text(Box::new(TextObject::point(Point::new(10.0, 40.0 + 45.0 * i as f64), "Hamburg", style))));
|
||
match i {
|
||
0 => n.opacity = 0.8,
|
||
1 => n.blend = vectorcraft_color::BlendMode::Multiply,
|
||
_ => n.appearance.effects.push(vectorcraft_doc::Effect {
|
||
id: "stylize.dropShadow".into(),
|
||
params: serde_json::json!({"x": 4, "y": 4, "blur": 1, "opacity": 100}),
|
||
visible: true,
|
||
}),
|
||
}
|
||
d.insert(Some(l), i, n).unwrap();
|
||
}
|
||
let opts = RenderOptions { background: Some([255, 255, 255, 255]), ..Default::default() };
|
||
let mut r = Renderer::new();
|
||
let before = r.render(&d, 300, 150, Affine::IDENTITY, &opts).pixels;
|
||
assert_eq!(r.render(&d, 300, 150, Affine::IDENTITY, &opts).pixels, before, "drawn again from the kept glyph geometry");
|
||
assert!(vectorcraft_text::FontDb::global().add_font(serif_as(FAMILY)) > 0);
|
||
let after = r.render(&d, 300, 150, Affine::IDENTITY, &opts).pixels;
|
||
assert_ne!(before, after, "drawn in the font that arrived");
|
||
assert_eq!(after, Renderer::new().render(&d, 300, 150, Affine::IDENTITY, &opts).pixels, "as a new renderer draws it");
|
||
}
|
||
|
||
/// Type with a geometry effect in a symbol's art redraws in a font that becomes available: the art
|
||
/// kept for the instance is placed again when the fonts change.
|
||
#[test]
|
||
fn symbol_type_redraws_when_its_font_becomes_available() {
|
||
let _adding = adding_fonts();
|
||
const FAMILY: &str = "Placed Serif 4";
|
||
let mut d = Document::new(300.0, 150.0);
|
||
let style = CharStyle { size: 60.0, font_family: FAMILY.into(), ..Default::default() };
|
||
let mut t = Node::new(d.alloc_id(), NodeKind::Text(Box::new(TextObject::point(Point::new(-140.0, 25.0), "Hamburg", style))));
|
||
t.appearance.effects.push(vectorcraft_doc::Effect { id: "distort.transform".into(), params: serde_json::json!({"moveH": 0.0}), visible: true });
|
||
let art = Node::group(d.alloc_id(), vec![Arc::new(t)]);
|
||
d.symbols.push(vectorcraft_doc::Symbol { dynamic: false, name: "Word".into(), art: Arc::new(art) });
|
||
let (l, id) = (d.layers[0].id, d.alloc_id());
|
||
d.insert(Some(l), 0, Node::new(id, NodeKind::SymbolInstance { symbol: "Word".into(), xf: Affine::translate((150.0, 75.0)) })).unwrap();
|
||
let opts = RenderOptions { background: Some([255, 255, 255, 255]), ..Default::default() };
|
||
let mut r = Renderer::new();
|
||
let before = r.render(&d, 300, 150, Affine::IDENTITY, &opts).pixels;
|
||
assert!(vectorcraft_text::FontDb::global().add_font(serif_as(FAMILY)) > 0);
|
||
let after = r.render(&d, 300, 150, Affine::IDENTITY, &opts).pixels;
|
||
assert_ne!(before, after, "drawn in the font that arrived");
|
||
assert_eq!(after, Renderer::new().render(&d, 300, 150, Affine::IDENTITY, &opts).pixels, "as a new renderer draws it");
|
||
}
|
||
|
||
/// Type that a geometry effect outlines redraws in a font that becomes available: the art drawn for
|
||
/// the effects of the type, of a group that holds it and of a symbol instance whose art holds it
|
||
/// is made again when the fonts change.
|
||
#[test]
|
||
fn type_with_geometry_effects_redraws_when_its_font_becomes_available() {
|
||
let _adding = adding_fonts();
|
||
use vectorcraft_doc::Effect;
|
||
let moved = || Effect { id: "distort.transform".into(), params: serde_json::json!({"moveH": 0.0}), visible: true };
|
||
let cases = [
|
||
("Moving Serif 4", "the type with a Transform effect"),
|
||
("Shadow Serif 5", "the type with a Transform effect and a drop shadow"),
|
||
("Massed Serif 4", "the group with a Transform effect"),
|
||
("Stamps Serif 4", "the symbol instance with a Transform effect"),
|
||
("Darker Serif 4", "the type with a Transform effect in Multiply"),
|
||
];
|
||
for (i, (family, what)) in cases.into_iter().enumerate() {
|
||
let mut d = Document::new(300.0, 150.0);
|
||
let style = CharStyle { size: 50.0, font_family: family.into(), ..Default::default() };
|
||
let at = if i == 3 { Point::new(-140.0, 20.0) } else { Point::new(10.0, 80.0) };
|
||
let mut object = Node::new(d.alloc_id(), NodeKind::Text(Box::new(TextObject::point(at, "Hamburg", style))));
|
||
match i {
|
||
0 => object.appearance.effects.push(moved()),
|
||
1 => {
|
||
object.appearance.effects.push(moved());
|
||
let params = serde_json::json!({"x": 4, "y": 4, "blur": 1, "opacity": 100});
|
||
object.appearance.effects.push(Effect { id: "stylize.dropShadow".into(), params, visible: true });
|
||
}
|
||
2 => {
|
||
object = Node::group(d.alloc_id(), vec![Arc::new(object)]);
|
||
object.appearance.effects.push(moved());
|
||
}
|
||
3 => {
|
||
let art = Node::group(d.alloc_id(), vec![Arc::new(object)]);
|
||
d.symbols.push(vectorcraft_doc::Symbol { dynamic: false, name: "Word".into(), art: Arc::new(art) });
|
||
object = Node::new(d.alloc_id(), NodeKind::SymbolInstance { symbol: "Word".into(), xf: Affine::translate((150.0, 75.0)) });
|
||
object.appearance.effects.push(moved());
|
||
}
|
||
_ => {
|
||
object.appearance.effects.push(moved());
|
||
object.blend = vectorcraft_color::BlendMode::Multiply;
|
||
}
|
||
}
|
||
let l = d.layers[0].id;
|
||
d.insert(Some(l), 0, object).unwrap();
|
||
let opts = RenderOptions { background: Some([255, 255, 255, 255]), ..Default::default() };
|
||
let mut r = Renderer::new();
|
||
let before = r.render(&d, 300, 150, Affine::IDENTITY, &opts).pixels;
|
||
assert!(vectorcraft_text::FontDb::global().add_font(serif_as(family)) > 0);
|
||
let after = r.render(&d, 300, 150, Affine::IDENTITY, &opts).pixels;
|
||
assert_ne!(before, after, "{what}: drawn in the font that arrived");
|
||
assert_eq!(after, Renderer::new().render(&d, 300, 150, Affine::IDENTITY, &opts).pixels, "{what}: as a new renderer draws it");
|
||
}
|
||
}
|
||
|
||
/// Type that an envelope bends redraws in a font that becomes available, in the envelope and in
|
||
/// the art of a symbol whose instance an envelope bends: the envelopes are evaluated again when the
|
||
/// fonts change.
|
||
#[test]
|
||
fn enveloped_type_redraws_when_its_font_becomes_available() {
|
||
let _adding = adding_fonts();
|
||
const FAMILY: &str = "Warped Serif 4";
|
||
let mut d = Document::new(300.0, 150.0);
|
||
let word = |d: &mut Document, at: Point| {
|
||
let style = CharStyle { size: 50.0, font_family: FAMILY.into(), ..Default::default() };
|
||
Node::new(d.alloc_id(), NodeKind::Text(Box::new(TextObject::point(at, "Hamburg", style))))
|
||
};
|
||
let typed = word(&mut d, Point::new(10.0, 60.0));
|
||
let art = word(&mut d, Point::new(-140.0, 20.0));
|
||
let art = Node::group(d.alloc_id(), vec![Arc::new(art)]);
|
||
d.symbols.push(vectorcraft_doc::Symbol { dynamic: false, name: "Word".into(), art: Arc::new(art) });
|
||
let shown = Node::new(d.alloc_id(), NodeKind::SymbolInstance { symbol: "Word".into(), xf: Affine::translate((150.0, 120.0)) });
|
||
let l = d.layers[0].id;
|
||
for (i, content) in [typed, shown].into_iter().enumerate() {
|
||
let kind = vectorcraft_doc::EnvelopeKind::Warp { style: "arc".into(), bend: 30.0, h: 0.0, v: 0.0, horizontal: true, version: 0 };
|
||
let envelope = NodeKind::Envelope {
|
||
content: vec![Arc::new(content)],
|
||
kind: Box::new(kind),
|
||
fidelity: 50.0,
|
||
editing: false,
|
||
options: Default::default(),
|
||
frame: Box::new(Affine::IDENTITY),
|
||
};
|
||
let id = d.alloc_id();
|
||
d.insert(Some(l), i, Node::new(id, envelope)).unwrap();
|
||
}
|
||
let opts = RenderOptions { background: Some([255, 255, 255, 255]), ..Default::default() };
|
||
let mut r = Renderer::new();
|
||
let before = r.render(&d, 300, 150, Affine::IDENTITY, &opts).pixels;
|
||
assert!(vectorcraft_text::FontDb::global().add_font(serif_as(FAMILY)) > 0);
|
||
let after = r.render(&d, 300, 150, Affine::IDENTITY, &opts).pixels;
|
||
assert_ne!(before, after, "drawn in the font that arrived");
|
||
assert_eq!(after, Renderer::new().render(&d, 300, 150, Affine::IDENTITY, &opts).pixels, "as a new renderer draws it");
|
||
}
|
||
|
||
/// Type that an envelope bends redraws in a font that becomes available when the art drawn for
|
||
/// effects is made from the envelope's evaluation: the envelope with a drop shadow, and the
|
||
/// envelope in a group with a geometry effect or with a fill of its own.
|
||
#[test]
|
||
fn enveloped_type_under_effects_redraws_when_its_font_becomes_available() {
|
||
let _adding = adding_fonts();
|
||
use vectorcraft_color::{Color, Paint};
|
||
use vectorcraft_doc::{AppearanceItem, Effect, FillLayer};
|
||
let cases = [
|
||
("Shadow Serif 4", "the envelope with a drop shadow"),
|
||
("Effect Serif 4", "the group with a geometry effect"),
|
||
("Filled Serif 4", "the group with a fill"),
|
||
];
|
||
for (i, (family, what)) in cases.into_iter().enumerate() {
|
||
let mut d = Document::new(300.0, 150.0);
|
||
let style = CharStyle { size: 50.0, font_family: family.into(), ..Default::default() };
|
||
let typed = Node::new(d.alloc_id(), NodeKind::Text(Box::new(TextObject::point(Point::new(10.0, 80.0), "Hamburg", style))));
|
||
let kind = vectorcraft_doc::EnvelopeKind::Warp { style: "arc".into(), bend: 30.0, h: 0.0, v: 0.0, horizontal: true, version: 0 };
|
||
let envelope = NodeKind::Envelope {
|
||
content: vec![Arc::new(typed)],
|
||
kind: Box::new(kind),
|
||
fidelity: 50.0,
|
||
editing: false,
|
||
options: Default::default(),
|
||
frame: Box::new(Affine::IDENTITY),
|
||
};
|
||
let mut object = Node::new(d.alloc_id(), envelope);
|
||
match i {
|
||
0 => {
|
||
let params = serde_json::json!({"x": 4, "y": 4, "blur": 1, "opacity": 100});
|
||
object.appearance.effects.push(Effect { id: "stylize.dropShadow".into(), params, visible: true });
|
||
}
|
||
1 => {
|
||
object = Node::group(d.alloc_id(), vec![Arc::new(object)]);
|
||
object.appearance.effects.push(Effect { id: "distort.transform".into(), params: serde_json::json!({"moveH": 0.0}), visible: true });
|
||
}
|
||
_ => {
|
||
object = Node::group(d.alloc_id(), vec![Arc::new(object)]);
|
||
object.appearance.items.push(AppearanceItem::Fill(FillLayer::new(Paint::solid(Color::rgb(1.0, 0.0, 0.0)))));
|
||
}
|
||
}
|
||
let l = d.layers[0].id;
|
||
d.insert(Some(l), 0, object).unwrap();
|
||
let opts = RenderOptions { background: Some([255, 255, 255, 255]), ..Default::default() };
|
||
let mut r = Renderer::new();
|
||
let before = r.render(&d, 300, 150, Affine::IDENTITY, &opts).pixels;
|
||
assert!(vectorcraft_text::FontDb::global().add_font(serif_as(family)) > 0);
|
||
let after = r.render(&d, 300, 150, Affine::IDENTITY, &opts).pixels;
|
||
assert_ne!(before, after, "{what}: drawn in the font that arrived");
|
||
assert_eq!(after, Renderer::new().render(&d, 300, 150, Affine::IDENTITY, &opts).pixels, "{what}: as a new renderer draws it");
|
||
}
|
||
}
|
||
|
||
/// Hyphenated area type redraws with its new line breaks when Preferences › Hyphenation ›
|
||
/// Exceptions change: its glyph geometry, the pixels of its raster effects, the art drawn for
|
||
/// geometry effects, the art kept for a symbol instance and an envelope's evaluation are made
|
||
/// again.
|
||
#[test]
|
||
fn hyphenated_type_redraws_when_the_exceptions_change() {
|
||
let _adding = adding_fonts();
|
||
struct Clear;
|
||
impl Drop for Clear {
|
||
fn drop(&mut self) {
|
||
vectorcraft_text::set_hyphenation_exceptions("");
|
||
}
|
||
}
|
||
let _clear = Clear;
|
||
use vectorcraft_doc::Effect;
|
||
let moved = || Effect { id: "distort.transform".into(), params: serde_json::json!({"moveH": 0.0}), visible: true };
|
||
const WORDS: &str = "Extraordinarily comprehensive typographical considerations notwithstanding everything.";
|
||
const NEVER: &str = "extraordinarily, comprehensive, typographical, considerations, notwithstanding";
|
||
let cases = ["the area type", "the type with a drop shadow", "the group with a Transform effect", "the symbol instance", "the envelope"];
|
||
for (i, what) in cases.into_iter().enumerate() {
|
||
vectorcraft_text::set_hyphenation_exceptions("");
|
||
let mut d = Document::new(300.0, 150.0);
|
||
let mut t = TextObject::point(Point::ZERO, WORDS, CharStyle { size: 14.0, ..Default::default() });
|
||
t.kind = TextKind::Area { frame: PathData::from_bezpath(&Rect::new(10.0, 10.0, 130.0, 145.0).to_path(0.1)) };
|
||
t.xf = Affine::IDENTITY;
|
||
t.para.hyphenate = true;
|
||
let mut object = Node::new(d.alloc_id(), NodeKind::Text(Box::new(t)));
|
||
match i {
|
||
0 => {}
|
||
1 => {
|
||
let params = serde_json::json!({"x": 4, "y": 4, "blur": 1, "opacity": 100});
|
||
object.appearance.effects.push(Effect { id: "stylize.dropShadow".into(), params, visible: true });
|
||
}
|
||
2 => {
|
||
object = Node::group(d.alloc_id(), vec![Arc::new(object)]);
|
||
object.appearance.effects.push(moved());
|
||
}
|
||
3 => {
|
||
object.appearance.effects.push(moved());
|
||
let art = Node::group(d.alloc_id(), vec![Arc::new(object)]);
|
||
d.symbols.push(vectorcraft_doc::Symbol { dynamic: false, name: "Words".into(), art: Arc::new(art) });
|
||
object = Node::new(d.alloc_id(), NodeKind::SymbolInstance { symbol: "Words".into(), xf: Affine::IDENTITY });
|
||
}
|
||
_ => {
|
||
let kind = vectorcraft_doc::EnvelopeKind::Warp { style: "arc".into(), bend: 30.0, h: 0.0, v: 0.0, horizontal: true, version: 0 };
|
||
let envelope = NodeKind::Envelope {
|
||
content: vec![Arc::new(object)],
|
||
kind: Box::new(kind),
|
||
fidelity: 50.0,
|
||
editing: false,
|
||
options: Default::default(),
|
||
frame: Box::new(Affine::IDENTITY),
|
||
};
|
||
object = Node::new(d.alloc_id(), envelope);
|
||
}
|
||
}
|
||
let l = d.layers[0].id;
|
||
d.insert(Some(l), 0, object).unwrap();
|
||
let opts = RenderOptions { background: Some([255, 255, 255, 255]), ..Default::default() };
|
||
let mut r = Renderer::new();
|
||
let before = r.render(&d, 300, 150, Affine::IDENTITY, &opts).pixels;
|
||
vectorcraft_text::set_hyphenation_exceptions(NEVER);
|
||
let after = r.render(&d, 300, 150, Affine::IDENTITY, &opts).pixels;
|
||
let fresh = Renderer::new().render(&d, 300, 150, Affine::IDENTITY, &opts).pixels;
|
||
assert_ne!(before, fresh, "{what}: the words in the list are not broken");
|
||
assert!(after == fresh, "{what}: drawn as a new renderer draws it");
|
||
}
|
||
}
|
||
|
||
/// Without an engine session, a renderer maps an envelope of type from its glyph outline bounds,
|
||
/// and measures the type again when its font becomes available.
|
||
#[test]
|
||
fn a_renderer_maps_enveloped_type_from_its_glyphs_in_the_current_font() {
|
||
let _adding = adding_fonts();
|
||
const FAMILY: &str = "Mapped Serif 4";
|
||
let style = CharStyle { size: 50.0, font_family: FAMILY.into(), ..Default::default() };
|
||
let t = TextObject::point(Point::new(10.0, 60.0), "Hamburg", style);
|
||
let kind = vectorcraft_doc::EnvelopeKind::Warp { style: "arc".into(), bend: 30.0, h: 0.0, v: 0.0, horizontal: true, version: 0 };
|
||
let envelope = Node::new(
|
||
vectorcraft_doc::NodeId(1),
|
||
NodeKind::Envelope {
|
||
content: vec![Arc::new(Node::new(vectorcraft_doc::NodeId(2), NodeKind::Text(Box::new(t.clone()))))],
|
||
kind: Box::new(kind),
|
||
fidelity: 50.0,
|
||
editing: false,
|
||
options: Default::default(),
|
||
frame: Box::new(Affine::IDENTITY),
|
||
},
|
||
);
|
||
let ink = || t.xf.transform_rect_bbox(vectorcraft_text::layout(vectorcraft_text::FontDb::global(), &t).ink_bounds().unwrap());
|
||
let src = || vectorcraft_doc::live::EnvelopeMap::of(&envelope).unwrap().src();
|
||
let off = |a: Rect, b: Rect| [a.x0 - b.x0, a.y0 - b.y0, a.x1 - b.x1, a.y1 - b.y1].iter().fold(0.0f64, |m, v| m.max(v.abs()));
|
||
let _ = Renderer::new();
|
||
let before = ink();
|
||
assert!(off(src(), before) < 1e-6, "{:?} vs {before:?}", src());
|
||
assert!(vectorcraft_text::FontDb::global().add_font(serif_as(FAMILY)) > 0);
|
||
let after = ink();
|
||
assert!(off(before, after) > 0.5, "the type draws in the font that arrived: {before:?} vs {after:?}");
|
||
assert!(off(src(), after) < 1e-6, "{:?} vs {after:?}", src());
|
||
}
|
||
|
||
/// 3D type measured for an edit ([`Renderer::changed`]) and drawn after its font became available
|
||
/// is drawn in that font: the art made to measure it, in the font it had, isn't taken.
|
||
#[test]
|
||
fn three_d_type_measured_before_its_font_arrives_draws_in_it() {
|
||
let _adding = adding_fonts();
|
||
const FAMILY: &str = "Solid Serif 44";
|
||
let mut old = Document::new(300.0, 150.0);
|
||
let style = CharStyle { size: 60.0, font_family: FAMILY.into(), ..Default::default() };
|
||
let mut n = Node::new(NodeId(0), NodeKind::Text(Box::new(TextObject::point(Point::new(10.0, 100.0), "Hamburg", style))));
|
||
n.id = old.alloc_id();
|
||
let extrude = |depth: f64| vectorcraft_doc::Effect {
|
||
id: "threeD.extrude".into(),
|
||
params: serde_json::json!({"depth": depth, "position": "isometricTop"}),
|
||
visible: true,
|
||
};
|
||
n.appearance.effects.push(extrude(40.0));
|
||
let l = old.layers[0].id;
|
||
let id = old.insert(Some(l), 0, n).unwrap();
|
||
let mut new = old.clone();
|
||
new.node_mut(id).unwrap().appearance.effects[0] = extrude(10.0);
|
||
let opts = RenderOptions { background: Some([255, 255, 255, 255]), ..Default::default() };
|
||
let mut r = Renderer::new();
|
||
r.render(&old, 300, 150, Affine::IDENTITY, &opts);
|
||
let _ = r.changed(&old, &new, &opts);
|
||
assert!(vectorcraft_text::FontDb::global().add_font(serif_as(FAMILY)) > 0);
|
||
let drawn = r.render(&new, 300, 150, Affine::IDENTITY, &opts).pixels;
|
||
let fresh = Renderer::new().render(&new, 300, 150, Affine::IDENTITY, &opts).pixels;
|
||
let differ = drawn.iter().zip(&fresh).filter(|(a, b)| a != b).count();
|
||
assert_eq!(differ, 0, "as a new renderer draws it");
|
||
}
|