Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

18.2 KB
Raw Blame
//! A page's content written from the document: layers as optional content,
//! groups (transparency groups as forms), unedited objects as the file drew
//! them, and edited ones from the model.

use super::objects::Objects;
use super::paint::{alpha_mask_ops, alpha_ops, cm, has_alpha, paint_ops, stroke_ops};
use super::resources::{Resources, rename};
use super::text::{self, InvisibleFont};
use crate::build::node_bounds;
use crate::file::SourceFile;
use crate::geom::{Affine, PathData, Rect, Seg};
use crate::marks::{self, GroupMark};
use crate::model::{
    BlendMode, Document, ImageNode, ImageSource, Node, NodeIdx, NodeKind, PathNode, Source, flags,
};
use crate::pdf::content::Op;
use crate::pdf::{Dict, ObjRef, Object, Stream};
use std::collections::{HashMap, HashSet};

/// Where operators go: a content stream and its resources.
struct Target {
    ops: Vec<Op>,
    res: Resources,
}

/// What every page shares.
pub struct Shared<'a> {
    /// The document.
    pub doc: &'a Document,
    /// The objects being written.
    pub objects: &'a mut Objects,
    /// Each layer's optional content group.
    pub layers: &'a HashMap<NodeIdx, ObjRef>,
    /// The group hidden objects go in.
    pub hidden: Option<ObjRef>,
    /// The font invisible copies of edited text use.
    pub invisible: &'a mut InvisibleFont,
    /// Added images, written once each.
    pub images: &'a mut HashMap<String, ObjRef>,
}

/// Writes one page.
pub struct PageWriter<'a, 'b> {
    shared: &'b mut Shared<'a>,
    /// Canvas to page space.
    c2p: Affine,
    /// Nodes with content on this page.
    on_page: &'b HashSet<NodeIdx>,
    targets: Vec<Target>,
}

fn op(name: &str, operands: Vec<Object>) -> Op {
    Op::new(name, operands)
}

fn num(v: f64) -> Object {
    Object::number(v)
}

/// A path's construction operators.
pub fn path_ops(data: &PathData) -> Vec<Op> {
    let mut out = Vec::with_capacity(data.segs.len());
    for s in &data.segs {
        out.push(match *s {
            Seg::Move { p } => op("m", vec![num(p.x), num(p.y)]),
            Seg::Line { p } => op("l", vec![num(p.x), num(p.y)]),
            Seg::Cubic { c1, c2, p } => op(
                "c",
                vec![
                    num(c1.x),
                    num(c1.y),
                    num(c2.x),
                    num(c2.y),
                    num(p.x),
                    num(p.y),
                ],
            ),
            Seg::Close => op("h", Vec::new()),
        });
    }
    out
}

/// Whether a node is written as the file drew it.
pub fn from_source(n: &Node) -> bool {
    n.source.is_some() && (matches!(n.kind, NodeKind::Raw { .. }) || n.edits & flags::REDRAWN == 0)
}

impl<'a, 'b> PageWriter<'a, 'b> {
    /// A writer for a page whose space `c2p` maps the canvas to.
    pub fn new(
        shared: &'b mut Shared<'a>,
        c2p: Affine,
        on_page: &'b HashSet<NodeIdx>,
    ) -> PageWriter<'a, 'b> {
        PageWriter {
            shared,
            c2p,
            on_page,
            targets: vec![Target {
                ops: Vec::new(),
                res: Resources::new(),
            }],
        }
    }

