//! PSD export: the header, the layer records (names, bounds, opacity, blend modes, groups, //! hidden layers), the merged image, the colour models, the slices, and a reader's view of the //! file. use std::sync::Arc; use vectorcraft_color::{BlendMode, Color}; use vectorcraft_doc::{Document, LayerColor, Node, NodeId, Slice, SliceKind, SliceOptions}; use vectorcraft_geom::Rect; use vectorcraft_testkit::fixtures::DocBuilder; use super::jpeg::ColorModel; use super::psd::{MAX_SIDE, MAX_SLICE_TEXT, MAX_SLICES, PsdOptions, room}; use super::*; /// A 100 × 60 pt document: a red square on Layer 1, and on "Top" a half-opaque blue multiply /// square overlapping it, a hidden green one and a sublayer "Inner" holding a grey "Corner". fn doc() -> Document { let mut b = DocBuilder::new(100.0, 60.0); b.rect(Rect::new(10.0, 10.0, 40.0, 40.0), Color::rgb8(255, 0, 0), |_| {}); let top = b.layer("Top"); b.rect(Rect::new(30.0, 20.0, 60.0, 50.0), Color::rgb8(0, 0, 255), |n: &mut Node| { n.opacity = 0.5; n.blend = BlendMode::Multiply; }); b.rect(Rect::new(70.0, 5.0, 90.0, 25.0), Color::rgb8(0, 255, 0), |n: &mut Node| n.visible = false); let corner = b.rect_node(Rect::new(0.0, 0.0, 6.0, 6.0), Color::rgb8(128, 128, 128)); let corner = Node { name: Some("Corner".into()), ..corner }; let inner = Node::layer(b.alloc(), "Inner", LayerColor::Preset(2)); let inner = b.doc.insert(Some(top), usize::MAX, inner).unwrap(); b.doc.insert(Some(inner), usize::MAX, corner).unwrap(); b.build() } fn opts(psd: PsdOptions) -> RasterExportOptions { RasterExportOptions { psd: PsdOptions { embed_icc: false, ..psd }, ..RasterExportOptions::default() } } fn export(doc: &Document, o: &RasterExportOptions) -> Vec { Renderer::new().export_region(doc, doc.artboards[0].rect, RasterFormat::Psd, o).unwrap() } fn u16_at(f: &[u8], at: usize) -> u16 { u16::from_be_bytes(f[at..at + 2].try_into().unwrap()) } fn u32_at(f: &[u8], at: usize) -> usize { u32::from_be_bytes(f[at..at + 4].try_into().unwrap()) as usize } /// A layer record as written. #[derive(Debug)] struct Rec { name: String, /// Top, left, bottom, right. rect: [i32; 4], channels: usize, blend: [u8; 4], opacity: u8, hidden: bool, divider: Option, /// The type tool object of a type layer. type_tool: Option>, } /// The file: header channels, colour mode, image resources, layer count and records. struct Parsed<'a> { channels: u16, mode: u16, resources: &'a [u8], count: i16, records: Vec, /// Where the merged image starts. image: usize, } fn parse(f: &[u8]) -> Parsed<'_> { assert_eq!(&f[..6], b"8BPS\0\x01"); let (channels, mode) = (u16_at(f, 12), u16_at(f, 24)); let mut at = 26; at += 4 + u32_at(f, at); let resources = &f[at + 4..at + 4 + u32_at(f, at)]; at += 4 + resources.len(); let image = at + 4 + u32_at(f, at); let mut out = Parsed { channels, mode, resources, count: 0, records: vec![], image }; if u32_at(f, at) == 0 { return out; } out.count = u16_at(f, at + 8) as i16; let mut p = at + 10; for _ in 0..out.count.unsigned_abs() { let rect: [i32; 4] = std::array::from_fn(|i| u32_at(f, p + i * 4) as i32); let channels = u16_at(f, p + 16) as usize; p += 18 + channels * 6; assert_eq!(&f[p..p + 4], b"8BIM"); let blend: [u8; 4] = f[p + 4..p + 8].try_into().unwrap(); let (opacity, flags) = (f[p + 8], f[p + 10]); let end = p + 16 + u32_at(f, p + 12); let mut q = p + 16 + 8; q += (1 + f[q] as usize).next_multiple_of(4); let (mut name, mut divider, mut type_tool) = (String::new(), None, None); while q < end { assert_eq!(&f[q..q + 4], b"8BIM"); let len = u32_at(f, q + 8); let data = &f[q + 12..q + 12 + len]; match &f[q + 4..q + 8] { b"luni" => name = String::from_utf16(&(0..u32_at(data, 0)).map(|i| u16_at(data, 4 + i * 2)).collect::>()).unwrap(), b"lsct" => divider = Some(u32_at(data, 0)), b"TySh" => type_tool = Some(data.to_vec()), _ => {} } q += 12 + len; } out.records.push(Rec { name, rect, channels, blend, opacity, hidden: flags & 2 != 0, divider, type_tool }); p = end; } out } /// The merged image's planes (`channels` planes of `w` × `h`), unpacked. fn merged_planes(f: &[u8], channels: usize, w: usize, h: usize) -> Vec> { let data = &f[parse(f).image..]; assert_eq!(u16_at(data, 0), 1, "PackBits"); let mut q = 2 + channels * h * 2; (0..channels) .map(|c| { let mut plane = vec![]; for row in 0..h { let n = u16_at(data, 2 + (c * h + row) * 2) as usize; unpack(&data[q..q + n], &mut plane); q += n; } assert_eq!(plane.len(), w * h); plane }) .collect() } fn unpack(mut src: &[u8], out: &mut Vec) { while let Some((&n, rest)) = src.split_first() { if n < 128 { out.extend(&rest[..n as usize + 1]); src = &rest[n as usize + 1..]; } else { out.extend(std::iter::repeat_n(rest[0], 257 - n as usize)); src = &rest[1..]; } } } /// The stored composite: RGB stays white-matted, with its original alpha. fn merged(f: &[u8]) -> Vec { let psd = craft_psd::PsdFile::from_bytes(f).expect("a PSD a reader takes"); if psd.header.color_mode != craft_psd::ColorMode::Rgb { return psd.composite_rgba8().expect("composite").data; } assert_eq!(psd.header.depth, 8); let samples = psd.decode_merged().expect("stored composite planes"); let count = psd.header.width as usize * psd.header.height as usize; (0..count) .flat_map(|i| [samples[i], samples[count + i], samples[2 * count + i], if psd.merged_has_alpha() { samples[3 * count + i] } else { 255 }]) .collect() } fn pixel(px: &[u8], width: usize, x: usize, y: usize) -> [u8; 4] { px[(y * width + x) * 4..][..4].try_into().unwrap() } #[test] fn layers_are_the_top_level_layers_and_the_merged_image_is_the_render() { let doc = doc(); let file = export(&doc, &opts(PsdOptions::default())); let p = parse(&file); assert_eq!((p.channels, p.mode), (4, 3), "RGB with the merged image's transparency"); assert_eq!(p.count, -2, "two layers; negative: the merged alpha is its transparency"); let names: Vec<&str> = p.records.iter().map(|r| r.name.as_str()).collect(); assert_eq!(names, ["Layer 1", "Top"], "bottom first"); let red = &p.records[0]; assert_eq!(red.rect, [10, 10, 40, 40], "cropped to what the layer paints"); assert_eq!((red.channels, red.blend, red.opacity, red.hidden, red.divider), (4, *b"norm", 255, false, None)); assert_eq!(p.records[1].rect, [0, 0, 50, 60], "the blue square and the corner"); // A reader decodes it: the layers, in place, and the merged image. let psd = craft_psd::PsdFile::from_bytes(&file).unwrap(); assert_eq!((psd.header.width, psd.header.height, psd.layers().len()), (100, 60, 2)); let layer = psd.iter_layers().find(|l| l.name() == "Layer 1").unwrap(); assert_eq!(layer.record.rect, craft_psd::layer::Rect { top: 10, left: 10, bottom: 40, right: 40 }); let red = layer.rgba8().unwrap().data; assert_eq!(pixel(&red, 30, 10, 10), [255, 0, 0, 255]); // The merged image is the flat render: colours on white where transparent, alpha apart. let img = Renderer::new().render_region_with(&doc, doc.artboards[0].rect, 1.0, &opts(PsdOptions::default()).render_options(RasterFormat::Psd)); let want: Vec = img.to_straight().as_chunks::<4>().0.iter().flat_map(|p| [on_white(p), [p[3]; 3]].concat()[..4].to_vec()).collect(); assert_eq!(merged(&file), want); let mixed = pixel(&want, 100, 35, 30); assert!(mixed[0].abs_diff(128) <= 1 && mixed[1] == 0 && mixed[2] == 0, "red under half-opaque blue multiply: {mixed:?}"); assert_eq!(pixel(&want, 100, 5, 50), [255, 255, 255, 0]); } #[test] fn flat_writes_the_merged_image_alone_on_white() { let doc = doc(); let o = opts(PsdOptions { layers: false, ..PsdOptions::default() }); let file = export(&doc, &o); let p = parse(&file); assert_eq!((p.channels, p.mode, p.count), (3, 3, 0)); assert!(p.records.is_empty()); // The resolution resource: 72 ppi in 16.16 fixed point. assert_eq!(&p.resources[..6], b"8BIM\x03\xed"); assert_eq!(u32_at(p.resources, 12), 72 << 16); let img = Renderer::new().render_region_with(&doc, doc.artboards[0].rect, 1.0, &o.render_options(RasterFormat::Psd)); assert_eq!(merged(&file), img.to_straight(), "the composite is the flat render"); // The same flat file from a rendered image. assert_eq!(o.encode(&img, RasterFormat::Psd).unwrap(), file); let file = export(&doc, &RasterExportOptions { ppi: 150.0, ..o }); assert_eq!(u32_at(parse(&file).resources, 12), 150 << 16); assert_eq!(craft_psd::PsdFile::from_bytes(&file).unwrap().header.width, 208); } #[test] fn maximum_editability_writes_groups_and_an_object_per_layer() { let doc = doc(); let o = opts(PsdOptions { max_editability: true, ..PsdOptions::default() }); let file = export(&doc, &o); let p = parse(&file); let rows: Vec<(&str, Option)> = p.records.iter().map(|r| (r.name.as_str(), r.divider)).collect(); let rect = doc.layers[0].children().unwrap()[0].display_name(); assert_eq!( rows, [ ("", Some(3)), (rect.as_str(), None), ("Layer 1", Some(1)), ("", Some(3)), (rect.as_str(), None), ("", Some(3)), ("Corner", None), ("Inner", Some(1)), ("Top", Some(1)), ], "groups end below their layers and open above them; the hidden square is left out" ); // The object keeps its opacity and blending in its record; groups pass through. assert_eq!((p.records[4].opacity, p.records[4].blend, p.records[4].rect), (128, *b"mul ", [20, 30, 50, 60])); assert_eq!((p.records[8].blend, p.records[8].opacity), (*b"pass", 255)); assert_eq!(p.records[6].rect, [0, 0, 6, 6]); let psd = craft_psd::PsdFile::from_bytes(&file).unwrap(); let content_layers = psd.layers().iter().filter(|l| matches!(l.section_type(), craft_psd::SectionType::Other)).count(); let groups = psd.layers().iter().filter(|l| matches!(l.section_type(), craft_psd::SectionType::OpenFolder | craft_psd::SectionType::ClosedFolder)).count(); assert_eq!((content_layers, groups), (3, 3)); assert_eq!(merged(&file), merged(&export(&doc, &opts(PsdOptions::default()))), "the same merged image"); // Hidden layers: written hidden, drawn as if visible, instead of left out. let o = opts(PsdOptions { max_editability: true, hidden_layers: true, ..PsdOptions::default() }); let file = export(&doc, &o); let p = parse(&file); let hidden: Vec<&Rec> = p.records.iter().filter(|r| r.hidden).collect(); assert_eq!(hidden.len(), 1); assert_eq!(hidden[0].rect, [5, 70, 25, 90]); } #[test] fn hidden_top_level_layers_are_optional() { let mut doc = doc(); Arc::make_mut(&mut doc.layers[1]).visible = false; let names = |o: PsdOptions| parse(&export(&doc, &opts(o))).records.iter().map(|r| (r.name.clone(), r.hidden)).collect::>(); assert_eq!(names(PsdOptions::default()), [("Layer 1".to_string(), false)]); assert_eq!(names(PsdOptions { hidden_layers: true, ..PsdOptions::default() }), [("Layer 1".to_string(), false), ("Top".to_string(), true)]); // Nothing left to write as a layer: no transparency plane either (it would read as a channel). Arc::make_mut(&mut doc.layers[0]).visible = false; let file = export(&doc, &opts(PsdOptions::default())); let p = parse(&file); assert_eq!((p.channels, p.count), (3, 0)); } #[test] fn guides_are_not_layers() { let mut b = DocBuilder::new(20.0, 20.0); b.rect(Rect::new(0.0, 0.0, 5.0, 5.0), Color::rgb8(0, 0, 0), |_| {}); b.rect(Rect::new(0.0, 10.0, 20.0, 10.0), Color::rgb8(0, 0, 0), |n: &mut Node| { if let vectorcraft_doc::NodeKind::Path { guide, .. } = &mut n.kind { *guide = true; } }); let o = opts(PsdOptions { max_editability: true, ..PsdOptions::default() }); assert_eq!(parse(&export(&b.build(), &o)).count, -3, "the group and the square"); } /// Ruler guides on a layer and a sublayer change nothing in the export: the same file with and /// without Maximum Editability, the same drawn bounds and the same cached size of each layer. #[test] fn ruler_guides_are_not_exported() { use vectorcraft_doc::{NodeId, NodeKind}; let plain = doc(); let mut guided = plain.clone(); let guide = |id, vertical, pos| Node::new(NodeId(id), NodeKind::RulerGuide { vertical, pos, artboard: None }); let (bottom, inner) = (guided.layers[0].id, guided.layers[1].children().unwrap().last().unwrap().id); guided.insert(Some(bottom), usize::MAX, guide(900, true, 20.0)).unwrap(); guided.insert(Some(bottom), usize::MAX, guide(901, false, 15.0)).unwrap(); guided.insert(Some(inner), usize::MAX, guide(902, true, 3.0)).unwrap(); for psd in [PsdOptions::default(), PsdOptions { max_editability: true, ..PsdOptions::default() }] { assert_eq!(export(&guided, &opts(psd.clone())), export(&plain, &opts(psd))); } assert_eq!(art_bounds(&guided), art_bounds(&plain)); for (g, p) in guided.layers.iter().zip(&plain.layers) { assert_eq!(crate::drawn_bounds(&guided, g), crate::drawn_bounds(&plain, p)); assert_eq!(crate::lru::node_bytes(g), crate::lru::node_bytes(p)); } } #[test] fn a_background_colour_is_the_bottom_layer() { let doc = doc(); let file = export(&doc, &RasterExportOptions { background: Some([0, 0, 255]), ..opts(PsdOptions::default()) }); let p = parse(&file); assert_eq!((p.channels, p.count), (3, 3), "opaque: no merged alpha"); assert_eq!((p.records[0].name.as_str(), p.records[0].rect), ("Background", [0, 0, 60, 100])); let psd = craft_psd::PsdFile::from_bytes(&file).unwrap(); assert!(psd.iter_layers().find(|l| l.name() == "Background").unwrap().rgba8().unwrap().data.chunks(4).all(|p| p == [0, 0, 255, 255])); assert_eq!(pixel(&merged(&file), 100, 5, 50), [0, 0, 255, 255]); } #[test] fn cmyk_planes_hold_the_inks_inverted_and_gray_is_one_plane() { let doc = doc(); let cmyk = export(&doc, &opts(PsdOptions { color_model: ColorModel::Cmyk, ..PsdOptions::default() })); let p = parse(&cmyk); assert_eq!((p.channels, p.mode, p.count, p.records[0].channels), (5, 4, -2, 5)); let gray = export(&doc, &opts(PsdOptions { color_model: ColorModel::Gray, layers: false, ..PsdOptions::default() })); let p = parse(&gray); assert_eq!((p.channels, p.mode), (1, 1)); let px = merged(&gray); assert_eq!(pixel(&px, 100, 5, 50), [255, 255, 255, 255], "white paper"); assert!((100..160).contains(&px[(20 * 100 + 20) * 4]), "red is a middle grey"); // A CMYK black is black ink alone; no ink is 255. let mut b = DocBuilder::new(10.0, 10.0); b.rect(Rect::new(0.0, 0.0, 5.0, 10.0), Color::cmyk(0.0, 0.0, 0.0, 1.0), |_| {}); let doc = b.build(); let file = export(&doc, &opts(PsdOptions { color_model: ColorModel::Cmyk, layers: false, ..PsdOptions::default() })); let planes = merged_planes(&file, 4, 10, 10); assert_eq!(planes.iter().map(|p| p[0]).collect::>(), [255, 255, 255, 0], "black ink"); assert_eq!(planes.iter().map(|p| p[9]).collect::>(), [255; 4], "no ink"); // Layered: the layer's inks are the same under its alpha. let file = export(&doc, &opts(PsdOptions { color_model: ColorModel::Cmyk, ..PsdOptions::default() })); assert_eq!(merged_planes(&file, 5, 10, 10)[3][0], 0); } #[test] fn the_profile_and_the_size_limit() { let doc = doc(); let file = export(&doc, &RasterExportOptions::default()); let resources = parse(&file).resources; let icc = resources.windows(6).position(|w| w == b"8BIM\x04\x0f").expect("the profile resource"); assert!(u32_at(resources, icc + 8) > 100); let o = RasterExportOptions { ppi: 72.0 * 301.0, ..RasterExportOptions::default() }; let err = Renderer::new().export_region(&doc, doc.artboards[0].rect, RasterFormat::Psd, &o).unwrap_err(); assert!(err.contains(&MAX_SIDE.to_string()), "{err}"); } /// A descriptor value as the format's specification lays it out. #[derive(Debug, PartialEq)] enum Item { Text(String), Enum(String, String), Long(i32), Doub(f64), Unit(String, f64), Object(String, Vec<(String, Item)>), Raw(Vec), } /// Reads an id (a four-character code after a zero length, else a length and its bytes) at `at`. fn read_id(d: &[u8], at: &mut usize) -> String { let n = u32_at(d, *at); let len = if n == 0 { 4 } else { n }; let s = String::from_utf8(d[*at + 4..*at + 4 + len].to_vec()).unwrap(); *at += 4 + len; s } fn read_unicode(d: &[u8], at: &mut usize) -> String { let n = u32_at(d, *at); let units: Vec = (0..n).map(|i| u16_at(d, *at + 4 + i * 2)).collect(); *at += 4 + n * 2; String::from_utf16(&units).unwrap().trim_end_matches('\0').to_string() } /// Reads a descriptor at `at`: its class and items. fn read_descriptor(d: &[u8], at: &mut usize) -> (String, Vec<(String, Item)>) { read_unicode(d, at); let class = read_id(d, at); let count = u32_at(d, *at); *at += 4; let mut items = vec![]; for _ in 0..count { let key = read_id(d, at); let ty = d[*at..*at + 4].to_vec(); *at += 4; let f64_at = |at: usize| f64::from_be_bytes(d[at..at + 8].try_into().unwrap()); let v = match &ty[..] { b"TEXT" => Item::Text(read_unicode(d, at)), b"enum" => Item::Enum(read_id(d, at), read_id(d, at)), b"long" => { *at += 4; Item::Long(u32_at(d, *at - 4) as i32) } b"doub" => { *at += 8; Item::Doub(f64_at(*at - 8)) } b"UntF" => { let unit = String::from_utf8(d[*at..*at + 4].to_vec()).unwrap(); *at += 12; Item::Unit(unit, f64_at(*at - 8)) } b"Objc" => { let (class, items) = read_descriptor(d, at); Item::Object(class, items) } b"tdta" => { let n = u32_at(d, *at); *at += 4 + n; Item::Raw(d[*at - n..*at].to_vec()) } other => panic!("unexpected item type {other:?}"), }; items.push((key, v)); } (class, items) } /// A type tool object: its transform, its text descriptor and its warp descriptor. struct TypeTool { transform: [f64; 6], text: Vec<(String, Item)>, warp: (String, Vec<(String, Item)>), } fn type_tool(d: &[u8]) -> TypeTool { assert_eq!(u16_at(d, 0), 1, "version"); let transform = std::array::from_fn(|i| f64::from_be_bytes(d[2 + i * 8..10 + i * 8].try_into().unwrap())); assert_eq!((u16_at(d, 50), u32_at(d, 52)), (50, 16), "text and descriptor versions"); let mut at = 56; let (class, text) = read_descriptor(d, &mut at); assert_eq!(class, "TxLr"); assert_eq!((u16_at(d, at), u32_at(d, at + 2)), (1, 16), "warp and descriptor versions"); at += 6; let warp = read_descriptor(d, &mut at); assert_eq!(d.len(), (at + 16).next_multiple_of(2), "the four warped bounds end the block (padded to an even length)"); TypeTool { transform, text, warp } } fn item<'a>(items: &'a [(String, Item)], key: &str) -> &'a Item { &items.iter().find(|(k, _)| k == key).unwrap_or_else(|| panic!("no {key}")).1 } /// `s` as the text engine stores a string: UTF-16BE after a byte order mark. fn engine_string(s: &str) -> Vec { [0xFE, 0xFF].into_iter().chain(s.encode_utf16().flat_map(u16::to_be_bytes)).collect() } fn type_node(b: &mut DocBuilder, origin: (f64, f64), text: &str, f: impl FnOnce(&mut vectorcraft_doc::TextObject)) -> Node { use vectorcraft_doc::{CharStyle, NodeKind, TextObject}; let style = CharStyle { size: 12.0, fill: vectorcraft_color::Paint::solid(Color::rgb8(0, 0, 0)), ..CharStyle::default() }; let mut t = TextObject::point(vectorcraft_geom::Point::new(origin.0, origin.1), text, style); f(&mut t); Node::new(b.alloc(), NodeKind::Text(Box::new(t))) } /// Layer 1: a red square, point type, a blue square. fn type_doc() -> Document { let mut b = DocBuilder::new(100.0, 60.0); b.rect(Rect::new(0.0, 0.0, 30.0, 30.0), Color::rgb8(255, 0, 0), |_| {}); let t = type_node(&mut b, (20.0, 40.0), "Hi\nyou", |_| {}); b.add(t); b.rect(Rect::new(60.0, 10.0, 90.0, 40.0), Color::rgb8(0, 0, 255), |_| {}); b.build() } #[test] fn preserve_text_writes_point_type_as_a_type_layer_between_pixel_layers() { let doc = type_doc(); let o = RasterExportOptions { ppi: 144.0, ..opts(PsdOptions { preserve_text: true, ..PsdOptions::default() }) }; let file = export(&doc, &o); let p = parse(&file); let rows: Vec<(&str, Option, bool)> = p.records.iter().map(|r| (r.name.as_str(), r.divider, r.type_tool.is_some())).collect(); assert_eq!( rows, [ ("", Some(3), false), ("Layer 1", None, false), ("Hi\nyou", None, true), ("Layer 1", None, false), ("Layer 1", Some(1), false), ], "the layer becomes a group: the art below the type, the type layer, the art above it" ); assert_eq!(p.records[1].rect, [0, 0, 60, 60], "the red square alone, at 2 pixels a point"); assert_eq!(p.records[3].rect, [20, 120, 80, 180], "the blue square alone"); assert_ne!(p.records[2].rect, [0; 4], "the type layer keeps its pixels"); let t = type_tool(p.records[2].type_tool.as_deref().unwrap()); assert_eq!(t.transform, [1.0, 0.0, 0.0, 1.0, 40.0, 80.0], "the first baseline's start, in pixels"); assert_eq!(item(&t.text, "Txt "), &Item::Text("Hi\ryou".into())); assert_eq!(item(&t.text, "Ornt"), &Item::Enum("Ornt".into(), "Hrzn".into())); let Item::Object(_, bounds) = item(&t.text, "bounds") else { panic!("bounds") }; let [l, top, r, bottom] = ["Left", "Top ", "Rght", "Btom"].map(|k| match item(bounds, k) { Item::Unit(_, v) => *v, other => panic!("{other:?}"), }); assert!(l < 4.0 && top < 0.0 && r > l && bottom > 24.0, "the ink around the baselines: {l} {top} {r} {bottom}"); assert_eq!(t.warp.0, "warp"); assert_eq!(item(&t.warp.1, "warpStyle"), &Item::Enum("warpStyle".into(), "warpNone".into())); let Item::Raw(engine) = item(&t.text, "EngineData") else { panic!("EngineData") }; let has = |needle: &[u8]| engine.windows(needle.len()).any(|w| w == needle); assert!(has(&engine_string("Hi\ryou\r")), "the text ends with a paragraph break"); assert!(has(b"/FontSize 24.0"), "the size in pixels at 144 ppi"); assert!(has(b"/RunLengthArray [ 3 4 ]"), "a paragraph run per paragraph, breaks counted"); assert!(has(b"/RunLengthArray [ 7 ]"), "one style run over the text and the closing break"); assert!(has(b"/Values [ 1.0 0.0 0.0 0.0 ]"), "black"); assert!(has(b"/ShapeType 0"), "point type"); assert!(has(b"/UseFractionalGlyphWidths true"), "Fractional Widths on"); // A reader takes the file, and the merged image is the same render. assert_eq!(craft_psd::PsdFile::from_bytes(&file).unwrap().layers().len(), p.records.len()); let plain = export(&doc, &RasterExportOptions { ppi: 144.0, ..opts(PsdOptions::default()) }); assert_eq!(merged(&file), merged(&plain)); assert_eq!(parse(&plain).records.iter().filter(|r| r.type_tool.is_some()).count(), 0, "off: no type layers"); } #[test] fn type_a_type_layer_cant_draw_stays_pixels() { use vectorcraft_doc::{NodeKind, TextKind}; use vectorcraft_geom::PathData; let mut b = DocBuilder::new(100.0, 60.0); let area = type_node(&mut b, (10.0, 20.0), "Area", |t| { t.kind = TextKind::Area { frame: PathData::from_bezpath(&vectorcraft_geom::Shape::to_path(&Rect::new(5.0, 5.0, 60.0, 50.0), 0.1)) }; }); b.add(area); let stroked = type_node(&mut b, (10.0, 50.0), "Stroked", |t| { t.runs[0].style.stroke = vectorcraft_color::Paint::solid(Color::rgb8(255, 0, 0)); t.runs[0].style.stroke_width = 1.0; }); b.add(stroked); let kerned = type_node(&mut b, (40.0, 50.0), "Kerned", |t| t.runs[0].style.kerning = Some(50.0)); b.add(kerned); let indented = type_node(&mut b, (70.0, 50.0), "Indented", |t| t.para.first_line_indent = 4.0); b.add(indented); let listed = type_node(&mut b, (10.0, 35.0), "Listed", |t| t.para.list = Some(vectorcraft_doc::text::ParaList::default())); b.add(listed); let system = type_node(&mut b, (40.0, 35.0), "System", |t| t.system_layout = true); b.add(system); let hanging = type_node(&mut b, (70.0, 35.0), "\"Hung\"", |t| t.optical_margin = true); b.add(hanging); let tabbed = type_node(&mut b, (10.0, 10.0), "a\tb", |t| { t.para.tabs = vec![vectorcraft_doc::TabStop { position: 30.0, align: Default::default(), leader: String::new(), align_on: '.' }]; }); b.add(tabbed); let leading = type_node(&mut b, (40.0, 10.0), "Auto", |t| t.para.justification.auto_leading = 150.0); b.add(leading); let standard = type_node(&mut b, (40.0, 20.0), "Std", |t| t.para.composer = vectorcraft_doc::Composer::StandardEveryLine); b.add(standard); // Hebrew: right to left from its first strong character, so Auto alignment is right. In an // installed font that covers it when there is one; otherwise its font lacks it. let hebrew_face = vectorcraft_text::FontDb::global().face_covering('ש'); let hebrew = type_node(&mut b, (70.0, 10.0), "שלום", |t| { if let Some(f) = &hebrew_face { (t.runs[0].style.font_family, t.runs[0].style.font_style) = (f.family.clone(), f.style.clone()); } }); b.add(hebrew); let tracked = type_node(&mut b, (10.0, 58.0), "Tracked", |t| t.runs[0].style.tracking = 0.5); b.add(tracked); let british = type_node(&mut b, (70.0, 58.0), "Colour", |t| t.runs[0].style.language = Some("en-GB".into())); b.add(british); // Drawn partly with a fallback font: the bundled fonts have no 縦. let fallback = type_node(&mut b, (40.0, 58.0), "A縦", |_| {}); b.add(fallback); let mut doc = b.build(); let with = |o: PsdOptions| export(&doc, &opts(o)); assert_eq!(with(PsdOptions { preserve_text: true, ..PsdOptions::default() }), with(PsdOptions::default()), "one pixel layer either way"); // An empty point type object has no text to edit. let empty = Node::new( doc.alloc_id(), NodeKind::Text(Box::new(vectorcraft_doc::TextObject::point(vectorcraft_geom::Point::ZERO, "", Default::default()))), ); doc.insert(Some(doc.layers[0].id), usize::MAX, empty).unwrap(); let file = export(&doc, &opts(PsdOptions { preserve_text: true, ..PsdOptions::default() })); assert!(parse(&file).records.iter().all(|r| r.type_tool.is_none())); } #[test] fn vertical_type_and_maximum_editability() { let mut b = DocBuilder::new(100.0, 60.0); b.rect(Rect::new(0.0, 0.0, 10.0, 10.0), Color::rgb8(255, 0, 0), |_| {}); let t = type_node(&mut b, (50.0, 10.0), "Up", |t| t.vertical = true); b.add(t); let hidden = type_node(&mut b, (10.0, 50.0), "Hidden", |_| {}); b.add(Node { visible: false, ..hidden }); let doc = b.build(); let o = opts(PsdOptions { preserve_text: true, max_editability: true, hidden_layers: true, ..PsdOptions::default() }); let file = export(&doc, &o); let p = parse(&file); let rows: Vec<(&str, bool, bool)> = p.records.iter().map(|r| (r.name.as_str(), r.type_tool.is_some(), r.hidden)).collect(); let square = doc.layers[0].children().unwrap()[0].display_name(); assert_eq!( rows, [("", false, false), (square.as_str(), false, false), ("Up", true, false), ("Hidden", true, true), ("Layer 1", false, false)], "each object a layer of its own; hidden type is a hidden type layer" ); let t = type_tool(p.records[2].type_tool.as_deref().unwrap()); assert_eq!(item(&t.text, "Ornt"), &Item::Enum("Ornt".into(), "Vrtc".into())); let Item::Raw(engine) = item(&t.text, "EngineData") else { panic!("EngineData") }; assert!(engine.windows(19).any(|w| w == b"/WritingDirection 2"), "vertical writing"); } #[test] fn type_layer_keeps_fractional_widths_off() { let mut b = DocBuilder::new(100.0, 60.0); let t = type_node(&mut b, (10.0, 30.0), "Whole", |t| t.fractional_widths = false); b.add(t); let file = export(&b.build(), &opts(PsdOptions { preserve_text: true, ..PsdOptions::default() })); let p = parse(&file); let record = p.records.iter().find(|r| r.type_tool.is_some()).expect("a type layer"); let t = type_tool(record.type_tool.as_deref().unwrap()); let Item::Raw(engine) = item(&t.text, "EngineData") else { panic!("EngineData") }; let needle = b"/UseFractionalGlyphWidths false"; assert!(engine.windows(needle.len()).any(|w| w == needle), "whole-point advances, as the pixels are drawn"); } #[test] fn type_layer_keeps_the_anti_aliasing_method() { use vectorcraft_doc::text::TypeAntiAlias; let engine_anti_alias = |doc: &Document, o: &RasterExportOptions| { let file = export(doc, o); let p = parse(&file); let t = type_tool(p.records.iter().find_map(|r| r.type_tool.as_deref()).expect("a type layer")); let Item::Raw(engine) = item(&t.text, "EngineData") else { panic!("EngineData") }; let at = engine.windows(11).position(|w| w == b"/AntiAlias ").expect("AntiAlias"); let Item::Enum(_, method) = item(&t.text, "AntA") else { panic!("AntA") }; (method.clone(), engine[at + 11]) }; let o = opts(PsdOptions { preserve_text: true, ..PsdOptions::default() }); for (aa, key, number) in [ (TypeAntiAlias::None, "Anno", b'0'), (TypeAntiAlias::Sharp, "AnSh", b'4'), (TypeAntiAlias::Crisp, "AnCr", b'1'), (TypeAntiAlias::Strong, "AnSt", b'2'), ] { let mut b = DocBuilder::new(100.0, 60.0); let t = type_node(&mut b, (10.0, 30.0), "Edges", |t| t.anti_alias = aa); b.add(t); let doc = b.build(); assert_eq!(engine_anti_alias(&doc, &o), (key.to_string(), number), "{aa:?}"); let hard = RasterExportOptions { anti_alias: crate::AntiAlias::None, ..o.clone() }; assert_eq!(engine_anti_alias(&doc, &hard), ("Anno".to_string(), b'0'), "{aa:?} exported without anti-aliasing"); } } #[test] fn variation_selectors_and_joiners_need_no_glyph() { let mut b = DocBuilder::new(100.0, 60.0); // In English: USA, the default language, given by its tag. let t = type_node(&mut b, (10.0, 30.0), "A\u{FE0F}\u{200D}B\u{E0100}", |t| t.runs[0].style.language = Some("en-US".into())); b.add(t); let file = export(&b.build(), &opts(PsdOptions { preserve_text: true, ..PsdOptions::default() })); assert_eq!(parse(&file).records.iter().filter(|r| r.type_tool.is_some()).count(), 1); } #[test] fn hidden_type_left_out_keeps_its_layer_whole() { let mut b = DocBuilder::new(100.0, 60.0); b.rect(Rect::new(0.0, 0.0, 30.0, 30.0), Color::rgb8(255, 0, 0), |_| {}); let t = type_node(&mut b, (20.0, 40.0), "Hidden", |_| {}); b.add(Node { visible: false, ..t }); b.rect(Rect::new(60.0, 10.0, 90.0, 40.0), Color::rgb8(0, 0, 255), |_| {}); let doc = b.build(); let with = |o: PsdOptions| export(&doc, &opts(o)); assert_eq!(with(PsdOptions { preserve_text: true, ..PsdOptions::default() }), with(PsdOptions::default()), "one pixel layer either way"); let shown = parse(&with(PsdOptions { preserve_text: true, hidden_layers: true, ..PsdOptions::default() })) .records .iter() .filter(|r| r.type_tool.is_some() && r.hidden) .count(); assert_eq!(shown, 1, "with hidden layers: a hidden type layer"); } #[test] fn blending_art_keeps_its_layer_whole() { use vectorcraft_color::BlendMode; use vectorcraft_doc::AppearanceItem; // The square's blend mode, on the object (`fill`: false) or on its fill. let build = |blend: BlendMode, above: bool, fill: bool| { let mut b = DocBuilder::new(100.0, 60.0); let square = |b: &mut DocBuilder| { b.rect(Rect::new(0.0, 0.0, 60.0, 40.0), Color::rgb8(255, 0, 0), |n| { if !fill { n.blend = blend; } else if let Some(AppearanceItem::Fill(f)) = n.appearance.items.first_mut() { f.blend = blend; } }); }; if !above { square(&mut b); } let t = type_node(&mut b, (10.0, 30.0), "Type", |_| {}); b.add(t); if above { square(&mut b); } b.build() }; let o = opts(PsdOptions { preserve_text: true, ..PsdOptions::default() }); for (above, fill) in [(true, false), (false, false), (true, true)] { let normal = export(&build(BlendMode::Normal, above, fill), &o); assert_eq!(parse(&normal).records.iter().filter(|r| r.type_tool.is_some()).count(), 1, "normal art (above: {above}): a type layer"); let doc = build(BlendMode::Multiply, above, fill); let file = export(&doc, &o); assert!(parse(&file).records.iter().all(|r| r.type_tool.is_none()), "multiplied art (above: {above}, fill: {fill}): one pixel layer"); assert_eq!(file, export(&doc, &opts(PsdOptions::default()))); } } #[test] fn long_unicode_name_is_cut_on_a_character_boundary() { let mut b = DocBuilder::new(100.0, 60.0); b.layer(&("a".repeat(254) + "😀")); b.rect(Rect::new(0.0, 0.0, 5.0, 5.0), Color::rgb8(0, 0, 0), |_| {}); let file = export(&b.build(), &opts(PsdOptions::default())); assert_eq!(parse(&file).records.last().unwrap().name, "a".repeat(254)); } /// `doc()` with a user slice over (20, 5)–(50, 15) and the red square made an object slice. fn sliced() -> Document { let mut d = doc(); let red = d.layers[0].children().unwrap()[0].id; let user = SliceOptions { name: "banner".into(), url: "https://example.com/".into(), target: "_blank".into(), message: "Go".into(), alt: "Banner".into(), background: "#123456".into(), ..SliceOptions::default() }; let id = d.alloc_id(); d.slices.push(Slice { id, rect: Rect::new(20.0, 5.0, 50.0, 15.0), options: user }); let cell = SliceOptions { kind: SliceKind::NoImage, text: "Hi".into(), background: "matte".into(), ..SliceOptions::default() }; d.node_mut(red).unwrap().extras_mut().slice = Some(Box::new(cell)); d } /// The slices resource of `file` as an independent reader reads it. fn slices_of(file: &[u8]) -> Option { let psd = craft_psd::PsdFile::from_bytes(file).expect("a PSD a reader takes"); psd.resource(1050).map(|r| craft_psd::slices::SlicesResource::from_bytes(&r.data).expect("a slices resource a reader takes")) } #[test] fn slices_are_written_with_or_without_layers() { let d = sliced(); for layers in [true, false] { let file = export(&d, &opts(PsdOptions { layers, ..PsdOptions::default() })); let res = slices_of(&file).expect("the slices resource"); assert_eq!((res.version, res.bounds, res.group_name.as_str()), (6, [5, 10, 40, 50], "Untitled-1")); let s = &res.slices; assert_eq!(s.len(), 2, "{s:?}"); // Laid out top to bottom: the user slice, then the object slice, both written as made by // the user. let user = &s[0]; assert_eq!((user.id, user.origin, user.layer_id, user.kind, user.rect), (1, 2, None, 1, [20, 5, 50, 15])); assert_eq!( (user.name.as_str(), user.url.as_str(), user.target.as_str(), user.message.as_str(), user.alt.as_str()), ("banner", "https://example.com/", "_blank", "Go", "Banner") ); assert_eq!(user.color, [255, 0x12, 0x34, 0x56]); let cell = &s[1]; assert_eq!((cell.id, cell.origin, cell.kind, cell.rect), (2, 2, 0, [10, 10, 40, 40])); assert_eq!((cell.name.as_str(), cell.cell_text.as_str(), cell.cell_text_is_html), ("", "Hi", true)); assert_eq!((cell.color[0], cell.color[1..].iter().any(|c| *c != 0)), (0, true), "the matte"); assert_eq!((cell.horizontal_align, cell.vertical_align), (0, 0)); } // A document without slices has no slices resource. assert!(slices_of(&export(&doc(), &opts(PsdOptions::default()))).is_none()); } #[test] fn slices_are_cut_to_the_exported_region_in_its_pixels() { let doc = sliced(); // The right part at 2 px a point: the user slice is cut at the region's left edge, and the red // square's slice ends at that edge. let o = RasterExportOptions { ppi: 144.0, ..opts(PsdOptions::default()) }; let file = Renderer::new().export_region(&doc, Rect::new(40.0, 0.0, 100.0, 60.0), RasterFormat::Psd, &o).unwrap(); let res = slices_of(&file).unwrap(); assert_eq!(res.slices.iter().map(|s| s.rect).collect::>(), [[0, 10, 20, 30]]); assert_eq!(res.bounds, [10, 0, 30, 20]); // A region no slice reaches has none. let file = Renderer::new().export_region(&doc, Rect::new(60.0, 30.0, 100.0, 60.0), RasterFormat::Psd, &o).unwrap(); assert!(slices_of(&file).is_none()); // A slice thinner than a pixel keeps one pixel. let mut thin = doc.clone(); thin.slices[0].rect = Rect::new(20.0, 5.0, 20.2, 15.0); let res = slices_of(&export(&thin, &opts(PsdOptions::default()))).unwrap(); assert_eq!(res.slices[0].rect, [20, 5, 21, 15]); // The overlap is found before the region is rounded to whole pixels: a slice inside a region // that ends at 10.4 keeps its last pixel, and one past a region that ends at 10.6 isn't written. let o = opts(PsdOptions::default()); let mut edge = doc.clone(); edge.slices[0].rect = Rect::new(10.1, 5.0, 10.3, 15.0); edge.node_mut(edge.layers[0].children().unwrap()[0].id).unwrap().extras_mut().slice = None; let file = Renderer::new().export_region(&edge, Rect::new(0.0, 0.0, 10.4, 60.0), RasterFormat::Psd, &o).unwrap(); assert_eq!(slices_of(&file).unwrap().slices.iter().map(|s| s.rect).collect::>(), [[9, 5, 10, 15]]); edge.slices[0].rect = Rect::new(10.7, 5.0, 10.9, 15.0); let file = Renderer::new().export_region(&edge, Rect::new(0.0, 0.0, 10.6, 60.0), RasterFormat::Psd, &o).unwrap(); assert!(slices_of(&file).is_none()); } #[test] fn an_html_text_slice_writes_one_break_for_each_line_ending() { use vectorcraft_doc::{CharStyle, NodeKind, TextObject}; use vectorcraft_geom::Point; let mut d = DocBuilder::new(100.0, 60.0).build(); let t = TextObject::point(Point::new(10.0, 30.0), "A\r\nB\rC\nD\u{2029}E", CharStyle { size: 12.0, ..CharStyle::default() }); let mut n = Node::new(d.alloc_id(), NodeKind::Text(Box::new(t))); n.extras_mut().slice = Some(Box::new(SliceOptions { kind: SliceKind::HtmlText, ..SliceOptions::default() })); let l = d.layers[0].id; d.insert(Some(l), 0, n).unwrap(); let res = slices_of(&export(&d, &opts(PsdOptions::default()))).unwrap(); assert_eq!(res.slices[0].cell_text, "A
B
C
D
E"); } #[test] fn slice_ids_count_from_1_and_the_limits_are_errors() { let mut doc = doc(); for i in 0..20 { let id = doc.alloc_id(); let x = f64::from(i) * 5.0; doc.slices.push(Slice { id, rect: Rect::new(x, 0.0, x + 5.0, 5.0), options: SliceOptions::default() }); } let res = slices_of(&export(&doc, &opts(PsdOptions::default()))).unwrap(); let ids: Vec = res.slices.iter().map(|s| s.id).collect(); assert_eq!(ids, (1..=20).collect::>()); let export_err = |d: &Document| { Renderer::new().export_region(d, d.artboards[0].rect, RasterFormat::Psd, &opts(PsdOptions::default())).err().unwrap_or_default() }; let mut long = doc.clone(); long.slices[0].options.alt = "a".repeat(MAX_SLICE_TEXT + 1); let e = export_err(&long); assert!(e.contains("characters"), "{e}"); let mut many = doc.clone(); many.slices = (0..=MAX_SLICES as u64) .map(|i| Slice { id: NodeId(1_000_000 + i), rect: Rect::new(0.0, 0.0, 5.0, 5.0), options: SliceOptions::default() }) .collect(); let e = export_err(&many); assert!(e.contains("slices"), "{e}"); // Not clipped to the artboard, a slice keeps bounds that aren't finite. let mut bad = doc; bad.slices_clip_to_artboard = false; bad.slices[0].rect = Rect::new(f64::NAN, 0.0, 5.0, 5.0); let e = export_err(&bad); assert!(e.contains("finite"), "{e}"); } #[test] fn slices_past_4_gb_are_an_error_before_they_are_written() { let max = u32::MAX as usize; assert_eq!(room(0, MAX_SLICE_TEXT), Ok(())); assert_eq!(room(max - 4 - 2 * 10, 10), Ok(())); let e = room(max - 4 - 2 * 10, 11).err().unwrap_or_default(); assert!(e.contains("4 GB"), "{e}"); assert!(room(max, 0).is_err()); assert!(room(0, usize::MAX).is_err()); }