mirror of
https://github.com/storytold/vectorcraft.git
synced 2026-11-19 05:35:49 +00:00
Type > Composite Fonts... has Custom: named character sets, each setting the characters it lists in its own font, style, size, baseline and scales ahead of their class. The later of two sets that list a character sets it. Characters are added by Direct Entry or by Unicode code and deleted one at a time, and the parts table scrolls when it grows. - type.compositeFonts.set takes `custom`; part keys left out take the Kanji part's values. Sets are saved with the document and in .vccomposite files, and Export refuses a file over 4 MB. - VectorCraft's own limits: 64 sets per font, 8,192 characters per set, each character once per set, up to U+FFFF and no control characters. - The font database caches each font's character lookup. Docs: docs/mcp.md, docs/type-parity.md, docs/target-app-parity.md.
665 lines
36 KiB
Rust
665 lines
36 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 missing font that starts before its open path: only the characters drawn on the path
|
||
/// are highlighted as substituted.
|
||
#[test]
|
||
fn characters_before_an_open_path_are_not_highlighted() {
|
||
let _steady = fonts_steady();
|
||
let style = CharStyle { size: 20.0, font_family: "No Such Family 5932".into(), ..Default::default() };
|
||
let mut t = TextObject::point(Point::ZERO, "MMMM", style);
|
||
let mut line = vectorcraft_geom::BezPath::new();
|
||
line.move_to((0.0, 50.0));
|
||
line.line_to((500.0, 50.0));
|
||
t.kind = TextKind::OnPath { path: PathData::from_bezpath(&line), start: 0.0, end: None };
|
||
let whole = text_geom(&t).substituted_fonts;
|
||
assert!(!whole.elements().is_empty());
|
||
t.kind = TextKind::OnPath { path: PathData::from_bezpath(&line), start: -0.9, end: None };
|
||
let g = text_geom(&t);
|
||
assert!(g.all.elements().is_empty() && g.substituted_fonts.elements().is_empty(), "{:?}", g.substituted_fonts);
|
||
}
|
||
|
||
/// 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, custom: Vec::new() });
|
||
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, custom: Vec::new() });
|
||
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, and as missing in one only the document placing it defines.
|
||
#[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, custom: Vec::new() }
|
||
};
|
||
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());
|
||
// A placed document that defines no composite font draws type naming the page's as missing.
|
||
let (undefined, undefined_id) = typed(NAME);
|
||
let (missing, missing_id) = typed("CF Placed Nowhere");
|
||
let borrowed = page(&undefined, undefined_id, "fontchange-placed-undefined", vec![definition("Inter")]);
|
||
assert!(borrowed == page(&missing, missing_id, "fontchange-placed-missing", vec![]), "drawn as in a missing font");
|
||
assert!(borrowed != page(&inter, inter_id, "fontchange-placed-undefined-inter", vec![]), "not in the page's definition");
|
||
}
|
||
|
||
/// A document that defines no composite font, drawn while another document's composite font of
|
||
/// the name its type is set in is registered (that document in front), draws that type as in a
|
||
/// missing font: in a render, an ink render, a thumbnail and a node render.
|
||
#[test]
|
||
fn a_document_draws_type_in_another_documents_composite_font_as_missing() {
|
||
use vectorcraft_doc::{CompositeFont, CompositePart, CompositeParts};
|
||
let _adding = adding_fonts();
|
||
const NAME: &str = "CF Front Only";
|
||
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 (back, id) = typed(NAME);
|
||
let (missing, missing_id) = typed("CF Front Nowhere");
|
||
let (plain, plain_id) = typed("JetBrains Mono");
|
||
let opts = RenderOptions { background: Some([255, 255, 255, 255]), ..Default::default() };
|
||
let region = Rect::new(0.0, 0.0, 300.0, 150.0);
|
||
let draw = |d: &Document, id: NodeId| {
|
||
let n = d.node(id).unwrap().clone();
|
||
(
|
||
Renderer::new().render(d, 300, 150, Affine::IDENTITY, &opts).pixels,
|
||
Renderer::new().render_region_inks(d, region, 1.0, &opts),
|
||
Renderer::new().render_thumbnail(d, id, 64).map(|r| r.pixels),
|
||
Renderer::new().render_node(d, &std::sync::Arc::new(n), 300, 150, Affine::IDENTITY).map(|r| r.pixels),
|
||
)
|
||
};
|
||
let mut parts = CompositeParts::all(CompositePart::new("Source Sans 3", "Regular"));
|
||
parts.roman = CompositePart::new("JetBrains Mono", "Regular");
|
||
db.set_composite_font(&CompositeFont { name: NAME.into(), parts, custom: Vec::new() });
|
||
let (drawn, as_missing, in_front) = (draw(&back, id), draw(&missing, missing_id), draw(&plain, plain_id));
|
||
db.remove_composite_font(NAME);
|
||
assert!(drawn.0 != in_front.0, "not in the front document's definition");
|
||
assert!(drawn.0 == as_missing.0, "rendered");
|
||
assert!(drawn.1 == as_missing.1, "rendered as ink amounts");
|
||
assert!(drawn.2 == as_missing.2, "thumbnail");
|
||
assert!(drawn.3 == as_missing.3, "node");
|
||
}
|
||
|
||
/// 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");
|
||
}
|