    fn doc(&self) -> &'a Document {
        self.shared.doc
    }

    fn file(&self) -> Option<&'a SourceFile> {
        self.shared.doc.file.as_deref()
    }

    fn top(&mut self) -> &mut Target {
        self.targets.last_mut().expect("the page's target")
    }

    fn push(&mut self, o: Op) {
        self.top().ops.push(o);
    }

    fn extend(&mut self, ops: Vec<Op>) {
        self.top().ops.extend(ops);
    }

    /// The page's content and resources.
    pub fn finish(mut self) -> (Vec<u8>, Dict) {
        let t = self.targets.pop().expect("the page's target");
        (crate::pdf::content::write(&t.ops), t.res.into_dict())
    }

    /// Writes the layers' content on this page.
    pub fn layers(&mut self) {
        for &l in &self.doc().layers {
            let n = self.doc().node(l);
            if n.removed || !self.on_page.contains(&l) {
                continue;
            }
            let Some(&ocg) = self.shared.layers.get(&l) else {
                continue;
            };
            let props = self.top().res.name("Properties", Object::Ref(ocg));
            self.push(op("BDC", vec![Object::name("OC"), Object::Name(props)]));
            for &c in &n.children {
                self.node(c);
            }
            self.push(op("EMC", Vec::new()));
        }
    }

    fn node(&mut self, i: NodeIdx) {
        let doc = self.doc();
        let n = doc.node(i);
        if n.removed || !self.on_page.contains(&i) {
            return;
        }
        let hidden = n.hidden && !n.is_layer();
        if hidden && let Some(h) = self.shared.hidden {
            let props = self.top().res.name("Properties", Object::Ref(h));
            self.push(op("BDC", vec![Object::name("OC"), Object::Name(props)]));
        }
        // An object's name (Illustrator keeps names in its own data, which
        // the saved file leaves out).
        let named = !n.is_container() && !n.name.is_empty();
        if named {
            let mark = marks::name_props(&n.name);
            self.push(op(
                "BDC",
                vec![Object::name(marks::NAME), Object::Dict(mark)],
            ));
        }
        match &n.kind {
            NodeKind::Layer { .. } => {}
            NodeKind::Group { .. } => self.group(i),
            _ if from_source(n) => {
                let wrap = matches!(n.kind, NodeKind::Raw { .. })
                    && (n.opacity < 1.0 || n.blend != BlendMode::Normal);
                if wrap {
                    self.begin_form();
                }
                if let Some(source) = &n.source {
                    self.source(n, source);
                }
                if wrap {
                    let bounds = node_bounds(doc, i);
                    self.end_form(n.opacity, n.blend, false, false, bounds);
                }
            }
            NodeKind::Path(p) => self.path(n, p),
            NodeKind::Text(t) if t.runs.is_some() => {
                let to_page = n.transform.followed_by(&self.c2p);
                let Target { ops, res } = self.targets.last_mut().expect("target");
                let file = self.shared.doc.file.as_deref();
                text::runs(n, t, &to_page, file, ops, res, self.shared.objects);
            }
            NodeKind::Text(t) => {
                let to_page = n.transform.followed_by(&self.c2p);
                let Target { ops, res } = self.targets.last_mut().expect("target");
                text::laid_out(
                    n,
                    t,
                    &to_page,
                    ops,
                    res,
                    self.shared.objects,
                    self.shared.invisible,
                );
            }
            NodeKind::Image(img) => self.image(n, img),
            NodeKind::Raw { .. } => {}
        }
        if named {
            self.push(op("EMC", Vec::new()));
        }
        if hidden && self.shared.hidden.is_some() {
            self.push(op("EMC", Vec::new()));
        }
    }

    /// A group: marked, clipped, and (when it has opacity, blending, or
    /// isolation) a transparency group form.
    fn group(&mut self, i: NodeIdx) {
        let doc = self.doc();
        let n = doc.node(i);
        let NodeKind::Group {
            clip,
            isolated,
            knockout,
        } = &n.kind
        else {
            return;
        };
        let form = n.opacity < 1.0 || n.blend != BlendMode::Normal || *isolated || *knockout;
        if form {
            self.begin_form();
        }
        let mark = marks::group_props(&GroupMark {
            name: n.name.clone(),
            clip: clip.is_some(),
        });
        self.push(op(
            "BDC",
            vec![Object::name(marks::GROUP), Object::Dict(mark)],
        ));
        self.push(op("q", Vec::new()));
        if let Some(c) = clip {
            let ops = path_ops(&c.path.transform(&self.c2p));
            self.extend(ops);
            self.push(op(if c.even_odd { "W*" } else { "W" }, Vec::new()));
            self.push(op("n", Vec::new()));
        }
        for &c in &n.children {
            self.node(c);
        }
        self.push(op("Q", Vec::new()));
        self.push(op("EMC", Vec::new()));
        if form {
            let bounds = node_bounds(doc, i);
            self.end_form(n.opacity, n.blend, *isolated, *knockout, bounds);
        }
    }

    /// Starts a form's content.
    fn begin_form(&mut self) {
        self.targets.push(Target {
            ops: Vec::new(),
            res: Resources::new(),
        });
    }

    /// Ends a form: it is drawn as a transparency group with an opacity and
    /// blend mode.
    fn end_form(
        &mut self,
        opacity: f32,
        blend: BlendMode,
        isolated: bool,
        knockout: bool,
        bounds: Option<Rect>,
    ) {
        let Some(t) = self.targets.pop() else { return };
        let bbox = bounds
            .map(|b| b.transform(&self.c2p).outset(4.0))
            .filter(|b| !b.is_empty() && b.width().is_finite())
            .unwrap_or(Rect::new(-1.0e5, -1.0e5, 1.0e5, 1.0e5));
        let mut group = Dict::new();
        group.set("Type", Object::name("Group"));
        group.set("S", Object::name("Transparency"));
        group.set("I", Object::Bool(isolated));
        group.set("K", Object::Bool(knockout));
        let mut d = Dict::new();
        d.set("Type", Object::name("XObject"));
        d.set("Subtype", Object::name("Form"));
        d.set(
            "BBox",
            Object::Array(vec![num(bbox.x0), num(bbox.y0), num(bbox.x1), num(bbox.y1)]),
        );
        d.set("Group", Object::Dict(group));
        d.set("Resources", Object::Dict(t.res.into_dict()));
        let data = crate::pdf::content::write(&t.ops);
        let stream = super::compressed(d, &data);
        let form = self.shared.objects.add(Object::Stream(stream));
        let name = self.top().res.name("XObject", Object::Ref(form));
        let mut ops = vec![op("q", Vec::new())];
        let gs = {
            let res = &mut self.top().res;
            alpha_ops(opacity, blend, res)
        };
        ops.extend(gs);
        ops.push(op("Do", vec![Object::Name(name)]));
        ops.push(op("Q", Vec::new()));
        self.extend(ops);
    }

    /// The canvas move since reading, as a page-space matrix for this
    /// page.
    fn delta(&self, n: &Node, source: &Source) -> Affine {
        let Some(page) = self.file().and_then(|f| f.pages.get(source.page as usize)) else {
            return Affine::IDENTITY;
        };
        let Some(inv) = source.transform.invert() else {
            return Affine::IDENTITY;
        };
        page.read_to_canvas()
            .followed_by(&inv)
            .followed_by(&n.transform)
            .followed_by(&self.c2p)
    }

    /// A node written with the operators that drew it.
    fn source(&mut self, n: &Node, source: &Source) {
        let Some(file) = self.file() else { return };
        let delta = self.delta(n, source);
        let src_res = file.resources(source.resources).clone();
        // Patterns were placed in the space the content started in; it now
        // starts in this page's, moved along.
        let patterns = source.base.followed_by(&delta);
        let mut ops = vec![op("q", Vec::new()), cm(&source.ctm.followed_by(&delta))];
        {
            let Target { res, .. } = self.targets.last_mut().expect("target");
            for (o, r) in &source.state {
                ops.push(rename(
                    o,
                    &file.pdf,
                    file.resources(*r),
                    res,
                    self.shared.objects,
                    &patterns,
                ));
            }
            for o in &source.ops {
                ops.push(rename(
                    o,
                    &file.pdf,
                    &src_res,
                    res,
                    self.shared.objects,
                    &patterns,
                ));
            }
        }
        ops.push(op("Q", Vec::new()));
        self.extend(ops);
    }

    /// A path written from the model.
    fn path(&mut self, n: &Node, p: &PathNode) {
        let to_page = n.transform.followed_by(&self.c2p);
        if p.fill.as_ref().is_some_and(has_alpha)
            || p.stroke.as_ref().is_some_and(|s| has_alpha(&s.paint))
        {
            self.masked_path(n, p, &to_page);
            return;
        }
        let mut ops = vec![op("q", Vec::new()), cm(&to_page)];
        {
            let Target { res, .. } = self.targets.last_mut().expect("target");
            ops.extend(alpha_ops(n.opacity, n.blend, res));
            if let Some(f) = &p.fill {
                ops.extend(paint_ops(f, false, &to_page, res, self.shared.objects));
            }
            if let Some(s) = &p.stroke {
                ops.extend(stroke_ops(s, &to_page, res, self.shared.objects));
            }
        }
        ops.extend(path_ops(&p.data));
        let paint = match (p.fill.is_some(), p.stroke.is_some(), p.even_odd) {
            (true, true, false) => "B",
            (true, true, true) => "B*",
            (true, false, false) => "f",
            (true, false, true) => "f*",
            (false, true, _) => "S",
            (false, false, _) => "n",
        };
        ops.push(op(paint, Vec::new()));
        ops.push(op("Q", Vec::new()));
        self.extend(ops);
    }

    /// A path with gradient stops that aren't opaque: its fill and its
    /// stroke each painted under a soft mask of their stops' opacities,
    /// in `/MacroPath` marked content that reads back as the path.
    fn masked_path(&mut self, n: &Node, p: &PathNode, to_page: &Affine) {
        let Target { res, .. } = self.targets.last_mut().expect("target");
        let objects = &mut *self.shared.objects;
        let mut ops = vec![op("q", Vec::new())];
        ops.extend(alpha_ops(n.opacity, n.blend, res));
        ops.push(op(
            "BDC",
            vec![
                Object::name(marks::PATH),
                Object::Dict(marks::path_props(p, to_page)),
            ],
        ));
        ops.push(cm(to_page));
        let bounds = p.data.bounds().unwrap_or_default();
        if let Some(f) = &p.fill {
            ops.push(op("q", Vec::new()));
            ops.extend(alpha_mask_ops(f, bounds, res, objects));
            ops.extend(paint_ops(f, false, to_page, res, objects));
            ops.extend(path_ops(&p.data));
            ops.push(op(if p.even_odd { "f*" } else { "f" }, Vec::new()));
            ops.push(op("Q", Vec::new()));
        }
        if let Some(s) = &p.stroke {
            let reach = s.width / 2.0 * s.miter_limit.max(1.0) + 1.0;
            ops.push(op("q", Vec::new()));
            ops.extend(alpha_mask_ops(&s.paint, bounds.outset(reach), res, objects));
            ops.extend(stroke_ops(s, to_page, res, objects));
            ops.extend(path_ops(&p.data));
            ops.push(op("S", Vec::new()));
            ops.push(op("Q", Vec::new()));
        }
        ops.push(op("EMC", Vec::new()));
        ops.push(op("Q", Vec::new()));
        self.extend(ops);
    }

    /// An image written from the model.
    fn image(&mut self, n: &Node, img: &ImageNode) {
        let to_page = n.transform.followed_by(&self.c2p);
        let mut ops = vec![op("q", Vec::new()), cm(&to_page)];
        {
            let Target { res, .. } = self.targets.last_mut().expect("target");
            ops.extend(alpha_ops(n.opacity, n.blend, res));
        }
        match &img.source {
            ImageSource::File { .. } => {
                let (Some(file), Some(source)) = (self.file(), n.source.as_ref()) else {
                    return;
                };
                let src_res = file.resources(source.resources).clone();
                let Some(draw) = source.ops.first() else {
                    return;
                };
                let Target { res, .. } = self.targets.last_mut().expect("target");
                ops.push(rename(
                    draw,
                    &file.pdf,
                    &src_res,
                    res,
                    self.shared.objects,
                    &Affine::IDENTITY,
                ));
            }
            ImageSource::Added { hash } => {
                let Some(xobject) = self.added_image(hash) else {
                    return;
                };
                let name = self.top().res.name("XObject", Object::Ref(xobject));
                ops.push(op("Do", vec![Object::Name(name)]));
            }
        }
        ops.push(op("Q", Vec::new()));
        self.extend(ops);
    }

    /// An added image's XObject (written once).
    fn added_image(&mut self, hash: &str) -> Option<ObjRef> {
        if let Some(&r) = self.shared.images.get(hash) {
            return Some(r);
        }
        let img = self.doc().images.get(hash)?;
        let mut d = Dict::new();
        d.set("Type", Object::name("XObject"));
        d.set("Subtype", Object::name("Image"));
        d.set("Width", i64::from(img.width));
        d.set("Height", i64::from(img.height));
        d.set("ColorSpace", Object::name("DeviceRGB"));
        d.set("BitsPerComponent", 8);
        let opaque = img.rgba.chunks_exact(4).all(|p| p[3] == 255);
        if !opaque {
            let alpha: Vec<u8> = img.rgba.chunks_exact(4).map(|p| p[3]).collect();
            let mut m = Dict::new();
            m.set("Type", Object::name("XObject"));
            m.set("Subtype", Object::name("Image"));
            m.set("Width", i64::from(img.width));
            m.set("Height", i64::from(img.height));
            m.set("ColorSpace", Object::name("DeviceGray"));
            m.set("BitsPerComponent", 8);
            let mask = self
                .shared
                .objects
                .add(Object::Stream(super::compressed(m, &alpha)));
            d.set("SMask", Object::Ref(mask));
        }
        let stream = match &img.jpeg {
            Some(jpeg) if opaque => {
                d.set("Filter", Object::name("DCTDecode"));
                Stream::new(d, jpeg.to_vec())
            }
            _ => {
                let rgb: Vec<u8> = img
                    .rgba
                    .chunks_exact(4)
                    .flat_map(|p| [p[0], p[1], p[2]])
                    .collect();
                super::compressed(d, &rgb)
            }
        };
        let r = self.shared.objects.add(Object::Stream(stream));
        self.shared.images.insert(hash.to_string(), r);
        Some(r)
    }
}