mirror of
https://github.com/storytold/craft-libs.git
synced 2026-11-17 19:14:26 +00:00
Document::add_optional_content_group writes an OCG; Surface::start_optional_content and end_optional_content mark content with /OC BDC/EMC, registering the group under the stream's /Properties resources. Marks nest independently of tagging, and misuse returns or records a KrillaError instead of panicking. The catalog gets /OCProperties (hidden groups in /OFF) and, opt-in, /PageMode /UseOC. PDF/A-1 reports ValidationError::OptionalContent; below PDF 1.5 the version requirement is registered too.
1376 lines
48 KiB
Rust
1376 lines
48 KiB
Rust
//! A low-level abstraction over a single content stream.
|
|
|
|
use std::cell::RefCell;
|
|
use std::collections::HashSet;
|
|
use std::rc::Rc;
|
|
use std::sync::Arc;
|
|
|
|
use float_cmp::approx_eq;
|
|
use pdf_writer::types::TextRenderingMode;
|
|
use pdf_writer::{Content, Finish, Name, Ref, Str, TextStr};
|
|
use tiny_skia_path::{Path, PathSegment, PathVerb};
|
|
|
|
use crate::chunk_container::ChunkContainer;
|
|
use crate::color::rgb;
|
|
use crate::configure::ValidationError;
|
|
#[cfg(feature = "raster-images")]
|
|
use crate::geom::Size;
|
|
use crate::geom::{Point, Rect, Transform};
|
|
use crate::graphics::blend::{GroupOptions, Overprint};
|
|
use crate::graphics::color::{Color, ColorSpace};
|
|
use crate::graphics::graphics_state::{ExtGState, GraphicsStates};
|
|
#[cfg(feature = "raster-images")]
|
|
use crate::graphics::image::Image;
|
|
use crate::graphics::mask::Mask;
|
|
use crate::graphics::optional_content::{self, OpenMarks};
|
|
use crate::graphics::paint::{Fill, FillRule, InnerPaint, LineCap, LineJoin, Paint, Stroke};
|
|
use crate::graphics::shading_function::{
|
|
GradientProperties, GradientPropertiesExt, ShadingFunction,
|
|
};
|
|
use crate::graphics::shading_pattern::ShadingPattern;
|
|
use crate::graphics::tiling_pattern::TilingPattern;
|
|
use crate::graphics::xobject::XObject;
|
|
use crate::interchange::tagging::ContentTag;
|
|
use crate::num::NormalizedF32;
|
|
use crate::resource;
|
|
use crate::resource::{Resource, ResourceDictionaryBuilder};
|
|
use crate::serialize::{MaybeDeviceColorSpace, SerializeContext};
|
|
use crate::stream::Stream;
|
|
use crate::text::group::{use_text_spanner, GlyphGroup, GlyphGrouper, GlyphSpan, GlyphSpanner};
|
|
use crate::text::type3::ColoredGlyph;
|
|
use crate::text::{Font, FontContainer, FontIdentifier, PdfFont, PDF_UNITS_PER_EM};
|
|
use crate::text::{Glyph, GlyphId};
|
|
use crate::util::{calculate_stroke_bbox, NameExt};
|
|
|
|
pub(crate) struct ContentBuilder {
|
|
pub(crate) rd_builder: ResourceDictionaryBuilder,
|
|
pub(crate) content: Content,
|
|
validation_errors: HashSet<ValidationError>,
|
|
root_transform: Transform,
|
|
graphics_states: GraphicsStates,
|
|
bbox: Option<Rect>,
|
|
uses_mask: bool,
|
|
// Calculating the bbox of text is expensive, so we should avoid doing it if not needed.
|
|
// The only time we really need it is if we are currently inside of an XObject, where we
|
|
// need to provide a bbox of all its contents. If we are on the main page stream, we only
|
|
// need it if automatic size detection is enabled.
|
|
bbox_important: bool,
|
|
/// A temporary buffer that's reused across the builder.
|
|
scratch: Vec<u8>,
|
|
pub(crate) active_marked_content: bool,
|
|
pub(crate) optional_content: OpenMarks,
|
|
}
|
|
|
|
/// Stores either a device-specific color space,
|
|
/// or the name of a different colorspace (e.g. ICCBased) stored in
|
|
/// the current resource dictionary
|
|
enum ContentColorSpace {
|
|
Device,
|
|
Named(String),
|
|
}
|
|
|
|
impl ContentBuilder {
|
|
pub(crate) fn new(
|
|
root_transform: Transform,
|
|
bbox_important: bool,
|
|
sc: &SerializeContext,
|
|
) -> Self {
|
|
Self {
|
|
rd_builder: ResourceDictionaryBuilder::new(),
|
|
validation_errors: HashSet::new(),
|
|
content: sc.new_content(),
|
|
root_transform,
|
|
uses_mask: false,
|
|
bbox_important,
|
|
graphics_states: GraphicsStates::new(),
|
|
bbox: None,
|
|
scratch: Vec::new(),
|
|
active_marked_content: false,
|
|
optional_content: OpenMarks::default(),
|
|
}
|
|
}
|
|
|
|
pub(crate) fn content_save_state(&mut self) {
|
|
self.content.save_state();
|
|
|
|
if self.content.state_nesting_depth() > 28 {
|
|
self.validation_errors
|
|
.insert(ValidationError::TooHighQNestingLevel);
|
|
}
|
|
}
|
|
|
|
pub(crate) fn finish(mut self, sc: &mut SerializeContext) -> Stream {
|
|
optional_content::close_open_marks(&mut self, sc);
|
|
let buf = self.content.finish();
|
|
sc.register_limits(buf.limits());
|
|
|
|
Stream::new(
|
|
buf.to_vec(),
|
|
self.bbox
|
|
.unwrap_or(Rect::from_xywh(0.0, 0.0, 1.0, 1.0).unwrap()),
|
|
self.validation_errors.into_iter().collect(),
|
|
self.rd_builder.finish(),
|
|
self.uses_mask,
|
|
)
|
|
}
|
|
|
|
fn start_marked_content_prelude(&mut self) {
|
|
if self.active_marked_content {
|
|
panic!("can't start marked content twice");
|
|
}
|
|
|
|
self.active_marked_content = true;
|
|
}
|
|
|
|
#[track_caller]
|
|
pub(crate) fn start_marked_content(&mut self, name: Name) {
|
|
self.start_marked_content_prelude();
|
|
self.content.begin_marked_content(name);
|
|
}
|
|
|
|
#[track_caller]
|
|
pub(crate) fn start_marked_content_with_properties(
|
|
&mut self,
|
|
sc: &mut SerializeContext,
|
|
mcid: Option<i32>,
|
|
tag: ContentTag,
|
|
) {
|
|
self.start_marked_content_prelude();
|
|
|
|
let mut mc = self
|
|
.content
|
|
.begin_marked_content_with_properties(tag.name());
|
|
let mut properties = mc.properties();
|
|
|
|
if let Some(mcid) = mcid {
|
|
properties.pairs([(Name(b"MCID"), mcid)]);
|
|
}
|
|
|
|
// Page height extracted from transform and passed to function to allow
|
|
// its dependants to flip the y-axis, mirroring Krilla conventions.
|
|
let page_height = self.root_transform.ty();
|
|
tag.write_properties(sc, properties, page_height);
|
|
}
|
|
|
|
pub(crate) fn end_marked_content(&mut self) {
|
|
if !self.active_marked_content {
|
|
panic!("can't end marked content when none has been started");
|
|
}
|
|
|
|
self.optional_content.tag_ended();
|
|
self.content.end_marked_content();
|
|
self.active_marked_content = false;
|
|
}
|
|
|
|
pub(crate) fn concat_transform(&mut self, transform: &Transform) {
|
|
self.graphics_states.transform(*transform);
|
|
}
|
|
|
|
fn cur_transform_with_root_transform(&self) -> Transform {
|
|
self.root_transform.pre_concat(self.cur_transform())
|
|
}
|
|
|
|
pub(crate) fn cur_transform(&self) -> Transform {
|
|
self.graphics_states.cur().transform()
|
|
}
|
|
|
|
pub(crate) fn save_graphics_state(&mut self) {
|
|
self.graphics_states.save_state();
|
|
}
|
|
|
|
pub(crate) fn restore_graphics_state(&mut self) {
|
|
self.graphics_states.restore_state();
|
|
}
|
|
|
|
pub(crate) fn set_blend_mode(&mut self, blend_mode: pdf_writer::types::BlendMode) {
|
|
if blend_mode != pdf_writer::types::BlendMode::Normal {
|
|
let state = ExtGState::new().blend_mode(blend_mode);
|
|
self.graphics_states.combine(&state);
|
|
}
|
|
}
|
|
|
|
pub(crate) fn set_overprint(&mut self, overprint: Overprint) {
|
|
let state =
|
|
ExtGState::new().overprint(overprint.fill, overprint.stroke, overprint.to_pdf_mode());
|
|
self.graphics_states.combine(&state);
|
|
}
|
|
|
|
pub(crate) fn expand_bbox(&mut self, new_bbox: Rect) {
|
|
let new_bbox = self.graphics_states.transform_bbox(new_bbox);
|
|
if let Some(bbox) = &mut self.bbox {
|
|
bbox.expand(&new_bbox);
|
|
} else {
|
|
self.bbox = Some(new_bbox);
|
|
}
|
|
}
|
|
|
|
pub(crate) fn draw_path(
|
|
&mut self,
|
|
path: &Path,
|
|
mut fill: Option<&Fill>,
|
|
stroke: Option<&Stroke>,
|
|
sc: &mut SerializeContext,
|
|
chunk_container: &mut ChunkContainer,
|
|
) {
|
|
if fill.is_none() && stroke.is_none() {
|
|
return;
|
|
}
|
|
|
|
// Zero-size geometry, don't draw.
|
|
if path.bounds().width() == 0.0 && path.bounds().height() == 0.0 {
|
|
return;
|
|
}
|
|
|
|
// See issue 199.
|
|
let is_line = path.verbs().len() == 2
|
|
&& path.verbs()[0] == PathVerb::Move
|
|
&& path.verbs()[1] == PathVerb::Line;
|
|
let dont_fill = path.bounds().width() == 0.0 || path.bounds().height() == 0.0 || is_line;
|
|
|
|
if dont_fill {
|
|
match stroke.is_some() {
|
|
// Some PDF viewers have bugs where they slightly fill zero-sized lines, so
|
|
// don't draw them in the first place.
|
|
false => return,
|
|
// Don't fill, but we still want to draw the stroke, so don't return.
|
|
true => {
|
|
fill = None;
|
|
}
|
|
}
|
|
}
|
|
|
|
let bbox_important = self.bbox_important;
|
|
let calculate_bbox = |is_solid: bool| bbox_important || !is_solid;
|
|
|
|
let stroke_bbox = |stroke: &Stroke| {
|
|
if calculate_bbox(matches!(&stroke.paint.0, InnerPaint::Color(_))) {
|
|
calculate_stroke_bbox(stroke, path).unwrap_or(Rect::from_tsp(path.bounds()))
|
|
} else {
|
|
Rect::from_tsp(path.bounds())
|
|
}
|
|
};
|
|
|
|
let fill_prep = |sb: &mut ContentBuilder, fill: &Fill| {
|
|
let has_pattern = matches!(fill.paint.0, InnerPaint::Pattern(_));
|
|
let fill_opacity = fill.opacity;
|
|
sb.expand_bbox(Rect::from_tsp(path.bounds()));
|
|
|
|
// PDF viewers don't show patterns with fill/stroke opacities consistently.
|
|
// Because of this, the opacity is accounted for in the pattern itself.
|
|
if !has_pattern {
|
|
sb.set_fill_opacity(fill_opacity);
|
|
}
|
|
};
|
|
|
|
let stroke_prep = |sb: &mut ContentBuilder, stroke: &Stroke, stroke_bbox: Rect| {
|
|
let is_pattern = matches!(stroke.paint.0, InnerPaint::Pattern(_));
|
|
let stroke_opacity = stroke.opacity;
|
|
sb.expand_bbox(stroke_bbox);
|
|
|
|
// See comment in `set_fill_properties`
|
|
if !is_pattern {
|
|
sb.set_stroke_opacity(stroke_opacity);
|
|
}
|
|
};
|
|
|
|
let fill_op = |sb: &mut ContentBuilder,
|
|
sc: &mut SerializeContext,
|
|
chunk_container: &mut ChunkContainer,
|
|
fill: &Fill| {
|
|
let fill_rule = fill.rule;
|
|
sb.content_set_fill_properties(
|
|
Rect::from_tsp(path.bounds()),
|
|
fill,
|
|
sc,
|
|
chunk_container,
|
|
);
|
|
sb.content_draw_path(path.segments());
|
|
|
|
match fill_rule {
|
|
FillRule::NonZero => sb.content.fill_nonzero(),
|
|
FillRule::EvenOdd => sb.content.fill_even_odd(),
|
|
};
|
|
};
|
|
|
|
let stroke_op = |sb: &mut ContentBuilder,
|
|
sc: &mut SerializeContext,
|
|
chunk_container: &mut ChunkContainer,
|
|
stroke: &Stroke,
|
|
stroke_bbox: Rect| {
|
|
sb.content_set_stroke_properties(stroke_bbox, stroke, sc, chunk_container);
|
|
sb.content_draw_path(path.segments());
|
|
sb.content.stroke();
|
|
};
|
|
|
|
let fill_stroke_op = |sb: &mut ContentBuilder,
|
|
sc: &mut SerializeContext,
|
|
chunk_container: &mut ChunkContainer,
|
|
fill: &Fill,
|
|
stroke: &Stroke,
|
|
stroke_bbox: Rect| {
|
|
let fill_rule = fill.rule;
|
|
sb.content_set_fill_properties(
|
|
Rect::from_tsp(path.bounds()),
|
|
fill,
|
|
sc,
|
|
chunk_container,
|
|
);
|
|
sb.content_set_stroke_properties(stroke_bbox, stroke, sc, chunk_container);
|
|
sb.content_draw_path(path.segments());
|
|
|
|
match fill_rule {
|
|
FillRule::NonZero => sb.content.fill_nonzero_and_stroke(),
|
|
FillRule::EvenOdd => sb.content.fill_even_odd_and_stroke(),
|
|
};
|
|
};
|
|
|
|
match (fill, stroke) {
|
|
(Some(fill), None) => {
|
|
self.apply_isolated_op(
|
|
|sb, _, _| {
|
|
fill_prep(sb, fill);
|
|
},
|
|
|sb, sc, chunk_container| {
|
|
fill_op(sb, sc, chunk_container, fill);
|
|
},
|
|
sc,
|
|
chunk_container,
|
|
);
|
|
}
|
|
(None, Some(stroke)) => {
|
|
let stroke_bbox = stroke_bbox(stroke);
|
|
|
|
self.apply_isolated_op(
|
|
|sb, _, _| {
|
|
stroke_prep(sb, stroke, stroke_bbox);
|
|
},
|
|
|sb, sc, chunk_container| {
|
|
stroke_op(sb, sc, chunk_container, stroke, stroke_bbox);
|
|
},
|
|
sc,
|
|
chunk_container,
|
|
);
|
|
}
|
|
(Some(fill), Some(stroke)) => {
|
|
let stroke_bbox = stroke_bbox(stroke);
|
|
|
|
self.apply_isolated_op(
|
|
|sb, _, _| {
|
|
fill_prep(sb, fill);
|
|
stroke_prep(sb, stroke, stroke_bbox);
|
|
},
|
|
|sb, sc, chunk_container| {
|
|
fill_stroke_op(sb, sc, chunk_container, fill, stroke, stroke_bbox);
|
|
},
|
|
sc,
|
|
chunk_container,
|
|
);
|
|
}
|
|
(None, None) => unreachable!(),
|
|
}
|
|
}
|
|
|
|
pub(crate) fn push_clip_path(&mut self, path: &Path, clip_rule: &FillRule) {
|
|
self.content_save_state();
|
|
self.content_draw_path(
|
|
path.clone()
|
|
.transform(self.cur_transform_with_root_transform().to_tsp())
|
|
.unwrap()
|
|
.segments(),
|
|
);
|
|
|
|
match clip_rule {
|
|
FillRule::NonZero => self.content.clip_nonzero(),
|
|
FillRule::EvenOdd => self.content.clip_even_odd(),
|
|
};
|
|
|
|
self.content.end_path();
|
|
}
|
|
|
|
pub(crate) fn pop_clip_path(&mut self) {
|
|
self.content.restore_state();
|
|
}
|
|
|
|
#[allow(clippy::too_many_arguments)]
|
|
pub(crate) fn draw_glyphs(
|
|
&mut self,
|
|
start: Point,
|
|
sc: &mut SerializeContext,
|
|
chunk_container: &mut ChunkContainer,
|
|
fill: Option<&Fill>,
|
|
stroke: Option<&Stroke>,
|
|
context_color: rgb::Color,
|
|
glyphs: &[impl Glyph],
|
|
font: Font,
|
|
text: &str,
|
|
font_size: f32,
|
|
) {
|
|
if fill.is_none() && stroke.is_none() {
|
|
return;
|
|
}
|
|
|
|
let (x, y) = (start.x, start.y);
|
|
self.graphics_states.save_state();
|
|
|
|
// Calculating the glyphs bbox is very expensive but not always necessary, so omit
|
|
// if not needed.
|
|
let bbox_important = self.bbox_important;
|
|
let calculate_bbox = |is_solid: bool| bbox_important || !is_solid;
|
|
|
|
let fill_action = |sb: &mut ContentBuilder,
|
|
sc: &mut SerializeContext,
|
|
chunk_container: &mut ChunkContainer,
|
|
fill: &Fill| {
|
|
let bbox = if calculate_bbox(matches!(&fill.paint.0, InnerPaint::Color(_))) {
|
|
let bbox = get_glyphs_bbox(glyphs, x, y, font_size, font.clone());
|
|
sb.expand_bbox(bbox);
|
|
bbox
|
|
} else {
|
|
Rect::from_xywh(0.0, 0.0, 1.0, 1.0).unwrap()
|
|
};
|
|
|
|
sb.content_set_fill_properties(bbox, fill, sc, chunk_container)
|
|
};
|
|
|
|
let stroke_action = |sb: &mut ContentBuilder,
|
|
sc: &mut SerializeContext,
|
|
chunk_container: &mut ChunkContainer,
|
|
stroke: &Stroke| {
|
|
let bbox = if calculate_bbox(matches!(&stroke.paint.0, InnerPaint::Color(_))) {
|
|
// TODO: Bbox should also account for stroke.
|
|
let bbox = get_glyphs_bbox(glyphs, x, y, font_size, font.clone());
|
|
sb.expand_bbox(bbox);
|
|
bbox
|
|
} else {
|
|
Rect::from_xywh(0.0, 0.0, 1.0, 1.0).unwrap()
|
|
};
|
|
|
|
sb.content_set_stroke_properties(bbox, stroke, sc, chunk_container);
|
|
};
|
|
|
|
let set_fill_opacity = |sb: &mut ContentBuilder, fill: &Fill| {
|
|
// PDF viewers don't show patterns with fill/stroke opacities consistently.
|
|
// Because of this, the opacity is accounted for in the pattern itself.
|
|
if !matches!(&fill.paint.0, &InnerPaint::Pattern(_)) {
|
|
sb.set_fill_opacity(fill.opacity);
|
|
}
|
|
};
|
|
|
|
let set_stroke_opacity = |sb: &mut ContentBuilder, stroke: &Stroke| {
|
|
// PDF viewers don't show patterns with fill/stroke opacities consistently.
|
|
// Because of this, the opacity is accounted for in the pattern itself.
|
|
if !matches!(&stroke.paint.0, &InnerPaint::Pattern(_)) {
|
|
// PDF viewers don't show patterns with fill/stroke opacities consistently.
|
|
// Because of this, the opacity is accounted for in the pattern itself.
|
|
sb.set_stroke_opacity(stroke.opacity);
|
|
|
|
// See the comment in `stroke-action` for why we also set the fill opacity.
|
|
sb.set_fill_opacity(stroke.opacity);
|
|
}
|
|
};
|
|
|
|
match (fill, stroke) {
|
|
(Some(f), Some(s)) => {
|
|
set_fill_opacity(self, f);
|
|
set_stroke_opacity(self, s);
|
|
|
|
self.fill_stroke_glyph_run(
|
|
x,
|
|
y,
|
|
sc,
|
|
chunk_container,
|
|
TextRenderingMode::FillStroke,
|
|
|sb, sc, chunk_container| {
|
|
fill_action(sb, sc, chunk_container, f);
|
|
stroke_action(sb, sc, chunk_container, s);
|
|
},
|
|
glyphs,
|
|
font.clone(),
|
|
context_color,
|
|
text,
|
|
font_size,
|
|
);
|
|
}
|
|
(Some(f), None) => {
|
|
set_fill_opacity(self, f);
|
|
|
|
self.fill_stroke_glyph_run(
|
|
x,
|
|
y,
|
|
sc,
|
|
chunk_container,
|
|
TextRenderingMode::Fill,
|
|
|sb, sc, chunk_container| {
|
|
fill_action(sb, sc, chunk_container, f);
|
|
},
|
|
glyphs,
|
|
font.clone(),
|
|
context_color,
|
|
text,
|
|
font_size,
|
|
);
|
|
}
|
|
(None, Some(s)) => {
|
|
set_stroke_opacity(self, s);
|
|
|
|
self.fill_stroke_glyph_run(
|
|
x,
|
|
y,
|
|
sc,
|
|
chunk_container,
|
|
TextRenderingMode::Stroke,
|
|
|sb, sc, chunk_container| {
|
|
stroke_action(sb, sc, chunk_container, s);
|
|
},
|
|
glyphs,
|
|
font.clone(),
|
|
context_color,
|
|
text,
|
|
font_size,
|
|
);
|
|
}
|
|
(None, None) => unreachable!(),
|
|
}
|
|
|
|
self.graphics_states.restore_state();
|
|
}
|
|
|
|
/// Encode a successive sequence of glyphs that share the same properties and
|
|
/// can be encoded with one text showing operator.
|
|
#[allow(clippy::too_many_arguments)]
|
|
#[inline(always)]
|
|
fn encode_consecutive_glyph_run(
|
|
&mut self,
|
|
sc: &mut SerializeContext,
|
|
cur_x: &mut f32,
|
|
cur_y: f32,
|
|
font_identifier: FontIdentifier,
|
|
pdf_font: &dyn PdfFont,
|
|
size: f32,
|
|
context_color: rgb::Color,
|
|
glyphs: &[impl Glyph],
|
|
text: &str,
|
|
) {
|
|
let font_name = self
|
|
.rd_builder
|
|
.register_resource(sc.register_font_identifier(font_identifier));
|
|
self.content.set_font(font_name.to_pdf_name(), size);
|
|
self.content.set_text_matrix(
|
|
Transform::from_row(1.0, 0.0, 0.0, -1.0, *cur_x, cur_y).to_pdf_transform(),
|
|
);
|
|
|
|
for glyph in glyphs {
|
|
if glyph.glyph_id() == GlyphId::new(0)
|
|
|| pdf_font.font().postscript_name() == Some("LastResort")
|
|
{
|
|
sc.register_validation_error(ValidationError::ContainsNotDefGlyph(
|
|
pdf_font.font(),
|
|
glyph.location(),
|
|
text[glyph.text_range()].to_string(),
|
|
));
|
|
}
|
|
}
|
|
|
|
// If it's just a single glyph and without an x_offset, there is no need for individual
|
|
// positioning, so we can use `Tj` instead of `TJ`. The reason we're doing this is because
|
|
// Acrobat's copy-paste is a bit buggy if `/ActualText` is used at the end of a line, but
|
|
// only if `TJ` is used. With `Tj`, it's fine.
|
|
if let [glyph] = glyphs {
|
|
if approx_eq!(f32, glyph.x_offset(1.0), 0.0, epsilon = 0.001) {
|
|
self.encode_single_glyph(cur_x, pdf_font, size, context_color, glyph);
|
|
return;
|
|
}
|
|
}
|
|
|
|
self.encode_glyphs_with_individual_positioning(
|
|
cur_x,
|
|
pdf_font,
|
|
size,
|
|
context_color,
|
|
glyphs,
|
|
);
|
|
}
|
|
|
|
fn encode_single_glyph(
|
|
&mut self,
|
|
cur_x: &mut f32,
|
|
pdf_font: &dyn PdfFont,
|
|
size: f32,
|
|
context_color: rgb::Color,
|
|
glyph: &impl Glyph,
|
|
) {
|
|
let pdf_glyph = pdf_font
|
|
.get_gid(ColoredGlyph::new(glyph.glyph_id(), context_color))
|
|
.unwrap();
|
|
self.scratch.clear();
|
|
let encoded = &mut self.scratch;
|
|
pdf_glyph.encode_into(encoded);
|
|
self.content.show(Str(encoded));
|
|
*cur_x += glyph.x_advance(size);
|
|
}
|
|
|
|
fn encode_glyphs_with_individual_positioning(
|
|
&mut self,
|
|
cur_x: &mut f32,
|
|
pdf_font: &dyn PdfFont,
|
|
size: f32,
|
|
context_color: rgb::Color,
|
|
glyphs: &[impl Glyph],
|
|
) {
|
|
self.scratch.clear();
|
|
let encoded = &mut self.scratch;
|
|
|
|
let mut adjustment = 0.0;
|
|
let mut positioned = self.content.show_positioned();
|
|
let mut items = positioned.items();
|
|
|
|
for glyph in glyphs {
|
|
let pdf_glyph = pdf_font
|
|
.get_gid(ColoredGlyph::new(glyph.glyph_id(), context_color))
|
|
.unwrap();
|
|
|
|
let scale = |val| val * pdf_font.units_per_em();
|
|
|
|
let x_advance = scale(glyph.x_advance(1.0));
|
|
let font_advance = pdf_font
|
|
.font()
|
|
.advance_width(glyph.glyph_id())
|
|
.map(|n| scale(n / pdf_font.font().units_per_em()));
|
|
let x_offset = scale(glyph.x_offset(1.0));
|
|
|
|
adjustment += x_offset;
|
|
|
|
// Make sure we don't write miniscule adjustments
|
|
if !approx_eq!(f32, adjustment, 0.0, epsilon = 0.001) {
|
|
if !encoded.is_empty() {
|
|
items.show(Str(encoded));
|
|
encoded.clear();
|
|
}
|
|
|
|
// Adjustment is always in 1000 units, even for Type3 fonts.
|
|
items.adjust(-(adjustment / pdf_font.units_per_em() * PDF_UNITS_PER_EM));
|
|
adjustment = 0.0;
|
|
}
|
|
|
|
pdf_glyph.encode_into(encoded);
|
|
|
|
if let Some(font_advance) = font_advance {
|
|
adjustment += x_advance - font_advance;
|
|
}
|
|
|
|
adjustment -= x_offset;
|
|
// cur_x/cur_y and glyph metrics are in user space units.
|
|
*cur_x += glyph.x_advance(size);
|
|
}
|
|
|
|
if !encoded.is_empty() {
|
|
items.show(Str(encoded));
|
|
}
|
|
|
|
items.finish();
|
|
positioned.finish();
|
|
}
|
|
|
|
#[allow(clippy::too_many_arguments)]
|
|
fn fill_stroke_glyph_run(
|
|
&mut self,
|
|
x: f32,
|
|
ys: f32,
|
|
sc: &mut SerializeContext,
|
|
chunk_container: &mut ChunkContainer,
|
|
fill_render_mode: TextRenderingMode,
|
|
action: impl FnOnce(&mut ContentBuilder, &mut SerializeContext, &mut ChunkContainer),
|
|
glyphs: &[impl Glyph],
|
|
font: Font,
|
|
context_color: rgb::Color,
|
|
text: &str,
|
|
font_size: f32,
|
|
) {
|
|
if glyphs.is_empty() {
|
|
return;
|
|
}
|
|
|
|
self.apply_isolated_op(
|
|
|_, _, _| {},
|
|
|sb, sc, chunk_container| {
|
|
let mut cur_x = x;
|
|
let mut cur_y = ys;
|
|
|
|
// When the glyph ranges are monotonically decreasing, the glyphs are in reverse
|
|
// order and we should write `/ReversedChars` marked content.
|
|
let reversed = glyphs.len() > 1
|
|
&& glyphs
|
|
.windows(2)
|
|
.all(|w| w[0].text_range().start >= w[1].text_range().end);
|
|
|
|
action(sb, sc, chunk_container);
|
|
sb.content.begin_text();
|
|
|
|
let font_container = sc.register_font_container(font.clone());
|
|
let do_text_span = reversed
|
|
|| use_text_spanner(
|
|
glyphs,
|
|
text,
|
|
context_color,
|
|
&mut font_container.borrow_mut(),
|
|
);
|
|
|
|
if do_text_span {
|
|
// Separate into distinct glyph runs that either are encoded using actual text, or are
|
|
// not.
|
|
let spanned = GlyphSpanner::new(
|
|
glyphs,
|
|
text,
|
|
reversed,
|
|
sc.serialize_settings()
|
|
.validators()
|
|
.requires_codepoint_mappings(),
|
|
context_color,
|
|
font_container.clone(),
|
|
);
|
|
|
|
for fragment in spanned {
|
|
sb.fill_stroke_glyph_span(
|
|
&mut cur_x,
|
|
&mut cur_y,
|
|
fragment,
|
|
sc,
|
|
fill_render_mode,
|
|
font_container.clone(),
|
|
context_color,
|
|
text,
|
|
font_size,
|
|
reversed,
|
|
)
|
|
}
|
|
} else {
|
|
let glyph_span = GlyphSpan::Unspanned(glyphs);
|
|
|
|
sb.fill_stroke_glyph_span(
|
|
&mut cur_x,
|
|
&mut cur_y,
|
|
glyph_span,
|
|
sc,
|
|
fill_render_mode,
|
|
font_container.clone(),
|
|
context_color,
|
|
text,
|
|
font_size,
|
|
reversed,
|
|
)
|
|
}
|
|
|
|
sb.content.end_text();
|
|
},
|
|
sc,
|
|
chunk_container,
|
|
)
|
|
}
|
|
|
|
#[allow(clippy::too_many_arguments)]
|
|
fn fill_stroke_glyph_span(
|
|
&mut self,
|
|
cur_x: &mut f32,
|
|
cur_y: &mut f32,
|
|
fragment: GlyphSpan<'_, impl Glyph>,
|
|
sc: &mut SerializeContext,
|
|
fill_render_mode: TextRenderingMode,
|
|
font_container: Rc<RefCell<FontContainer>>,
|
|
context_color: rgb::Color,
|
|
text: &str,
|
|
font_size: f32,
|
|
reversed: bool,
|
|
) {
|
|
if let Some(text) = fragment.actual_text() {
|
|
let mut actual_text = self
|
|
.content
|
|
.begin_marked_content_with_properties(Name(b"Span"));
|
|
actual_text.properties().actual_text(TextStr(text));
|
|
}
|
|
|
|
if reversed {
|
|
self.content.begin_marked_content(Name(b"ReversedChars"));
|
|
}
|
|
|
|
// Segment into glyph runs that can be encoded in one go using a PDF
|
|
// text showing operator (i.e. no y shift, same Type3 font, etc.)
|
|
let segmented = GlyphGrouper::new(font_container.clone(), context_color, fragment.glyphs());
|
|
|
|
for glyph_group in segmented {
|
|
self.fill_stroke_glyph_group(
|
|
cur_x,
|
|
cur_y,
|
|
glyph_group,
|
|
sc,
|
|
fill_render_mode,
|
|
font_container.clone(),
|
|
context_color,
|
|
text,
|
|
font_size,
|
|
)
|
|
}
|
|
|
|
if reversed {
|
|
self.content.end_marked_content();
|
|
}
|
|
|
|
if fragment.actual_text().is_some() {
|
|
self.content.end_marked_content();
|
|
}
|
|
}
|
|
|
|
#[allow(clippy::too_many_arguments)]
|
|
fn fill_stroke_glyph_group(
|
|
&mut self,
|
|
cur_x: &mut f32,
|
|
cur_y: &mut f32,
|
|
glyph_group: GlyphGroup<'_, impl Glyph>,
|
|
sc: &mut SerializeContext,
|
|
fill_render_mode: TextRenderingMode,
|
|
font_container: Rc<RefCell<FontContainer>>,
|
|
context_color: rgb::Color,
|
|
text: &str,
|
|
font_size: f32,
|
|
) {
|
|
let borrowed = font_container.borrow();
|
|
let pdf_font = borrowed
|
|
.get_from_identifier(glyph_group.font_identifier.clone())
|
|
.unwrap();
|
|
|
|
if fill_render_mode == TextRenderingMode::Fill || pdf_font.force_fill() {
|
|
self.content
|
|
.set_text_rendering_mode(TextRenderingMode::Fill);
|
|
} else if fill_render_mode == TextRenderingMode::FillStroke {
|
|
self.content
|
|
.set_text_rendering_mode(TextRenderingMode::FillStroke);
|
|
} else {
|
|
self.content
|
|
.set_text_rendering_mode(TextRenderingMode::Stroke);
|
|
}
|
|
|
|
self.encode_consecutive_glyph_run(
|
|
sc,
|
|
cur_x,
|
|
*cur_y - glyph_group.y_offset * font_size,
|
|
glyph_group.font_identifier,
|
|
pdf_font,
|
|
font_size,
|
|
context_color,
|
|
glyph_group.glyphs,
|
|
text,
|
|
);
|
|
|
|
*cur_y -= glyph_group.y_advance * font_size;
|
|
}
|
|
|
|
pub(crate) fn draw_xobject(
|
|
&mut self,
|
|
sc: &mut SerializeContext,
|
|
chunk_container: &mut ChunkContainer,
|
|
x_object: XObject,
|
|
state: &ExtGState,
|
|
) {
|
|
let bbox = x_object.bbox();
|
|
self.apply_isolated_op(
|
|
|sb, _, _| {
|
|
sb.graphics_states.combine(state);
|
|
sb.expand_bbox(bbox);
|
|
},
|
|
move |sb, sc, chunk_container| {
|
|
let x_object_name = sb
|
|
.rd_builder
|
|
.register_resource(sc.register_resourceable(chunk_container, x_object));
|
|
sb.content.x_object(x_object_name.to_pdf_name());
|
|
},
|
|
sc,
|
|
chunk_container,
|
|
);
|
|
}
|
|
|
|
#[allow(dead_code)]
|
|
pub(crate) fn draw_xobject_by_reference(
|
|
&mut self,
|
|
sc: &mut SerializeContext,
|
|
chunk_container: &mut ChunkContainer,
|
|
bbox: Rect,
|
|
x_object: Ref,
|
|
) {
|
|
// TODO: Consider bbox of XObject somehow?
|
|
self.apply_isolated_op(
|
|
|sb, _, _| {
|
|
sb.expand_bbox(bbox);
|
|
},
|
|
move |sb, _, _| {
|
|
let x_object_name = sb
|
|
.rd_builder
|
|
.register_resource(resource::XObject::new(x_object));
|
|
sb.content.x_object(x_object_name.to_pdf_name());
|
|
},
|
|
sc,
|
|
chunk_container,
|
|
);
|
|
}
|
|
|
|
pub(crate) fn draw_masked(
|
|
&mut self,
|
|
sc: &mut SerializeContext,
|
|
chunk_container: &mut ChunkContainer,
|
|
mask: Mask,
|
|
stream: Stream,
|
|
) {
|
|
let state = ExtGState::new().mask(mask, sc, chunk_container);
|
|
self.uses_mask = true;
|
|
let x_object = XObject::new(stream, false, true, None);
|
|
self.draw_xobject(sc, chunk_container, x_object, &state);
|
|
}
|
|
|
|
pub(crate) fn draw_opacified(
|
|
&mut self,
|
|
sc: &mut SerializeContext,
|
|
chunk_container: &mut ChunkContainer,
|
|
opacity: NormalizedF32,
|
|
stream: Stream,
|
|
) {
|
|
let state = ExtGState::new()
|
|
.stroking_alpha(opacity)
|
|
.non_stroking_alpha(opacity);
|
|
let x_object = XObject::new(stream, true, false, None);
|
|
self.draw_xobject(sc, chunk_container, x_object, &state);
|
|
}
|
|
|
|
pub(crate) fn draw_group(
|
|
&mut self,
|
|
sc: &mut SerializeContext,
|
|
chunk_container: &mut ChunkContainer,
|
|
options: GroupOptions,
|
|
stream: Stream,
|
|
) {
|
|
let state = ExtGState::new();
|
|
let x_object = XObject::group(stream, options);
|
|
self.draw_xobject(sc, chunk_container, x_object, &state);
|
|
}
|
|
|
|
#[cfg(feature = "raster-images")]
|
|
pub(crate) fn draw_image(
|
|
&mut self,
|
|
image: Image,
|
|
size: Size,
|
|
sc: &mut SerializeContext,
|
|
chunk_container: &mut ChunkContainer,
|
|
) {
|
|
self.apply_isolated_op(
|
|
|sb, _, _| {
|
|
// Scale the image from 1x1 to the actual dimensions.
|
|
let transform =
|
|
Transform::from_row(size.width(), 0.0, 0.0, -size.height(), 0.0, size.height());
|
|
sb.concat_transform(&transform);
|
|
sb.expand_bbox(Rect::from_xywh(0.0, 0.0, 1.0, 1.0).unwrap());
|
|
},
|
|
move |sb, sc, chunk_container| {
|
|
let image_name = sb.rd_builder.register_resource(resource::XObject::new(
|
|
sc.register_image(chunk_container, image),
|
|
));
|
|
|
|
sb.content.x_object(image_name.to_pdf_name());
|
|
},
|
|
sc,
|
|
chunk_container,
|
|
);
|
|
}
|
|
|
|
pub(crate) fn draw_shading(
|
|
&mut self,
|
|
shading: &ShadingFunction,
|
|
sc: &mut SerializeContext,
|
|
chunk_container: &mut ChunkContainer,
|
|
) {
|
|
self.apply_isolated_op(
|
|
|_, _, _| {},
|
|
move |sb, sc, chunk_container| {
|
|
let sh = sb
|
|
.rd_builder
|
|
.register_resource(sc.register_resourceable(chunk_container, shading.clone()));
|
|
sb.content.shading(sh.to_pdf_name());
|
|
},
|
|
sc,
|
|
chunk_container,
|
|
)
|
|
}
|
|
|
|
fn set_fill_opacity(&mut self, alpha: NormalizedF32) {
|
|
if alpha.get() != 1.0 {
|
|
let state = ExtGState::new().non_stroking_alpha(alpha);
|
|
self.graphics_states.combine(&state);
|
|
}
|
|
}
|
|
|
|
fn set_stroke_opacity(&mut self, alpha: NormalizedF32) {
|
|
if alpha.get() != 1.0 {
|
|
let state = ExtGState::new().stroking_alpha(alpha);
|
|
self.graphics_states.combine(&state);
|
|
}
|
|
}
|
|
|
|
fn apply_isolated_op(
|
|
&mut self,
|
|
prep: impl FnOnce(&mut Self, &mut SerializeContext, &mut ChunkContainer),
|
|
op: impl FnOnce(&mut Self, &mut SerializeContext, &mut ChunkContainer),
|
|
sc: &mut SerializeContext,
|
|
chunk_container: &mut ChunkContainer,
|
|
) {
|
|
self.save_graphics_state();
|
|
self.content_save_state();
|
|
|
|
prep(self, sc, chunk_container);
|
|
|
|
let transform = self.cur_transform_with_root_transform();
|
|
|
|
if transform != Transform::identity() {
|
|
self.content.transform(transform.to_pdf_transform());
|
|
}
|
|
|
|
let state = self.graphics_states.cur().ext_g_state().clone();
|
|
|
|
if !state.empty() {
|
|
let ext = self.rd_builder.register_resource::<resource::ExtGState>(
|
|
sc.register_resourceable(chunk_container, state),
|
|
);
|
|
self.content.set_parameters(ext.to_pdf_name());
|
|
}
|
|
|
|
op(self, sc, chunk_container);
|
|
|
|
self.content.restore_state();
|
|
self.restore_graphics_state();
|
|
}
|
|
|
|
#[allow(clippy::too_many_arguments)]
|
|
fn content_set_fill_stroke_properties(
|
|
&mut self,
|
|
bounds: Rect,
|
|
paint: &Paint,
|
|
opacity: NormalizedF32,
|
|
sc: &mut SerializeContext,
|
|
chunk_container: &mut ChunkContainer,
|
|
mut set_pattern_fn: impl FnMut(&mut Content, String),
|
|
mut set_solid_fn: impl FnMut(&mut Content, ContentColorSpace, &Color),
|
|
) {
|
|
let pattern_transform = |transform: Transform| -> Transform {
|
|
transform.post_concat(self.cur_transform_with_root_transform())
|
|
};
|
|
|
|
let mut write_gradient =
|
|
|gradient_props: GradientProperties,
|
|
sc: &mut SerializeContext,
|
|
chunk_container: &mut ChunkContainer,
|
|
transform: Transform,
|
|
content_builder: &mut ContentBuilder| {
|
|
if let Some((color, opacity)) = gradient_props.single_stop_color() {
|
|
// Write gradients with one stop as a solid color fill.
|
|
content_builder.set_fill_opacity(opacity);
|
|
let cs = color.color_space(sc);
|
|
let color_space_resource =
|
|
Self::cs_to_content_cs(content_builder, sc, chunk_container, cs);
|
|
set_solid_fn(&mut content_builder.content, color_space_resource, color);
|
|
} else {
|
|
let shading_mask = Mask::new_from_shading(
|
|
gradient_props.clone(),
|
|
transform,
|
|
bounds,
|
|
sc,
|
|
chunk_container,
|
|
);
|
|
|
|
let shading_pattern = ShadingPattern::new(
|
|
gradient_props,
|
|
content_builder
|
|
.cur_transform_with_root_transform()
|
|
.pre_concat(transform),
|
|
);
|
|
let color_space = content_builder
|
|
.rd_builder
|
|
.register_resource::<resource::Pattern>(
|
|
sc.register_resourceable(chunk_container, shading_pattern),
|
|
);
|
|
|
|
if let Some(shading_mask) = shading_mask {
|
|
let state = ExtGState::new().mask(shading_mask, sc, chunk_container);
|
|
content_builder.uses_mask = true;
|
|
|
|
let ext = content_builder
|
|
.rd_builder
|
|
.register_resource::<resource::ExtGState>(
|
|
sc.register_resourceable(chunk_container, state),
|
|
);
|
|
content_builder.content.set_parameters(ext.to_pdf_name());
|
|
}
|
|
|
|
set_pattern_fn(&mut content_builder.content, color_space);
|
|
}
|
|
};
|
|
|
|
match &paint.0 {
|
|
InnerPaint::Color(c) => {
|
|
let cs = c.color_space(sc);
|
|
let color_space_resource = Self::cs_to_content_cs(self, sc, chunk_container, cs);
|
|
set_solid_fn(&mut self.content, color_space_resource, c);
|
|
}
|
|
InnerPaint::LinearGradient(lg) => {
|
|
let (gradient_props, transform) = lg.clone().gradient_properties(bounds);
|
|
write_gradient(gradient_props, sc, chunk_container, transform, self);
|
|
}
|
|
InnerPaint::RadialGradient(rg) => {
|
|
let (gradient_props, transform) = rg.clone().gradient_properties(bounds);
|
|
write_gradient(gradient_props, sc, chunk_container, transform, self);
|
|
}
|
|
InnerPaint::SweepGradient(sg) => {
|
|
let (gradient_props, transform) = sg.clone().gradient_properties(bounds);
|
|
write_gradient(gradient_props, sc, chunk_container, transform, self);
|
|
}
|
|
InnerPaint::MeshGradient(mg) => {
|
|
let transform = mg.transform;
|
|
write_gradient(
|
|
GradientProperties::MeshGradient(mg.clone()),
|
|
sc,
|
|
chunk_container,
|
|
transform,
|
|
self,
|
|
);
|
|
}
|
|
InnerPaint::Pattern(pat) => {
|
|
let mut pat = Arc::unwrap_or_clone(pat.clone());
|
|
pat.transform = pattern_transform(pat.transform);
|
|
|
|
let tiling_pattern = TilingPattern::new(
|
|
pat.stream,
|
|
pat.transform,
|
|
opacity,
|
|
pat.width,
|
|
pat.height,
|
|
sc,
|
|
chunk_container,
|
|
);
|
|
|
|
let color_space = self.rd_builder.register_resource::<resource::Pattern>(
|
|
sc.register_resourceable(chunk_container, tiling_pattern),
|
|
);
|
|
set_pattern_fn(&mut self.content, color_space);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn cs_to_content_cs(
|
|
content_builder: &mut ContentBuilder,
|
|
sc: &mut SerializeContext,
|
|
chunk_container: &mut ChunkContainer,
|
|
cs: ColorSpace,
|
|
) -> ContentColorSpace {
|
|
match sc.register_colorspace(chunk_container, cs) {
|
|
MaybeDeviceColorSpace::ColorSpace(s) => {
|
|
ContentColorSpace::Named(content_builder.rd_builder.register_resource(s))
|
|
}
|
|
MaybeDeviceColorSpace::DeviceGray => ContentColorSpace::Device,
|
|
MaybeDeviceColorSpace::DeviceRgb => ContentColorSpace::Device,
|
|
MaybeDeviceColorSpace::DeviceCMYK => ContentColorSpace::Device,
|
|
}
|
|
}
|
|
|
|
fn content_set_fill_properties(
|
|
&mut self,
|
|
bounds: Rect,
|
|
fill: &Fill,
|
|
serializer_context: &mut SerializeContext,
|
|
chunk_container: &mut ChunkContainer,
|
|
) {
|
|
fn set_pattern_fn(content: &mut Content, color_space: String) {
|
|
content.set_fill_color_space(pdf_writer::types::ColorSpaceOperand::Pattern);
|
|
content.set_fill_pattern(None, color_space.to_pdf_name());
|
|
}
|
|
|
|
fn set_solid_fn(content: &mut Content, color_space: ContentColorSpace, color: &Color) {
|
|
match color_space {
|
|
ContentColorSpace::Device => match color {
|
|
Color::Regular(crate::color::RegularColor::Rgb(r)) => {
|
|
let comps = r.to_pdf_color();
|
|
content.set_fill_rgb(comps[0], comps[1], comps[2]);
|
|
}
|
|
Color::Regular(crate::color::RegularColor::Luma(l)) => {
|
|
content.set_fill_gray(l.to_pdf_color());
|
|
}
|
|
Color::Regular(crate::color::RegularColor::Cmyk(c)) => {
|
|
let comps = c.to_pdf_color();
|
|
content.set_fill_cmyk(comps[0], comps[1], comps[2], comps[3]);
|
|
}
|
|
Color::Special(_) => {
|
|
panic!("Device color space cannot be used with special colors")
|
|
}
|
|
},
|
|
ContentColorSpace::Named(n) => {
|
|
content.set_fill_color_space(n.to_pdf_name());
|
|
content.set_fill_color(color.to_pdf_color());
|
|
}
|
|
}
|
|
}
|
|
|
|
self.content_set_fill_stroke_properties(
|
|
bounds,
|
|
&fill.paint,
|
|
fill.opacity,
|
|
serializer_context,
|
|
chunk_container,
|
|
set_pattern_fn,
|
|
set_solid_fn,
|
|
);
|
|
}
|
|
|
|
fn content_set_stroke_properties(
|
|
&mut self,
|
|
bounds: Rect,
|
|
stroke: &Stroke,
|
|
serializer_context: &mut SerializeContext,
|
|
chunk_container: &mut ChunkContainer,
|
|
) {
|
|
fn set_pattern_fn(content: &mut Content, color_space: String) {
|
|
content.set_stroke_color_space(pdf_writer::types::ColorSpaceOperand::Pattern);
|
|
content.set_stroke_pattern(None, color_space.to_pdf_name());
|
|
}
|
|
|
|
fn set_solid_fn(content: &mut Content, color_space: ContentColorSpace, color: &Color) {
|
|
match color_space {
|
|
ContentColorSpace::Device => match color {
|
|
Color::Regular(crate::color::RegularColor::Rgb(r)) => {
|
|
let comps = r.to_pdf_color();
|
|
content.set_stroke_rgb(comps[0], comps[1], comps[2]);
|
|
}
|
|
Color::Regular(crate::color::RegularColor::Luma(l)) => {
|
|
content.set_stroke_gray(l.to_pdf_color());
|
|
}
|
|
Color::Regular(crate::color::RegularColor::Cmyk(c)) => {
|
|
let comps = c.to_pdf_color();
|
|
content.set_stroke_cmyk(comps[0], comps[1], comps[2], comps[3]);
|
|
}
|
|
Color::Special(_) => {
|
|
panic!("Device color space cannot be used with special colors")
|
|
}
|
|
},
|
|
ContentColorSpace::Named(n) => {
|
|
content.set_stroke_color_space(n.to_pdf_name());
|
|
content.set_stroke_color(color.to_pdf_color());
|
|
}
|
|
}
|
|
}
|
|
|
|
self.content_set_fill_stroke_properties(
|
|
bounds,
|
|
&stroke.paint,
|
|
stroke.opacity,
|
|
serializer_context,
|
|
chunk_container,
|
|
set_pattern_fn,
|
|
set_solid_fn,
|
|
);
|
|
|
|
// Only write if they don't correspond to the default values as defined in the
|
|
// PDF specification.
|
|
if stroke.width != 1.0 {
|
|
self.content.set_line_width(stroke.width);
|
|
}
|
|
|
|
if stroke.miter_limit != 10.0 {
|
|
self.content.set_miter_limit(stroke.miter_limit);
|
|
}
|
|
|
|
if stroke.line_cap != LineCap::Butt {
|
|
self.content.set_line_cap(stroke.line_cap.to_pdf_line_cap());
|
|
}
|
|
|
|
if stroke.line_join != LineJoin::Miter {
|
|
self.content
|
|
.set_line_join(stroke.line_join.to_pdf_line_join());
|
|
}
|
|
|
|
if let Some(stroke_dash) = &stroke.dash {
|
|
self.content
|
|
.set_dash_pattern(stroke_dash.array.iter().copied(), stroke_dash.offset);
|
|
}
|
|
}
|
|
|
|
fn content_draw_path(&mut self, path_data: impl Iterator<Item = PathSegment>) {
|
|
// Taken from resvg
|
|
fn calc(n1: f32, n2: f32) -> f32 {
|
|
(n1 + n2 * 2.0) / 3.0
|
|
}
|
|
|
|
let mut p_prev = None;
|
|
|
|
for operation in path_data {
|
|
match operation {
|
|
PathSegment::MoveTo(p) => {
|
|
self.content.move_to(p.x, p.y);
|
|
p_prev = Some(p);
|
|
}
|
|
PathSegment::LineTo(p) => {
|
|
self.content.line_to(p.x, p.y);
|
|
p_prev = Some(p);
|
|
}
|
|
PathSegment::QuadTo(p1, p2) => {
|
|
// Since PDF doesn't support quad curves, we need to convert them into
|
|
// cubic.
|
|
let prev = p_prev.unwrap();
|
|
self.content.cubic_to(
|
|
calc(prev.x, p1.x),
|
|
calc(prev.y, p1.y),
|
|
calc(p2.x, p1.x),
|
|
calc(p2.y, p1.y),
|
|
p2.x,
|
|
p2.y,
|
|
);
|
|
p_prev = Some(p2);
|
|
}
|
|
PathSegment::CubicTo(p1, p2, p3) => {
|
|
self.content.cubic_to(p1.x, p1.y, p2.x, p2.y, p3.x, p3.y);
|
|
p_prev = Some(p3);
|
|
}
|
|
PathSegment::Close => {
|
|
self.content.close_path();
|
|
}
|
|
};
|
|
}
|
|
}
|
|
}
|
|
|
|
// Note that this isn't a 100% accurate calculation, it can overestimate (and in a few cases
|
|
// even underestimate), but it should be good enough for the majority of the cases.
|
|
// TODO: Improve this so that `zalgo_text` test case shows up fully in the reference image.
|
|
fn get_glyphs_bbox(glyphs: &[impl Glyph], x: f32, y: f32, size: f32, font: Font) -> Rect {
|
|
let font_bbox = font.bbox();
|
|
let (mut bl, mut bt, mut br, mut bb) = font_bbox
|
|
.transform(Transform::from_scale(
|
|
size / font.units_per_em(),
|
|
-size / font.units_per_em(),
|
|
))
|
|
.and_then(|b| b.transform(Transform::from_translate(x, y)))
|
|
.map(|b| (b.left(), b.top(), b.right(), b.bottom()))
|
|
.unwrap_or((x, y, x + 1.0, y + 1.0));
|
|
|
|
let mut x = x;
|
|
let mut y = y;
|
|
|
|
for glyph in glyphs {
|
|
let xo = glyph.x_offset(size);
|
|
let xa = glyph.x_advance(size);
|
|
let yo = glyph.y_offset(size);
|
|
let ya = glyph.y_advance(size);
|
|
|
|
x += xa;
|
|
y -= ya;
|
|
|
|
bl = bl.min(x + xo);
|
|
br = br.max(x + xo);
|
|
bt = bt.min(y - yo);
|
|
bb = bb.max(y - yo);
|
|
}
|
|
|
|
Rect::from_ltrb(bl, bt, br, bb).unwrap()
|
|
}
|