mirror of
https://github.com/typst/typst
synced 2025-07-11 14:42:53 +08:00
Rewrite foundations of native elements (#6547)
This commit is contained in:
parent
36ecbb2c8d
commit
0a3c6939dd
12
.github/workflows/ci.yml
vendored
12
.github/workflows/ci.yml
vendored
@ -103,3 +103,15 @@ jobs:
|
||||
- uses: Swatinem/rust-cache@v2
|
||||
- run: cargo install --locked cargo-fuzz@0.12.0
|
||||
- run: cd tests/fuzz && cargo fuzz build --dev
|
||||
|
||||
miri:
|
||||
name: Check unsafe code
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- uses: dtolnay/rust-toolchain@master
|
||||
with:
|
||||
components: miri
|
||||
toolchain: nightly-2024-10-29
|
||||
- uses: Swatinem/rust-cache@v2
|
||||
- run: cargo miri test -p typst-library test_miri
|
||||
|
@ -186,7 +186,7 @@ impl Eval for ast::Raw<'_> {
|
||||
let lines = self.lines().map(|line| (line.get().clone(), line.span())).collect();
|
||||
let mut elem = RawElem::new(RawContent::Lines(lines)).with_block(self.block());
|
||||
if let Some(lang) = self.lang() {
|
||||
elem.push_lang(Some(lang.get().clone()));
|
||||
elem.lang.set(Some(lang.get().clone()));
|
||||
}
|
||||
Ok(elem.pack())
|
||||
}
|
||||
@ -219,9 +219,8 @@ impl Eval for ast::Ref<'_> {
|
||||
.expect("unexpected empty reference");
|
||||
let mut elem = RefElem::new(target);
|
||||
if let Some(supplement) = self.supplement() {
|
||||
elem.push_supplement(Smart::Custom(Some(Supplement::Content(
|
||||
supplement.eval(vm)?,
|
||||
))));
|
||||
elem.supplement
|
||||
.set(Smart::Custom(Some(Supplement::Content(supplement.eval(vm)?))));
|
||||
}
|
||||
Ok(elem.pack())
|
||||
}
|
||||
@ -252,7 +251,7 @@ impl Eval for ast::EnumItem<'_> {
|
||||
let body = self.body().eval(vm)?;
|
||||
let mut elem = EnumItem::new(body);
|
||||
if let Some(number) = self.number() {
|
||||
elem.push_number(Some(number));
|
||||
elem.number.set(Some(number));
|
||||
}
|
||||
Ok(elem.pack())
|
||||
}
|
||||
|
@ -80,17 +80,17 @@ impl Eval for ast::MathAttach<'_> {
|
||||
let mut elem = AttachElem::new(base);
|
||||
|
||||
if let Some(expr) = self.top() {
|
||||
elem.push_t(Some(expr.eval_display(vm)?));
|
||||
elem.t.set(Some(expr.eval_display(vm)?));
|
||||
}
|
||||
|
||||
// Always attach primes in scripts style (not limits style),
|
||||
// i.e. at the top-right corner.
|
||||
if let Some(primes) = self.primes() {
|
||||
elem.push_tr(Some(primes.eval(vm)?));
|
||||
elem.tr.set(Some(primes.eval(vm)?));
|
||||
}
|
||||
|
||||
if let Some(expr) = self.bottom() {
|
||||
elem.push_b(Some(expr.eval_display(vm)?));
|
||||
elem.b.set(Some(expr.eval_display(vm)?));
|
||||
}
|
||||
|
||||
Ok(elem.pack())
|
||||
|
@ -1,6 +1,6 @@
|
||||
use typst_library::diag::{warning, At, SourceResult};
|
||||
use typst_library::foundations::{
|
||||
Element, Fields, Func, Recipe, Selector, ShowableSelector, Styles, Transformation,
|
||||
Element, Func, Recipe, Selector, ShowableSelector, Styles, Transformation,
|
||||
};
|
||||
use typst_library::layout::BlockElem;
|
||||
use typst_library::model::ParElem;
|
||||
@ -62,8 +62,7 @@ fn check_show_par_set_block(vm: &mut Vm, recipe: &Recipe) {
|
||||
if let Some(Selector::Elem(elem, _)) = recipe.selector();
|
||||
if *elem == Element::of::<ParElem>();
|
||||
if let Transformation::Style(styles) = recipe.transform();
|
||||
if styles.has::<BlockElem>(<BlockElem as Fields>::Enum::Above as _) ||
|
||||
styles.has::<BlockElem>(<BlockElem as Fields>::Enum::Below as _);
|
||||
if styles.has(BlockElem::above) || styles.has(BlockElem::below);
|
||||
then {
|
||||
vm.engine.sink.warn(warning!(
|
||||
recipe.span(),
|
||||
|
@ -177,12 +177,12 @@ fn handle(
|
||||
output.push(HtmlNode::Tag(elem.tag.clone()));
|
||||
} else if let Some(elem) = child.to_packed::<HtmlElem>() {
|
||||
let mut children = vec![];
|
||||
if let Some(body) = elem.body(styles) {
|
||||
if let Some(body) = elem.body.get_ref(styles) {
|
||||
children = html_fragment(engine, body, locator.next(&elem.span()), styles)?;
|
||||
}
|
||||
let element = HtmlElement {
|
||||
tag: elem.tag,
|
||||
attrs: elem.attrs(styles).clone(),
|
||||
attrs: elem.attrs.get_cloned(styles),
|
||||
children,
|
||||
span: elem.span(),
|
||||
};
|
||||
@ -198,7 +198,7 @@ fn handle(
|
||||
);
|
||||
} else if let Some(elem) = child.to_packed::<BoxElem>() {
|
||||
// TODO: This is rather incomplete.
|
||||
if let Some(body) = elem.body(styles) {
|
||||
if let Some(body) = elem.body.get_ref(styles) {
|
||||
let children =
|
||||
html_fragment(engine, body, locator.next(&elem.span()), styles)?;
|
||||
output.push(
|
||||
@ -212,7 +212,7 @@ fn handle(
|
||||
} else if let Some((elem, body)) =
|
||||
child
|
||||
.to_packed::<BlockElem>()
|
||||
.and_then(|elem| match elem.body(styles) {
|
||||
.and_then(|elem| match elem.body.get_ref(styles) {
|
||||
Some(BlockBody::Content(body)) => Some((elem, body)),
|
||||
_ => None,
|
||||
})
|
||||
@ -233,12 +233,12 @@ fn handle(
|
||||
output.push(HtmlElement::new(tag::br).spanned(elem.span()).into());
|
||||
} else if let Some(elem) = child.to_packed::<SmartQuoteElem>() {
|
||||
output.push(HtmlNode::text(
|
||||
if elem.double(styles) { '"' } else { '\'' },
|
||||
if elem.double.get(styles) { '"' } else { '\'' },
|
||||
child.span(),
|
||||
));
|
||||
} else if let Some(elem) = child.to_packed::<FrameElem>() {
|
||||
let locator = locator.next(&elem.span());
|
||||
let style = TargetElem::set_target(Target::Paged).wrap();
|
||||
let style = TargetElem::target.set(Target::Paged).wrap();
|
||||
let frame = (engine.routines.layout_frame)(
|
||||
engine,
|
||||
&elem.body,
|
||||
@ -248,7 +248,7 @@ fn handle(
|
||||
)?;
|
||||
output.push(HtmlNode::Frame(HtmlFrame {
|
||||
inner: frame,
|
||||
text_size: TextElem::size_in(styles),
|
||||
text_size: styles.resolve(TextElem::size),
|
||||
}));
|
||||
} else {
|
||||
engine.sink.warn(warning!(
|
||||
|
@ -187,6 +187,6 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_definition_std() {
|
||||
test("#table", 1, Side::After).must_be_value(typst::model::TableElem::elem());
|
||||
test("#table", 1, Side::After).must_be_value(typst::model::TableElem::ELEM);
|
||||
}
|
||||
}
|
||||
|
@ -171,13 +171,11 @@ fn library() -> Library {
|
||||
let mut lib = typst::Library::builder()
|
||||
.with_features([Feature::Html].into_iter().collect())
|
||||
.build();
|
||||
lib.styles.set(PageElem::width, Smart::Custom(Abs::pt(120.0).into()));
|
||||
lib.styles.set(PageElem::height, Smart::Auto);
|
||||
lib.styles
|
||||
.set(PageElem::set_width(Smart::Custom(Abs::pt(120.0).into())));
|
||||
lib.styles.set(PageElem::set_height(Smart::Auto));
|
||||
lib.styles.set(PageElem::set_margin(Margin::splat(Some(Smart::Custom(
|
||||
Abs::pt(10.0).into(),
|
||||
)))));
|
||||
lib.styles.set(TextElem::set_size(TextSize(Abs::pt(10.0).into())));
|
||||
.set(PageElem::margin, Margin::splat(Some(Smart::Custom(Abs::pt(10.0).into()))));
|
||||
lib.styles.set(TextElem::size, TextSize(Abs::pt(10.0).into()));
|
||||
lib
|
||||
}
|
||||
|
||||
|
@ -24,15 +24,15 @@ pub fn layout_single_block(
|
||||
region: Region,
|
||||
) -> SourceResult<Frame> {
|
||||
// Fetch sizing properties.
|
||||
let width = elem.width(styles);
|
||||
let height = elem.height(styles);
|
||||
let inset = elem.inset(styles).unwrap_or_default();
|
||||
let width = elem.width.get(styles);
|
||||
let height = elem.height.get(styles);
|
||||
let inset = elem.inset.resolve(styles).unwrap_or_default();
|
||||
|
||||
// Build the pod regions.
|
||||
let pod = unbreakable_pod(&width.into(), &height, &inset, styles, region.size);
|
||||
|
||||
// Layout the body.
|
||||
let body = elem.body(styles);
|
||||
let body = elem.body.get_ref(styles);
|
||||
let mut frame = match body {
|
||||
// If we have no body, just create one frame. Its size will be
|
||||
// adjusted below.
|
||||
@ -73,18 +73,19 @@ pub fn layout_single_block(
|
||||
}
|
||||
|
||||
// Prepare fill and stroke.
|
||||
let fill = elem.fill(styles);
|
||||
let fill = elem.fill.get_cloned(styles);
|
||||
let stroke = elem
|
||||
.stroke(styles)
|
||||
.stroke
|
||||
.resolve(styles)
|
||||
.unwrap_or_default()
|
||||
.map(|s| s.map(Stroke::unwrap_or_default));
|
||||
|
||||
// Only fetch these if necessary (for clipping or filling/stroking).
|
||||
let outset = LazyCell::new(|| elem.outset(styles).unwrap_or_default());
|
||||
let radius = LazyCell::new(|| elem.radius(styles).unwrap_or_default());
|
||||
let outset = LazyCell::new(|| elem.outset.resolve(styles).unwrap_or_default());
|
||||
let radius = LazyCell::new(|| elem.radius.resolve(styles).unwrap_or_default());
|
||||
|
||||
// Clip the contents, if requested.
|
||||
if elem.clip(styles) {
|
||||
if elem.clip.get(styles) {
|
||||
frame.clip(clip_rect(frame.size(), &radius, &stroke, &outset));
|
||||
}
|
||||
|
||||
@ -111,9 +112,9 @@ pub fn layout_multi_block(
|
||||
regions: Regions,
|
||||
) -> SourceResult<Fragment> {
|
||||
// Fetch sizing properties.
|
||||
let width = elem.width(styles);
|
||||
let height = elem.height(styles);
|
||||
let inset = elem.inset(styles).unwrap_or_default();
|
||||
let width = elem.width.get(styles);
|
||||
let height = elem.height.get(styles);
|
||||
let inset = elem.inset.resolve(styles).unwrap_or_default();
|
||||
|
||||
// Allocate a small vector for backlogs.
|
||||
let mut buf = SmallVec::<[Abs; 2]>::new();
|
||||
@ -122,7 +123,7 @@ pub fn layout_multi_block(
|
||||
let pod = breakable_pod(&width.into(), &height, &inset, styles, regions, &mut buf);
|
||||
|
||||
// Layout the body.
|
||||
let body = elem.body(styles);
|
||||
let body = elem.body.get_ref(styles);
|
||||
let mut fragment = match body {
|
||||
// If we have no body, just create one frame plus one per backlog
|
||||
// region. We create them zero-sized; if necessary, their size will
|
||||
@ -188,18 +189,19 @@ pub fn layout_multi_block(
|
||||
};
|
||||
|
||||
// Prepare fill and stroke.
|
||||
let fill = elem.fill(styles);
|
||||
let fill = elem.fill.get_ref(styles);
|
||||
let stroke = elem
|
||||
.stroke(styles)
|
||||
.stroke
|
||||
.resolve(styles)
|
||||
.unwrap_or_default()
|
||||
.map(|s| s.map(Stroke::unwrap_or_default));
|
||||
|
||||
// Only fetch these if necessary (for clipping or filling/stroking).
|
||||
let outset = LazyCell::new(|| elem.outset(styles).unwrap_or_default());
|
||||
let radius = LazyCell::new(|| elem.radius(styles).unwrap_or_default());
|
||||
let outset = LazyCell::new(|| elem.outset.resolve(styles).unwrap_or_default());
|
||||
let radius = LazyCell::new(|| elem.radius.resolve(styles).unwrap_or_default());
|
||||
|
||||
// Fetch/compute these outside of the loop.
|
||||
let clip = elem.clip(styles);
|
||||
let clip = elem.clip.get(styles);
|
||||
let has_fill_or_stroke = fill.is_some() || stroke.iter().any(Option::is_some);
|
||||
let has_inset = !inset.is_zero();
|
||||
let is_explicit = matches!(body, None | Some(BlockBody::Content(_)));
|
||||
|
@ -89,7 +89,7 @@ impl<'a> Collector<'a, '_, '_> {
|
||||
} else if child.is::<FlushElem>() {
|
||||
self.output.push(Child::Flush);
|
||||
} else if let Some(elem) = child.to_packed::<ColbreakElem>() {
|
||||
self.output.push(Child::Break(elem.weak(styles)));
|
||||
self.output.push(Child::Break(elem.weak.get(styles)));
|
||||
} else if child.is::<PagebreakElem>() {
|
||||
bail!(
|
||||
child.span(), "pagebreaks are not allowed inside of containers";
|
||||
@ -132,7 +132,7 @@ impl<'a> Collector<'a, '_, '_> {
|
||||
self.output.push(Child::Tag(&elem.tag));
|
||||
}
|
||||
|
||||
let leading = ParElem::leading_in(styles);
|
||||
let leading = styles.resolve(ParElem::leading);
|
||||
self.lines(lines, leading, styles);
|
||||
|
||||
for (c, _) in &self.children[end..] {
|
||||
@ -146,7 +146,9 @@ impl<'a> Collector<'a, '_, '_> {
|
||||
/// Collect vertical spacing into a relative or fractional child.
|
||||
fn v(&mut self, elem: &'a Packed<VElem>, styles: StyleChain<'a>) {
|
||||
self.output.push(match elem.amount {
|
||||
Spacing::Rel(rel) => Child::Rel(rel.resolve(styles), elem.weak(styles) as u8),
|
||||
Spacing::Rel(rel) => {
|
||||
Child::Rel(rel.resolve(styles), elem.weak.get(styles) as u8)
|
||||
}
|
||||
Spacing::Fr(fr) => Child::Fr(fr),
|
||||
});
|
||||
}
|
||||
@ -169,8 +171,8 @@ impl<'a> Collector<'a, '_, '_> {
|
||||
)?
|
||||
.into_frames();
|
||||
|
||||
let spacing = elem.spacing(styles);
|
||||
let leading = elem.leading(styles);
|
||||
let spacing = elem.spacing.resolve(styles);
|
||||
let leading = elem.leading.resolve(styles);
|
||||
|
||||
self.output.push(Child::Rel(spacing.into(), 4));
|
||||
|
||||
@ -184,8 +186,8 @@ impl<'a> Collector<'a, '_, '_> {
|
||||
|
||||
/// Collect laid-out lines.
|
||||
fn lines(&mut self, lines: Vec<Frame>, leading: Abs, styles: StyleChain<'a>) {
|
||||
let align = AlignElem::alignment_in(styles).resolve(styles);
|
||||
let costs = TextElem::costs_in(styles);
|
||||
let align = styles.resolve(AlignElem::alignment);
|
||||
let costs = styles.get(TextElem::costs);
|
||||
|
||||
// Determine whether to prevent widow and orphans.
|
||||
let len = lines.len();
|
||||
@ -231,23 +233,23 @@ impl<'a> Collector<'a, '_, '_> {
|
||||
/// whether it is breakable.
|
||||
fn block(&mut self, elem: &'a Packed<BlockElem>, styles: StyleChain<'a>) {
|
||||
let locator = self.locator.next(&elem.span());
|
||||
let align = AlignElem::alignment_in(styles).resolve(styles);
|
||||
let align = styles.resolve(AlignElem::alignment);
|
||||
let alone = self.children.len() == 1;
|
||||
let sticky = elem.sticky(styles);
|
||||
let breakable = elem.breakable(styles);
|
||||
let fr = match elem.height(styles) {
|
||||
let sticky = elem.sticky.get(styles);
|
||||
let breakable = elem.breakable.get(styles);
|
||||
let fr = match elem.height.get(styles) {
|
||||
Sizing::Fr(fr) => Some(fr),
|
||||
_ => None,
|
||||
};
|
||||
|
||||
let fallback = LazyCell::new(|| ParElem::spacing_in(styles));
|
||||
let fallback = LazyCell::new(|| styles.resolve(ParElem::spacing));
|
||||
let spacing = |amount| match amount {
|
||||
Smart::Auto => Child::Rel((*fallback).into(), 4),
|
||||
Smart::Custom(Spacing::Rel(rel)) => Child::Rel(rel.resolve(styles), 3),
|
||||
Smart::Custom(Spacing::Fr(fr)) => Child::Fr(fr),
|
||||
};
|
||||
|
||||
self.output.push(spacing(elem.above(styles)));
|
||||
self.output.push(spacing(elem.above.get(styles)));
|
||||
|
||||
if !breakable || fr.is_some() {
|
||||
self.output.push(Child::Single(self.boxed(SingleChild {
|
||||
@ -272,7 +274,7 @@ impl<'a> Collector<'a, '_, '_> {
|
||||
})));
|
||||
};
|
||||
|
||||
self.output.push(spacing(elem.below(styles)));
|
||||
self.output.push(spacing(elem.below.get(styles)));
|
||||
self.par_situation = ParSituation::Other;
|
||||
}
|
||||
|
||||
@ -282,13 +284,13 @@ impl<'a> Collector<'a, '_, '_> {
|
||||
elem: &'a Packed<PlaceElem>,
|
||||
styles: StyleChain<'a>,
|
||||
) -> SourceResult<()> {
|
||||
let alignment = elem.alignment(styles);
|
||||
let alignment = elem.alignment.get(styles);
|
||||
let align_x = alignment.map_or(FixedAlignment::Center, |align| {
|
||||
align.x().unwrap_or_default().resolve(styles)
|
||||
});
|
||||
let align_y = alignment.map(|align| align.y().map(|y| y.resolve(styles)));
|
||||
let scope = elem.scope(styles);
|
||||
let float = elem.float(styles);
|
||||
let scope = elem.scope.get(styles);
|
||||
let float = elem.float.get(styles);
|
||||
|
||||
match (float, align_y) {
|
||||
(true, Smart::Custom(None | Some(FixedAlignment::Center))) => bail!(
|
||||
@ -312,8 +314,8 @@ impl<'a> Collector<'a, '_, '_> {
|
||||
}
|
||||
|
||||
let locator = self.locator.next(&elem.span());
|
||||
let clearance = elem.clearance(styles);
|
||||
let delta = Axes::new(elem.dx(styles), elem.dy(styles)).resolve(styles);
|
||||
let clearance = elem.clearance.resolve(styles);
|
||||
let delta = Axes::new(elem.dx.get(styles), elem.dy.get(styles)).resolve(styles);
|
||||
self.output.push(Child::Placed(self.boxed(PlacedChild {
|
||||
align_x,
|
||||
align_y,
|
||||
@ -631,7 +633,7 @@ impl PlacedChild<'_> {
|
||||
pub fn layout(&self, engine: &mut Engine, base: Size) -> SourceResult<Frame> {
|
||||
self.cell.get_or_init(base, |base| {
|
||||
let align = self.alignment.unwrap_or_else(|| Alignment::CENTER);
|
||||
let aligned = AlignElem::set_alignment(align).wrap();
|
||||
let aligned = AlignElem::alignment.set(align).wrap();
|
||||
let styles = self.styles.chain(&aligned);
|
||||
|
||||
let mut frame = layout_and_modify(styles, |styles| {
|
||||
|
@ -851,7 +851,7 @@ fn layout_line_number_reset(
|
||||
config: &Config,
|
||||
locator: &mut SplitLocator,
|
||||
) -> SourceResult<Frame> {
|
||||
let counter = Counter::of(ParLineMarker::elem());
|
||||
let counter = Counter::of(ParLineMarker::ELEM);
|
||||
let update = CounterUpdate::Set(CounterState::init(false));
|
||||
let content = counter.update(Span::detached(), update);
|
||||
crate::layout_frame(
|
||||
@ -879,7 +879,7 @@ fn layout_line_number(
|
||||
locator: &mut SplitLocator,
|
||||
numbering: &Numbering,
|
||||
) -> SourceResult<Frame> {
|
||||
let counter = Counter::of(ParLineMarker::elem());
|
||||
let counter = Counter::of(ParLineMarker::ELEM);
|
||||
let update = CounterUpdate::Step(NonZeroUsize::ONE);
|
||||
let numbering = Smart::Custom(numbering.clone());
|
||||
|
||||
|
@ -98,8 +98,8 @@ pub fn layout_columns(
|
||||
locator.track(),
|
||||
styles,
|
||||
regions,
|
||||
elem.count(styles),
|
||||
elem.gutter(styles),
|
||||
elem.count.get(styles),
|
||||
elem.gutter.resolve(styles),
|
||||
)
|
||||
}
|
||||
|
||||
@ -251,22 +251,22 @@ fn configuration<'x>(
|
||||
|
||||
let gutter = column_gutter.relative_to(regions.base().x);
|
||||
let width = (regions.size.x - gutter * (count - 1) as f64) / count as f64;
|
||||
let dir = TextElem::dir_in(shared);
|
||||
let dir = shared.resolve(TextElem::dir);
|
||||
ColumnConfig { count, width, gutter, dir }
|
||||
},
|
||||
footnote: FootnoteConfig {
|
||||
separator: FootnoteEntry::separator_in(shared),
|
||||
clearance: FootnoteEntry::clearance_in(shared),
|
||||
gap: FootnoteEntry::gap_in(shared),
|
||||
separator: shared.get_cloned(FootnoteEntry::separator),
|
||||
clearance: shared.resolve(FootnoteEntry::clearance),
|
||||
gap: shared.resolve(FootnoteEntry::gap),
|
||||
expand: regions.expand.x,
|
||||
},
|
||||
line_numbers: (mode == FlowMode::Root).then(|| LineNumberConfig {
|
||||
scope: ParLine::numbering_scope_in(shared),
|
||||
scope: shared.get(ParLine::numbering_scope),
|
||||
default_clearance: {
|
||||
let width = if PageElem::flipped_in(shared) {
|
||||
PageElem::height_in(shared)
|
||||
let width = if shared.get(PageElem::flipped) {
|
||||
shared.resolve(PageElem::height)
|
||||
} else {
|
||||
PageElem::width_in(shared)
|
||||
shared.resolve(PageElem::width)
|
||||
};
|
||||
|
||||
// Clamp below is safe (min <= max): if the font size is
|
||||
|
@ -249,7 +249,7 @@ impl<'a> GridLayouter<'a> {
|
||||
rowspans: vec![],
|
||||
finished: vec![],
|
||||
finished_header_rows: vec![],
|
||||
is_rtl: TextElem::dir_in(styles) == Dir::RTL,
|
||||
is_rtl: styles.resolve(TextElem::dir) == Dir::RTL,
|
||||
repeating_headers: vec![],
|
||||
upcoming_headers: &grid.headers,
|
||||
pending_headers: Default::default(),
|
||||
|
@ -28,7 +28,7 @@ pub fn layout_image(
|
||||
// Take the format that was explicitly defined, or parse the extension,
|
||||
// or try to detect the format.
|
||||
let Derived { source, derived: loaded } = &elem.source;
|
||||
let format = match elem.format(styles) {
|
||||
let format = match elem.format.get(styles) {
|
||||
Smart::Custom(v) => v,
|
||||
Smart::Auto => determine_format(source, &loaded.data).at(span)?,
|
||||
};
|
||||
@ -55,7 +55,7 @@ pub fn layout_image(
|
||||
RasterImage::new(
|
||||
loaded.data.clone(),
|
||||
format,
|
||||
elem.icc(styles).as_ref().map(|icc| icc.derived.clone()),
|
||||
elem.icc.get_ref(styles).as_ref().map(|icc| icc.derived.clone()),
|
||||
)
|
||||
.at(span)?,
|
||||
),
|
||||
@ -69,7 +69,7 @@ pub fn layout_image(
|
||||
),
|
||||
};
|
||||
|
||||
let image = Image::new(kind, elem.alt(styles), elem.scaling(styles));
|
||||
let image = Image::new(kind, elem.alt.get_cloned(styles), elem.scaling.get(styles));
|
||||
|
||||
// Determine the image's pixel aspect ratio.
|
||||
let pxw = image.width();
|
||||
@ -106,7 +106,7 @@ pub fn layout_image(
|
||||
};
|
||||
|
||||
// Compute the actual size of the fitted image.
|
||||
let fit = elem.fit(styles);
|
||||
let fit = elem.fit.get(styles);
|
||||
let fitted = match fit {
|
||||
ImageFit::Cover | ImageFit::Contain => {
|
||||
if wide == (fit == ImageFit::Contain) {
|
||||
|
@ -21,15 +21,15 @@ pub fn layout_box(
|
||||
region: Size,
|
||||
) -> SourceResult<Frame> {
|
||||
// Fetch sizing properties.
|
||||
let width = elem.width(styles);
|
||||
let height = elem.height(styles);
|
||||
let inset = elem.inset(styles).unwrap_or_default();
|
||||
let width = elem.width.get(styles);
|
||||
let height = elem.height.get(styles);
|
||||
let inset = elem.inset.resolve(styles).unwrap_or_default();
|
||||
|
||||
// Build the pod region.
|
||||
let pod = unbreakable_pod(&width, &height.into(), &inset, styles, region);
|
||||
|
||||
// Layout the body.
|
||||
let mut frame = match elem.body(styles) {
|
||||
let mut frame = match elem.body.get_ref(styles) {
|
||||
// If we have no body, just create an empty frame. If necessary,
|
||||
// its size will be adjusted below.
|
||||
None => Frame::hard(Size::zero()),
|
||||
@ -50,18 +50,19 @@ pub fn layout_box(
|
||||
}
|
||||
|
||||
// Prepare fill and stroke.
|
||||
let fill = elem.fill(styles);
|
||||
let fill = elem.fill.get_cloned(styles);
|
||||
let stroke = elem
|
||||
.stroke(styles)
|
||||
.stroke
|
||||
.resolve(styles)
|
||||
.unwrap_or_default()
|
||||
.map(|s| s.map(Stroke::unwrap_or_default));
|
||||
|
||||
// Only fetch these if necessary (for clipping or filling/stroking).
|
||||
let outset = LazyCell::new(|| elem.outset(styles).unwrap_or_default());
|
||||
let radius = LazyCell::new(|| elem.radius(styles).unwrap_or_default());
|
||||
let outset = LazyCell::new(|| elem.outset.resolve(styles).unwrap_or_default());
|
||||
let radius = LazyCell::new(|| elem.radius.resolve(styles).unwrap_or_default());
|
||||
|
||||
// Clip the contents, if requested.
|
||||
if elem.clip(styles) {
|
||||
if elem.clip.get(styles) {
|
||||
frame.clip(clip_rect(frame.size(), &radius, &stroke, &outset));
|
||||
}
|
||||
|
||||
@ -78,7 +79,7 @@ pub fn layout_box(
|
||||
// Apply baseline shift. Do this after setting the size and applying the
|
||||
// inset, so that a relative shift is resolved relative to the final
|
||||
// height.
|
||||
let shift = elem.baseline(styles).relative_to(frame.height());
|
||||
let shift = elem.baseline.resolve(styles).relative_to(frame.height());
|
||||
if !shift.is_zero() {
|
||||
frame.set_baseline(frame.baseline() - shift);
|
||||
}
|
||||
|
@ -144,7 +144,7 @@ pub fn collect<'a>(
|
||||
collector.push_text(" ", styles);
|
||||
} else if let Some(elem) = child.to_packed::<TextElem>() {
|
||||
collector.build_text(styles, |full| {
|
||||
let dir = TextElem::dir_in(styles);
|
||||
let dir = styles.resolve(TextElem::dir);
|
||||
if dir != config.dir {
|
||||
// Insert "Explicit Directional Embedding".
|
||||
match dir {
|
||||
@ -154,7 +154,7 @@ pub fn collect<'a>(
|
||||
}
|
||||
}
|
||||
|
||||
if let Some(case) = TextElem::case_in(styles) {
|
||||
if let Some(case) = styles.get(TextElem::case) {
|
||||
full.push_str(&case.apply(&elem.text));
|
||||
} else {
|
||||
full.push_str(&elem.text);
|
||||
@ -174,20 +174,22 @@ pub fn collect<'a>(
|
||||
Spacing::Fr(fr) => Item::Fractional(fr, None),
|
||||
Spacing::Rel(rel) => Item::Absolute(
|
||||
rel.resolve(styles).relative_to(region.x),
|
||||
elem.weak(styles),
|
||||
elem.weak.get(styles),
|
||||
),
|
||||
});
|
||||
} else if let Some(elem) = child.to_packed::<LinebreakElem>() {
|
||||
collector
|
||||
.push_text(if elem.justify(styles) { "\u{2028}" } else { "\n" }, styles);
|
||||
collector.push_text(
|
||||
if elem.justify.get(styles) { "\u{2028}" } else { "\n" },
|
||||
styles,
|
||||
);
|
||||
} else if let Some(elem) = child.to_packed::<SmartQuoteElem>() {
|
||||
let double = elem.double(styles);
|
||||
if elem.enabled(styles) {
|
||||
let double = elem.double.get(styles);
|
||||
if elem.enabled.get(styles) {
|
||||
let quotes = SmartQuotes::get(
|
||||
elem.quotes(styles),
|
||||
TextElem::lang_in(styles),
|
||||
TextElem::region_in(styles),
|
||||
elem.alternative(styles),
|
||||
elem.quotes.get_ref(styles),
|
||||
styles.get(TextElem::lang),
|
||||
styles.get(TextElem::region),
|
||||
elem.alternative.get(styles),
|
||||
);
|
||||
let before =
|
||||
collector.full.chars().rev().find(|&c| !is_default_ignorable(c));
|
||||
@ -215,7 +217,7 @@ pub fn collect<'a>(
|
||||
collector.push_item(Item::Skip(POP_ISOLATE));
|
||||
} else if let Some(elem) = child.to_packed::<BoxElem>() {
|
||||
let loc = locator.next(&elem.span());
|
||||
if let Sizing::Fr(v) = elem.width(styles) {
|
||||
if let Sizing::Fr(v) = elem.width.get(styles) {
|
||||
collector.push_item(Item::Fractional(v, Some((elem, loc, styles))));
|
||||
} else {
|
||||
let mut frame = layout_and_modify(styles, |styles| {
|
||||
|
@ -2,6 +2,7 @@ use std::fmt::{self, Debug, Formatter};
|
||||
use std::ops::{Deref, DerefMut};
|
||||
|
||||
use typst_library::engine::Engine;
|
||||
use typst_library::foundations::Resolve;
|
||||
use typst_library::introspection::{SplitLocator, Tag};
|
||||
use typst_library::layout::{Abs, Dir, Em, Fr, Frame, FrameItem, Point};
|
||||
use typst_library::model::ParLineMarker;
|
||||
@ -418,10 +419,11 @@ pub fn apply_shift<'a>(
|
||||
frame: &mut Frame,
|
||||
styles: StyleChain,
|
||||
) {
|
||||
let mut baseline = TextElem::baseline_in(styles);
|
||||
let mut baseline = styles.resolve(TextElem::baseline);
|
||||
let mut compensation = Abs::zero();
|
||||
if let Some(scripts) = TextElem::shift_settings_in(styles) {
|
||||
let font_metrics = TextElem::font_in(styles)
|
||||
if let Some(scripts) = styles.get_ref(TextElem::shift_settings) {
|
||||
let font_metrics = styles
|
||||
.get_ref(TextElem::font)
|
||||
.into_iter()
|
||||
.find_map(|family| {
|
||||
world
|
||||
@ -462,7 +464,7 @@ pub fn commit(
|
||||
if let Some(Item::Text(text)) = line.items.first() {
|
||||
if let Some(glyph) = text.glyphs.first() {
|
||||
if !text.dir.is_positive()
|
||||
&& TextElem::overhang_in(text.styles)
|
||||
&& text.styles.get(TextElem::overhang)
|
||||
&& (line.items.len() > 1 || text.glyphs.len() > 1)
|
||||
{
|
||||
let amount = overhang(glyph.c) * glyph.x_advance.at(glyph.size);
|
||||
@ -476,7 +478,7 @@ pub fn commit(
|
||||
if let Some(Item::Text(text)) = line.items.last() {
|
||||
if let Some(glyph) = text.glyphs.last() {
|
||||
if text.dir.is_positive()
|
||||
&& TextElem::overhang_in(text.styles)
|
||||
&& text.styles.get(TextElem::overhang)
|
||||
&& (line.items.len() > 1 || text.glyphs.len() > 1)
|
||||
{
|
||||
let amount = overhang(glyph.c) * glyph.x_advance.at(glyph.size);
|
||||
|
@ -846,7 +846,9 @@ fn hyphenate_at(p: &Preparation, offset: usize) -> bool {
|
||||
p.config.hyphenate.unwrap_or_else(|| {
|
||||
let (_, item) = p.get(offset);
|
||||
match item.text() {
|
||||
Some(text) => TextElem::hyphenate_in(text.styles).unwrap_or(p.config.justify),
|
||||
Some(text) => {
|
||||
text.styles.get(TextElem::hyphenate).unwrap_or(p.config.justify)
|
||||
}
|
||||
None => false,
|
||||
}
|
||||
})
|
||||
@ -857,7 +859,7 @@ fn lang_at(p: &Preparation, offset: usize) -> Option<hypher::Lang> {
|
||||
let lang = p.config.lang.or_else(|| {
|
||||
let (_, item) = p.get(offset);
|
||||
let styles = item.text()?.styles;
|
||||
Some(TextElem::lang_in(styles))
|
||||
Some(styles.get(TextElem::lang))
|
||||
})?;
|
||||
|
||||
let bytes = lang.as_str().as_bytes().try_into().ok()?;
|
||||
|
@ -14,7 +14,7 @@ pub use self::shaping::create_shape_plan;
|
||||
use comemo::{Track, Tracked, TrackedMut};
|
||||
use typst_library::diag::SourceResult;
|
||||
use typst_library::engine::{Engine, Route, Sink, Traced};
|
||||
use typst_library::foundations::{Packed, Resolve, Smart, StyleChain};
|
||||
use typst_library::foundations::{Packed, Smart, StyleChain};
|
||||
use typst_library::introspection::{Introspector, Locator, LocatorLink, SplitLocator};
|
||||
use typst_library::layout::{Abs, AlignElem, Dir, FixedAlignment, Fragment, Size};
|
||||
use typst_library::model::{
|
||||
@ -113,10 +113,10 @@ fn layout_par_impl(
|
||||
expand,
|
||||
Some(situation),
|
||||
&ConfigBase {
|
||||
justify: elem.justify(styles),
|
||||
linebreaks: elem.linebreaks(styles),
|
||||
first_line_indent: elem.first_line_indent(styles),
|
||||
hanging_indent: elem.hanging_indent(styles),
|
||||
justify: elem.justify.get(styles),
|
||||
linebreaks: elem.linebreaks.get(styles),
|
||||
first_line_indent: elem.first_line_indent.get(styles),
|
||||
hanging_indent: elem.hanging_indent.resolve(styles),
|
||||
},
|
||||
)
|
||||
}
|
||||
@ -139,10 +139,10 @@ pub fn layout_inline<'a>(
|
||||
expand,
|
||||
None,
|
||||
&ConfigBase {
|
||||
justify: ParElem::justify_in(shared),
|
||||
linebreaks: ParElem::linebreaks_in(shared),
|
||||
first_line_indent: ParElem::first_line_indent_in(shared),
|
||||
hanging_indent: ParElem::hanging_indent_in(shared),
|
||||
justify: shared.get(ParElem::justify),
|
||||
linebreaks: shared.get(ParElem::linebreaks),
|
||||
first_line_indent: shared.get(ParElem::first_line_indent),
|
||||
hanging_indent: shared.resolve(ParElem::hanging_indent),
|
||||
},
|
||||
)
|
||||
}
|
||||
@ -184,8 +184,8 @@ fn configuration(
|
||||
situation: Option<ParSituation>,
|
||||
) -> Config {
|
||||
let justify = base.justify;
|
||||
let font_size = TextElem::size_in(shared);
|
||||
let dir = TextElem::dir_in(shared);
|
||||
let font_size = shared.resolve(TextElem::size);
|
||||
let dir = shared.resolve(TextElem::dir);
|
||||
|
||||
Config {
|
||||
justify,
|
||||
@ -207,7 +207,7 @@ fn configuration(
|
||||
Some(ParSituation::Other) => all,
|
||||
None => false,
|
||||
}
|
||||
&& AlignElem::alignment_in(shared).resolve(shared).x == dir.start().into()
|
||||
&& shared.resolve(AlignElem::alignment).x == dir.start().into()
|
||||
{
|
||||
amount.at(font_size)
|
||||
} else {
|
||||
@ -219,26 +219,26 @@ fn configuration(
|
||||
} else {
|
||||
Abs::zero()
|
||||
},
|
||||
numbering_marker: ParLine::numbering_in(shared).map(|numbering| {
|
||||
numbering_marker: shared.get_cloned(ParLine::numbering).map(|numbering| {
|
||||
Packed::new(ParLineMarker::new(
|
||||
numbering,
|
||||
ParLine::number_align_in(shared),
|
||||
ParLine::number_margin_in(shared),
|
||||
shared.get(ParLine::number_align),
|
||||
shared.get(ParLine::number_margin),
|
||||
// Delay resolving the number clearance until line numbers are
|
||||
// laid out to avoid inconsistent spacing depending on varying
|
||||
// font size.
|
||||
ParLine::number_clearance_in(shared),
|
||||
shared.get(ParLine::number_clearance),
|
||||
))
|
||||
}),
|
||||
align: AlignElem::alignment_in(shared).fix(dir).x,
|
||||
align: shared.get(AlignElem::alignment).fix(dir).x,
|
||||
font_size,
|
||||
dir,
|
||||
hyphenate: shared_get(children, shared, TextElem::hyphenate_in)
|
||||
hyphenate: shared_get(children, shared, |s| s.get(TextElem::hyphenate))
|
||||
.map(|uniform| uniform.unwrap_or(justify)),
|
||||
lang: shared_get(children, shared, TextElem::lang_in),
|
||||
fallback: TextElem::fallback_in(shared),
|
||||
cjk_latin_spacing: TextElem::cjk_latin_spacing_in(shared).is_auto(),
|
||||
costs: TextElem::costs_in(shared),
|
||||
lang: shared_get(children, shared, |s| s.get(TextElem::lang)),
|
||||
fallback: shared.get(TextElem::fallback),
|
||||
cjk_latin_spacing: shared.get(TextElem::cjk_latin_spacing).is_auto(),
|
||||
costs: shared.get(TextElem::costs),
|
||||
}
|
||||
}
|
||||
|
||||
@ -314,7 +314,7 @@ fn shared_get<T: PartialEq>(
|
||||
/// When we support some kind of more general ancestry mechanism, this can
|
||||
/// become more elegant.
|
||||
fn in_list(styles: StyleChain) -> bool {
|
||||
ListElem::depth_in(styles).0 > 0
|
||||
|| !EnumElem::parents_in(styles).is_empty()
|
||||
|| TermsElem::within_in(styles)
|
||||
styles.get(ListElem::depth).0 > 0
|
||||
|| !styles.get_cloned(EnumElem::parents).is_empty()
|
||||
|| styles.get(TermsElem::within)
|
||||
}
|
||||
|
@ -223,12 +223,12 @@ impl<'a> ShapedText<'a> {
|
||||
let mut frame = Frame::soft(size);
|
||||
frame.set_baseline(top);
|
||||
|
||||
let size = TextElem::size_in(self.styles);
|
||||
let shift = TextElem::baseline_in(self.styles);
|
||||
let decos = TextElem::deco_in(self.styles);
|
||||
let fill = TextElem::fill_in(self.styles);
|
||||
let stroke = TextElem::stroke_in(self.styles);
|
||||
let span_offset = TextElem::span_offset_in(self.styles);
|
||||
let size = self.styles.resolve(TextElem::size);
|
||||
let shift = self.styles.resolve(TextElem::baseline);
|
||||
let decos = self.styles.get_cloned(TextElem::deco);
|
||||
let fill = self.styles.get_ref(TextElem::fill);
|
||||
let stroke = self.styles.resolve(TextElem::stroke);
|
||||
let span_offset = self.styles.get(TextElem::span_offset);
|
||||
|
||||
for ((font, y_offset, glyph_size), group) in self
|
||||
.glyphs
|
||||
@ -340,9 +340,9 @@ impl<'a> ShapedText<'a> {
|
||||
let mut top = Abs::zero();
|
||||
let mut bottom = Abs::zero();
|
||||
|
||||
let size = TextElem::size_in(self.styles);
|
||||
let top_edge = TextElem::top_edge_in(self.styles);
|
||||
let bottom_edge = TextElem::bottom_edge_in(self.styles);
|
||||
let size = self.styles.resolve(TextElem::size);
|
||||
let top_edge = self.styles.get(TextElem::top_edge);
|
||||
let bottom_edge = self.styles.get(TextElem::bottom_edge);
|
||||
|
||||
// Expand top and bottom by reading the font's vertical metrics.
|
||||
let mut expand = |font: &Font, bounds: TextEdgeBounds| {
|
||||
@ -486,7 +486,7 @@ impl<'a> ShapedText<'a> {
|
||||
// that subtracting either of the endpoints by self.base doesn't
|
||||
// underflow. See <https://github.com/typst/typst/issues/2283>.
|
||||
.unwrap_or_else(|| self.base..self.base);
|
||||
let size = TextElem::size_in(self.styles);
|
||||
let size = self.styles.resolve(TextElem::size);
|
||||
self.width += x_advance.at(size);
|
||||
let glyph = ShapedGlyph {
|
||||
font,
|
||||
@ -603,9 +603,9 @@ pub fn shape_range<'a>(
|
||||
range: Range,
|
||||
styles: StyleChain<'a>,
|
||||
) {
|
||||
let script = TextElem::script_in(styles);
|
||||
let lang = TextElem::lang_in(styles);
|
||||
let region = TextElem::region_in(styles);
|
||||
let script = styles.get(TextElem::script);
|
||||
let lang = styles.get(TextElem::lang);
|
||||
let region = styles.get(TextElem::region);
|
||||
let mut process = |range: Range, level: BidiLevel| {
|
||||
let dir = if level.is_ltr() { Dir::LTR } else { Dir::RTL };
|
||||
let shaped =
|
||||
@ -669,8 +669,8 @@ fn shape<'a>(
|
||||
lang: Lang,
|
||||
region: Option<Region>,
|
||||
) -> ShapedText<'a> {
|
||||
let size = TextElem::size_in(styles);
|
||||
let shift_settings = TextElem::shift_settings_in(styles);
|
||||
let size = styles.resolve(TextElem::size);
|
||||
let shift_settings = styles.get(TextElem::shift_settings);
|
||||
let mut ctx = ShapingContext {
|
||||
engine,
|
||||
size,
|
||||
@ -679,7 +679,7 @@ fn shape<'a>(
|
||||
styles,
|
||||
variant: variant(styles),
|
||||
features: features(styles),
|
||||
fallback: TextElem::fallback_in(styles),
|
||||
fallback: styles.get(TextElem::fallback),
|
||||
dir,
|
||||
shift_settings,
|
||||
};
|
||||
@ -783,7 +783,7 @@ fn shape_segment<'a>(
|
||||
let mut buffer = UnicodeBuffer::new();
|
||||
buffer.push_str(text);
|
||||
buffer.set_language(language(ctx.styles));
|
||||
if let Some(script) = TextElem::script_in(ctx.styles).custom().and_then(|script| {
|
||||
if let Some(script) = ctx.styles.get(TextElem::script).custom().and_then(|script| {
|
||||
rustybuzz::Script::from_iso15924_tag(Tag::from_bytes(script.as_bytes()))
|
||||
}) {
|
||||
buffer.set_script(script)
|
||||
@ -1073,8 +1073,11 @@ fn shape_tofus(ctx: &mut ShapingContext, base: usize, text: &str, font: Font) {
|
||||
|
||||
/// Apply tracking and spacing to the shaped glyphs.
|
||||
fn track_and_space(ctx: &mut ShapingContext) {
|
||||
let tracking = Em::from_abs(TextElem::tracking_in(ctx.styles), ctx.size);
|
||||
let spacing = TextElem::spacing_in(ctx.styles).map(|abs| Em::from_abs(abs, ctx.size));
|
||||
let tracking = Em::from_abs(ctx.styles.resolve(TextElem::tracking), ctx.size);
|
||||
let spacing = ctx
|
||||
.styles
|
||||
.resolve(TextElem::spacing)
|
||||
.map(|abs| Em::from_abs(abs, ctx.size));
|
||||
|
||||
let mut glyphs = ctx.glyphs.iter_mut().peekable();
|
||||
while let Some(glyph) = glyphs.next() {
|
||||
|
@ -20,20 +20,21 @@ pub fn layout_list(
|
||||
styles: StyleChain,
|
||||
regions: Regions,
|
||||
) -> SourceResult<Fragment> {
|
||||
let indent = elem.indent(styles);
|
||||
let body_indent = elem.body_indent(styles);
|
||||
let tight = elem.tight(styles);
|
||||
let gutter = elem.spacing(styles).unwrap_or_else(|| {
|
||||
let indent = elem.indent.get(styles);
|
||||
let body_indent = elem.body_indent.get(styles);
|
||||
let tight = elem.tight.get(styles);
|
||||
let gutter = elem.spacing.get(styles).unwrap_or_else(|| {
|
||||
if tight {
|
||||
ParElem::leading_in(styles).into()
|
||||
styles.get(ParElem::leading)
|
||||
} else {
|
||||
ParElem::spacing_in(styles).into()
|
||||
styles.get(ParElem::spacing)
|
||||
}
|
||||
});
|
||||
|
||||
let Depth(depth) = ListElem::depth_in(styles);
|
||||
let Depth(depth) = styles.get(ListElem::depth);
|
||||
let marker = elem
|
||||
.marker(styles)
|
||||
.marker
|
||||
.get_ref(styles)
|
||||
.resolve(engine, styles, depth)?
|
||||
// avoid '#set align' interference with the list
|
||||
.aligned(HAlignment::Start + VAlignment::Top);
|
||||
@ -52,7 +53,7 @@ pub fn layout_list(
|
||||
cells.push(Cell::new(marker.clone(), locator.next(&marker.span())));
|
||||
cells.push(Cell::new(Content::empty(), locator.next(&())));
|
||||
cells.push(Cell::new(
|
||||
body.styled(ListElem::set_depth(Depth(1))),
|
||||
body.set(ListElem::depth, Depth(1)),
|
||||
locator.next(&item.body.span()),
|
||||
));
|
||||
}
|
||||
@ -81,40 +82,40 @@ pub fn layout_enum(
|
||||
styles: StyleChain,
|
||||
regions: Regions,
|
||||
) -> SourceResult<Fragment> {
|
||||
let numbering = elem.numbering(styles);
|
||||
let reversed = elem.reversed(styles);
|
||||
let indent = elem.indent(styles);
|
||||
let body_indent = elem.body_indent(styles);
|
||||
let tight = elem.tight(styles);
|
||||
let gutter = elem.spacing(styles).unwrap_or_else(|| {
|
||||
let numbering = elem.numbering.get_ref(styles);
|
||||
let reversed = elem.reversed.get(styles);
|
||||
let indent = elem.indent.get(styles);
|
||||
let body_indent = elem.body_indent.get(styles);
|
||||
let tight = elem.tight.get(styles);
|
||||
let gutter = elem.spacing.get(styles).unwrap_or_else(|| {
|
||||
if tight {
|
||||
ParElem::leading_in(styles).into()
|
||||
styles.get(ParElem::leading)
|
||||
} else {
|
||||
ParElem::spacing_in(styles).into()
|
||||
styles.get(ParElem::spacing)
|
||||
}
|
||||
});
|
||||
|
||||
let mut cells = vec![];
|
||||
let mut locator = locator.split();
|
||||
let mut number = elem.start(styles).unwrap_or_else(|| {
|
||||
let mut number = elem.start.get(styles).unwrap_or_else(|| {
|
||||
if reversed {
|
||||
elem.children.len() as u64
|
||||
} else {
|
||||
1
|
||||
}
|
||||
});
|
||||
let mut parents = EnumElem::parents_in(styles);
|
||||
let mut parents = styles.get_cloned(EnumElem::parents);
|
||||
|
||||
let full = elem.full(styles);
|
||||
let full = elem.full.get(styles);
|
||||
|
||||
// Horizontally align based on the given respective parameter.
|
||||
// Vertically align to the top to avoid inheriting `horizon` or `bottom`
|
||||
// alignment from the context and having the number be displaced in
|
||||
// relation to the item it refers to.
|
||||
let number_align = elem.number_align(styles);
|
||||
let number_align = elem.number_align.get(styles);
|
||||
|
||||
for item in &elem.children {
|
||||
number = item.number(styles).unwrap_or(number);
|
||||
number = item.number.get(styles).unwrap_or(number);
|
||||
|
||||
let context = Context::new(None, Some(styles));
|
||||
let resolved = if full {
|
||||
@ -133,8 +134,7 @@ pub fn layout_enum(
|
||||
|
||||
// Disable overhang as a workaround to end-aligned dots glitching
|
||||
// and decreasing spacing between numbers and items.
|
||||
let resolved =
|
||||
resolved.aligned(number_align).styled(TextElem::set_overhang(false));
|
||||
let resolved = resolved.aligned(number_align).set(TextElem::overhang, false);
|
||||
|
||||
// Text in wide enums shall always turn into paragraphs.
|
||||
let mut body = item.body.clone();
|
||||
@ -146,7 +146,7 @@ pub fn layout_enum(
|
||||
cells.push(Cell::new(resolved, locator.next(&())));
|
||||
cells.push(Cell::new(Content::empty(), locator.next(&())));
|
||||
cells.push(Cell::new(
|
||||
body.styled(EnumElem::set_parents(smallvec![number])),
|
||||
body.set(EnumElem::parents, smallvec![number]),
|
||||
locator.next(&item.body.span()),
|
||||
));
|
||||
number =
|
||||
|
@ -24,7 +24,7 @@ pub fn layout_accent(
|
||||
// Try to replace the base glyph with its dotless variant.
|
||||
let dtls = style_dtls();
|
||||
let base_styles =
|
||||
if top_accent && elem.dotless(styles) { styles.chain(&dtls) } else { styles };
|
||||
if top_accent && elem.dotless.get(styles) { styles.chain(&dtls) } else { styles };
|
||||
|
||||
let cramped = style_cramped();
|
||||
let base = ctx.layout_into_fragment(&elem.base, base_styles.chain(&cramped))?;
|
||||
@ -47,7 +47,7 @@ pub fn layout_accent(
|
||||
|
||||
// Forcing the accent to be at least as large as the base makes it too wide
|
||||
// in many cases.
|
||||
let width = elem.size(styles).relative_to(base.width());
|
||||
let width = elem.size.resolve(styles).relative_to(base.width());
|
||||
let short_fall = ACCENT_SHORT_FALL.at(glyph.item.size);
|
||||
glyph.stretch_horizontal(ctx, width - short_fall);
|
||||
let accent_attach = glyph.accent_attach.0;
|
||||
|
@ -31,16 +31,16 @@ pub fn layout_attach(
|
||||
let mut base = ctx.layout_into_fragment(&elem.base, styles)?;
|
||||
let sup_style = style_for_superscript(styles);
|
||||
let sup_style_chain = styles.chain(&sup_style);
|
||||
let tl = elem.tl(sup_style_chain);
|
||||
let tr = elem.tr(sup_style_chain);
|
||||
let tl = elem.tl.get_cloned(sup_style_chain);
|
||||
let tr = elem.tr.get_cloned(sup_style_chain);
|
||||
let primed = tr.as_ref().is_some_and(|content| content.is::<PrimesElem>());
|
||||
let t = elem.t(sup_style_chain);
|
||||
let t = elem.t.get_cloned(sup_style_chain);
|
||||
|
||||
let sub_style = style_for_subscript(styles);
|
||||
let sub_style_chain = styles.chain(&sub_style);
|
||||
let bl = elem.bl(sub_style_chain);
|
||||
let br = elem.br(sub_style_chain);
|
||||
let b = elem.b(sub_style_chain);
|
||||
let bl = elem.bl.get_cloned(sub_style_chain);
|
||||
let br = elem.br.get_cloned(sub_style_chain);
|
||||
let b = elem.b.get_cloned(sub_style_chain);
|
||||
|
||||
let limits = base.limits().active(styles);
|
||||
let (t, tr) = match (t, tr) {
|
||||
@ -146,7 +146,7 @@ pub fn layout_limits(
|
||||
ctx: &mut MathContext,
|
||||
styles: StyleChain,
|
||||
) -> SourceResult<()> {
|
||||
let limits = if elem.inline(styles) { Limits::Always } else { Limits::Display };
|
||||
let limits = if elem.inline.get(styles) { Limits::Always } else { Limits::Display };
|
||||
let mut fragment = ctx.layout_into_fragment(&elem.body, styles)?;
|
||||
fragment.set_limits(limits);
|
||||
ctx.push(fragment);
|
||||
@ -161,7 +161,8 @@ fn stretch_size(styles: StyleChain, elem: &Packed<AttachElem>) -> Option<Rel<Abs
|
||||
base = &equation.body;
|
||||
}
|
||||
|
||||
base.to_packed::<StretchElem>().map(|stretch| stretch.size(styles))
|
||||
base.to_packed::<StretchElem>()
|
||||
.map(|stretch| stretch.size.resolve(styles))
|
||||
}
|
||||
|
||||
/// Lay out the attachments.
|
||||
@ -397,7 +398,7 @@ fn compute_script_shifts(
|
||||
base: &MathFragment,
|
||||
[tl, tr, bl, br]: [&Option<MathFragment>; 4],
|
||||
) -> (Abs, Abs) {
|
||||
let sup_shift_up = if EquationElem::cramped_in(styles) {
|
||||
let sup_shift_up = if styles.get(EquationElem::cramped) {
|
||||
scaled!(ctx, styles, superscript_shift_up_cramped)
|
||||
} else {
|
||||
scaled!(ctx, styles, superscript_shift_up)
|
||||
|
@ -27,16 +27,16 @@ pub fn layout_cancel(
|
||||
let mut body = body.into_frame();
|
||||
let body_size = body.size();
|
||||
let span = elem.span();
|
||||
let length = elem.length(styles);
|
||||
let length = elem.length.resolve(styles);
|
||||
|
||||
let stroke = elem.stroke(styles).unwrap_or(FixedStroke {
|
||||
paint: TextElem::fill_in(styles).as_decoration(),
|
||||
let stroke = elem.stroke.resolve(styles).unwrap_or(FixedStroke {
|
||||
paint: styles.get_ref(TextElem::fill).as_decoration(),
|
||||
..Default::default()
|
||||
});
|
||||
|
||||
let invert = elem.inverted(styles);
|
||||
let cross = elem.cross(styles);
|
||||
let angle = elem.angle(styles);
|
||||
let invert = elem.inverted.get(styles);
|
||||
let cross = elem.cross.get(styles);
|
||||
let angle = elem.angle.get_ref(styles);
|
||||
|
||||
let invert_first_line = !cross && invert;
|
||||
let first_line = draw_cancel_line(
|
||||
@ -44,7 +44,7 @@ pub fn layout_cancel(
|
||||
length,
|
||||
stroke.clone(),
|
||||
invert_first_line,
|
||||
&angle,
|
||||
angle,
|
||||
body_size,
|
||||
styles,
|
||||
span,
|
||||
@ -57,7 +57,7 @@ pub fn layout_cancel(
|
||||
if cross {
|
||||
// Draw the second line.
|
||||
let second_line =
|
||||
draw_cancel_line(ctx, length, stroke, true, &angle, body_size, styles, span)?;
|
||||
draw_cancel_line(ctx, length, stroke, true, angle, body_size, styles, span)?;
|
||||
|
||||
body.push_frame(center, second_line);
|
||||
}
|
||||
|
@ -124,7 +124,7 @@ fn layout_frac_like(
|
||||
FrameItem::Shape(
|
||||
Geometry::Line(Point::with_x(line_width)).stroked(
|
||||
FixedStroke::from_pair(
|
||||
TextElem::fill_in(styles).as_decoration(),
|
||||
styles.get_ref(TextElem::fill).as_decoration(),
|
||||
thickness,
|
||||
),
|
||||
),
|
||||
|
@ -315,7 +315,8 @@ impl GlyphFragment {
|
||||
let cluster = info.cluster as usize;
|
||||
let c = text[cluster..].chars().next().unwrap();
|
||||
let limits = Limits::for_char(c);
|
||||
let class = EquationElem::class_in(styles)
|
||||
let class = styles
|
||||
.get(EquationElem::class)
|
||||
.or_else(|| default_math_class(c))
|
||||
.unwrap_or(MathClass::Normal);
|
||||
|
||||
@ -331,11 +332,11 @@ impl GlyphFragment {
|
||||
|
||||
let item = TextItem {
|
||||
font: font.clone(),
|
||||
size: TextElem::size_in(styles),
|
||||
fill: TextElem::fill_in(styles).as_decoration(),
|
||||
stroke: TextElem::stroke_in(styles).map(|s| s.unwrap_or_default()),
|
||||
lang: TextElem::lang_in(styles),
|
||||
region: TextElem::region_in(styles),
|
||||
size: styles.resolve(TextElem::size),
|
||||
fill: styles.get_ref(TextElem::fill).as_decoration(),
|
||||
stroke: styles.resolve(TextElem::stroke).map(|s| s.unwrap_or_default()),
|
||||
lang: styles.get(TextElem::lang),
|
||||
region: styles.get(TextElem::region),
|
||||
text: text.into(),
|
||||
glyphs: vec![glyph.clone()],
|
||||
};
|
||||
@ -344,7 +345,7 @@ impl GlyphFragment {
|
||||
item,
|
||||
base_glyph: glyph,
|
||||
// Math
|
||||
math_size: EquationElem::size_in(styles),
|
||||
math_size: styles.get(EquationElem::size),
|
||||
class,
|
||||
limits,
|
||||
mid_stretched: None,
|
||||
@ -356,7 +357,7 @@ impl GlyphFragment {
|
||||
baseline: None,
|
||||
// Misc
|
||||
align: Abs::zero(),
|
||||
shift: TextElem::baseline_in(styles),
|
||||
shift: styles.resolve(TextElem::baseline),
|
||||
modifiers: FrameModifiers::get_in(styles),
|
||||
};
|
||||
fragment.update_glyph();
|
||||
@ -541,9 +542,9 @@ impl FrameFragment {
|
||||
let accent_attach = frame.width() / 2.0;
|
||||
Self {
|
||||
frame: frame.modified(&FrameModifiers::get_in(styles)),
|
||||
font_size: TextElem::size_in(styles),
|
||||
class: EquationElem::class_in(styles).unwrap_or(MathClass::Normal),
|
||||
math_size: EquationElem::size_in(styles),
|
||||
font_size: styles.resolve(TextElem::size),
|
||||
class: styles.get(EquationElem::class).unwrap_or(MathClass::Normal),
|
||||
math_size: styles.get(EquationElem::size),
|
||||
limits: Limits::Never,
|
||||
spaced: false,
|
||||
base_ascent,
|
||||
@ -864,7 +865,7 @@ impl Limits {
|
||||
pub fn active(&self, styles: StyleChain) -> bool {
|
||||
match self {
|
||||
Self::Always => true,
|
||||
Self::Display => EquationElem::size_in(styles) == MathSize::Display,
|
||||
Self::Display => styles.get(EquationElem::size) == MathSize::Display,
|
||||
Self::Never => false,
|
||||
}
|
||||
}
|
||||
|
@ -22,7 +22,7 @@ pub fn layout_lr(
|
||||
|
||||
// Extract implicit LrElem.
|
||||
if let Some(lr) = body.to_packed::<LrElem>() {
|
||||
if lr.size(styles).is_one() {
|
||||
if lr.size.get(styles).is_one() {
|
||||
body = &lr.body;
|
||||
}
|
||||
}
|
||||
@ -41,7 +41,7 @@ pub fn layout_lr(
|
||||
.unwrap_or_default();
|
||||
|
||||
let relative_to = 2.0 * max_extent;
|
||||
let height = elem.size(styles);
|
||||
let height = elem.size.resolve(styles);
|
||||
|
||||
// Scale up fragments at both ends.
|
||||
match inner_fragments {
|
||||
|
@ -30,15 +30,15 @@ pub fn layout_vec(
|
||||
ctx,
|
||||
styles,
|
||||
&[column],
|
||||
elem.align(styles),
|
||||
elem.align.resolve(styles),
|
||||
LeftRightAlternator::Right,
|
||||
None,
|
||||
Axes::with_y(elem.gap(styles)),
|
||||
Axes::with_y(elem.gap.resolve(styles)),
|
||||
span,
|
||||
"elements",
|
||||
)?;
|
||||
|
||||
let delim = elem.delim(styles);
|
||||
let delim = elem.delim.get(styles);
|
||||
layout_delimiters(ctx, styles, frame, delim.open(), delim.close(), span)
|
||||
}
|
||||
|
||||
@ -59,14 +59,17 @@ pub fn layout_cases(
|
||||
FixedAlignment::Start,
|
||||
LeftRightAlternator::None,
|
||||
None,
|
||||
Axes::with_y(elem.gap(styles)),
|
||||
Axes::with_y(elem.gap.resolve(styles)),
|
||||
span,
|
||||
"branches",
|
||||
)?;
|
||||
|
||||
let delim = elem.delim(styles);
|
||||
let (open, close) =
|
||||
if elem.reverse(styles) { (None, delim.close()) } else { (delim.open(), None) };
|
||||
let delim = elem.delim.get(styles);
|
||||
let (open, close) = if elem.reverse.get(styles) {
|
||||
(None, delim.close())
|
||||
} else {
|
||||
(delim.open(), None)
|
||||
};
|
||||
layout_delimiters(ctx, styles, frame, open, close, span)
|
||||
}
|
||||
|
||||
@ -81,7 +84,7 @@ pub fn layout_mat(
|
||||
let rows = &elem.rows;
|
||||
let ncols = rows.first().map_or(0, |row| row.len());
|
||||
|
||||
let augment = elem.augment(styles);
|
||||
let augment = elem.augment.resolve(styles);
|
||||
if let Some(aug) = &augment {
|
||||
for &offset in &aug.hline.0 {
|
||||
if offset == 0 || offset.unsigned_abs() >= rows.len() {
|
||||
@ -116,15 +119,15 @@ pub fn layout_mat(
|
||||
ctx,
|
||||
styles,
|
||||
&columns,
|
||||
elem.align(styles),
|
||||
elem.align.resolve(styles),
|
||||
LeftRightAlternator::Right,
|
||||
augment,
|
||||
Axes::new(elem.column_gap(styles), elem.row_gap(styles)),
|
||||
Axes::new(elem.column_gap.resolve(styles), elem.row_gap.resolve(styles)),
|
||||
span,
|
||||
"cells",
|
||||
)?;
|
||||
|
||||
let delim = elem.delim(styles);
|
||||
let delim = elem.delim.get(styles);
|
||||
layout_delimiters(ctx, styles, frame, delim.open(), delim.close(), span)
|
||||
}
|
||||
|
||||
@ -157,7 +160,7 @@ fn layout_body(
|
||||
let default_stroke_thickness = DEFAULT_STROKE_THICKNESS.resolve(styles);
|
||||
let default_stroke = FixedStroke {
|
||||
thickness: default_stroke_thickness,
|
||||
paint: TextElem::fill_in(styles).as_decoration(),
|
||||
paint: styles.get_ref(TextElem::fill).as_decoration(),
|
||||
cap: LineCap::Square,
|
||||
..Default::default()
|
||||
};
|
||||
|
@ -51,7 +51,7 @@ pub fn layout_equation_inline(
|
||||
styles: StyleChain,
|
||||
region: Size,
|
||||
) -> SourceResult<Vec<InlineItem>> {
|
||||
assert!(!elem.block(styles));
|
||||
assert!(!elem.block.get(styles));
|
||||
|
||||
let font = find_math_font(engine, styles, elem.span())?;
|
||||
|
||||
@ -78,12 +78,12 @@ pub fn layout_equation_inline(
|
||||
for item in &mut items {
|
||||
let InlineItem::Frame(frame) = item else { continue };
|
||||
|
||||
let slack = ParElem::leading_in(styles) * 0.7;
|
||||
let slack = styles.resolve(ParElem::leading) * 0.7;
|
||||
|
||||
let (t, b) = font.edges(
|
||||
TextElem::top_edge_in(styles),
|
||||
TextElem::bottom_edge_in(styles),
|
||||
TextElem::size_in(styles),
|
||||
styles.get(TextElem::top_edge),
|
||||
styles.get(TextElem::bottom_edge),
|
||||
styles.resolve(TextElem::size),
|
||||
TextEdgeBounds::Frame(frame),
|
||||
);
|
||||
|
||||
@ -105,7 +105,7 @@ pub fn layout_equation_block(
|
||||
styles: StyleChain,
|
||||
regions: Regions,
|
||||
) -> SourceResult<Fragment> {
|
||||
assert!(elem.block(styles));
|
||||
assert!(elem.block.get(styles));
|
||||
|
||||
let span = elem.span();
|
||||
let font = find_math_font(engine, styles, span)?;
|
||||
@ -121,7 +121,7 @@ pub fn layout_equation_block(
|
||||
.multiline_frame_builder(styles);
|
||||
let width = full_equation_builder.size.x;
|
||||
|
||||
let equation_builders = if BlockElem::breakable_in(styles) {
|
||||
let equation_builders = if styles.get(BlockElem::breakable) {
|
||||
let mut rows = full_equation_builder.frames.into_iter().peekable();
|
||||
let mut equation_builders = vec![];
|
||||
let mut last_first_pos = Point::zero();
|
||||
@ -188,7 +188,7 @@ pub fn layout_equation_block(
|
||||
vec![full_equation_builder]
|
||||
};
|
||||
|
||||
let Some(numbering) = (**elem).numbering(styles) else {
|
||||
let Some(numbering) = elem.numbering.get_ref(styles) else {
|
||||
let frames = equation_builders
|
||||
.into_iter()
|
||||
.map(MathRunFrameBuilder::build)
|
||||
@ -197,7 +197,7 @@ pub fn layout_equation_block(
|
||||
};
|
||||
|
||||
let pod = Region::new(regions.base(), Axes::splat(false));
|
||||
let counter = Counter::of(EquationElem::elem())
|
||||
let counter = Counter::of(EquationElem::ELEM)
|
||||
.display_at_loc(engine, elem.location().unwrap(), styles, numbering)?
|
||||
.spanned(span);
|
||||
let number = crate::layout_frame(engine, &counter, locator.next(&()), styles, pod)?;
|
||||
@ -205,7 +205,7 @@ pub fn layout_equation_block(
|
||||
static NUMBER_GUTTER: Em = Em::new(0.5);
|
||||
let full_number_width = number.width() + NUMBER_GUTTER.resolve(styles);
|
||||
|
||||
let number_align = match elem.number_align(styles) {
|
||||
let number_align = match elem.number_align.get(styles) {
|
||||
SpecificAlignment::H(h) => SpecificAlignment::Both(h, VAlignment::Horizon),
|
||||
SpecificAlignment::V(v) => SpecificAlignment::Both(OuterHAlignment::End, v),
|
||||
SpecificAlignment::Both(h, v) => SpecificAlignment::Both(h, v),
|
||||
@ -224,7 +224,7 @@ pub fn layout_equation_block(
|
||||
builder,
|
||||
number.clone(),
|
||||
number_align.resolve(styles),
|
||||
AlignElem::alignment_in(styles).resolve(styles).x,
|
||||
styles.get(AlignElem::alignment).resolve(styles).x,
|
||||
regions.size.x,
|
||||
full_number_width,
|
||||
)
|
||||
@ -472,7 +472,9 @@ impl<'a, 'v, 'e> MathContext<'a, 'v, 'e> {
|
||||
let outer = styles;
|
||||
for (elem, styles) in pairs {
|
||||
// Hack because the font is fixed in math.
|
||||
if styles != outer && TextElem::font_in(styles) != TextElem::font_in(outer) {
|
||||
if styles != outer
|
||||
&& styles.get_ref(TextElem::font) != outer.get_ref(TextElem::font)
|
||||
{
|
||||
let frame = layout_external(elem, self, styles)?;
|
||||
self.push(FrameFragment::new(styles, frame).with_spaced(true));
|
||||
continue;
|
||||
@ -603,7 +605,10 @@ fn layout_h(
|
||||
) -> SourceResult<()> {
|
||||
if let Spacing::Rel(rel) = elem.amount {
|
||||
if rel.rel.is_zero() {
|
||||
ctx.push(MathFragment::Spacing(rel.abs.resolve(styles), elem.weak(styles)));
|
||||
ctx.push(MathFragment::Spacing(
|
||||
rel.abs.resolve(styles),
|
||||
elem.weak.get(styles),
|
||||
));
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
@ -616,7 +621,7 @@ fn layout_class(
|
||||
ctx: &mut MathContext,
|
||||
styles: StyleChain,
|
||||
) -> SourceResult<()> {
|
||||
let style = EquationElem::set_class(Some(elem.class)).wrap();
|
||||
let style = EquationElem::class.set(Some(elem.class)).wrap();
|
||||
let mut fragment = ctx.layout_into_fragment(&elem.body, styles.chain(&style))?;
|
||||
fragment.set_class(elem.class);
|
||||
fragment.set_limits(Limits::for_class(elem.class));
|
||||
@ -642,7 +647,7 @@ fn layout_op(
|
||||
.with_italics_correction(italics)
|
||||
.with_accent_attach(accent_attach)
|
||||
.with_text_like(text_like)
|
||||
.with_limits(if elem.limits(styles) {
|
||||
.with_limits(if elem.limits.get(styles) {
|
||||
Limits::Display
|
||||
} else {
|
||||
Limits::Never
|
||||
|
@ -17,7 +17,7 @@ pub fn layout_root(
|
||||
ctx: &mut MathContext,
|
||||
styles: StyleChain,
|
||||
) -> SourceResult<()> {
|
||||
let index = elem.index(styles);
|
||||
let index = elem.index.get_ref(styles);
|
||||
let span = elem.span();
|
||||
|
||||
let gap = scaled!(
|
||||
@ -54,7 +54,7 @@ pub fn layout_root(
|
||||
let sqrt = sqrt.into_frame();
|
||||
|
||||
// Layout the index.
|
||||
let sscript = EquationElem::set_size(MathSize::ScriptScript).wrap();
|
||||
let sscript = EquationElem::size.set(MathSize::ScriptScript).wrap();
|
||||
let index = index
|
||||
.as_ref()
|
||||
.map(|elem| ctx.layout_into_frame(elem, styles.chain(&sscript)))
|
||||
@ -112,7 +112,7 @@ pub fn layout_root(
|
||||
FrameItem::Shape(
|
||||
Geometry::Line(Point::with_x(radicand.width())).stroked(
|
||||
FixedStroke::from_pair(
|
||||
TextElem::fill_in(styles).as_decoration(),
|
||||
styles.get_ref(TextElem::fill).as_decoration(),
|
||||
thickness,
|
||||
),
|
||||
),
|
||||
|
@ -194,13 +194,13 @@ impl MathRun {
|
||||
let row_count = rows.len();
|
||||
let alignments = alignments(&rows);
|
||||
|
||||
let leading = if EquationElem::size_in(styles) >= MathSize::Text {
|
||||
ParElem::leading_in(styles)
|
||||
let leading = if styles.get(EquationElem::size) >= MathSize::Text {
|
||||
styles.resolve(ParElem::leading)
|
||||
} else {
|
||||
TIGHT_LEADING.resolve(styles)
|
||||
};
|
||||
|
||||
let align = AlignElem::alignment_in(styles).resolve(styles).x;
|
||||
let align = styles.resolve(AlignElem::alignment).x;
|
||||
let mut frames: Vec<(Frame, Point)> = vec![];
|
||||
let mut size = Size::zero();
|
||||
for (i, row) in rows.into_iter().enumerate() {
|
||||
|
@ -10,7 +10,7 @@ use super::{LeftRightAlternator, MathContext, MathFragment, MathRun};
|
||||
|
||||
macro_rules! scaled {
|
||||
($ctx:expr, $styles:expr, text: $text:ident, display: $display:ident $(,)?) => {
|
||||
match typst_library::math::EquationElem::size_in($styles) {
|
||||
match $styles.get(typst_library::math::EquationElem::size) {
|
||||
typst_library::math::MathSize::Display => scaled!($ctx, $styles, $display),
|
||||
_ => scaled!($ctx, $styles, $text),
|
||||
}
|
||||
@ -19,7 +19,7 @@ macro_rules! scaled {
|
||||
$crate::math::Scaled::scaled(
|
||||
$ctx.constants.$name(),
|
||||
$ctx,
|
||||
typst_library::text::TextElem::size_in($styles),
|
||||
$styles.resolve(typst_library::text::TextElem::size),
|
||||
)
|
||||
};
|
||||
}
|
||||
@ -58,27 +58,32 @@ impl Scaled for MathValue<'_> {
|
||||
|
||||
/// Styles something as cramped.
|
||||
pub fn style_cramped() -> LazyHash<Style> {
|
||||
EquationElem::set_cramped(true).wrap()
|
||||
EquationElem::cramped.set(true).wrap()
|
||||
}
|
||||
|
||||
/// Sets flac OpenType feature.
|
||||
pub fn style_flac() -> LazyHash<Style> {
|
||||
TextElem::set_features(FontFeatures(vec![(Tag::from_bytes(b"flac"), 1)])).wrap()
|
||||
TextElem::features
|
||||
.set(FontFeatures(vec![(Tag::from_bytes(b"flac"), 1)]))
|
||||
.wrap()
|
||||
}
|
||||
|
||||
/// Sets dtls OpenType feature.
|
||||
pub fn style_dtls() -> LazyHash<Style> {
|
||||
TextElem::set_features(FontFeatures(vec![(Tag::from_bytes(b"dtls"), 1)])).wrap()
|
||||
TextElem::features
|
||||
.set(FontFeatures(vec![(Tag::from_bytes(b"dtls"), 1)]))
|
||||
.wrap()
|
||||
}
|
||||
|
||||
/// The style for subscripts in the current style.
|
||||
pub fn style_for_subscript(styles: StyleChain) -> [LazyHash<Style>; 2] {
|
||||
[style_for_superscript(styles), EquationElem::set_cramped(true).wrap()]
|
||||
[style_for_superscript(styles), EquationElem::cramped.set(true).wrap()]
|
||||
}
|
||||
|
||||
/// The style for superscripts in the current style.
|
||||
pub fn style_for_superscript(styles: StyleChain) -> LazyHash<Style> {
|
||||
EquationElem::set_size(match EquationElem::size_in(styles) {
|
||||
EquationElem::size
|
||||
.set(match styles.get(EquationElem::size) {
|
||||
MathSize::Display | MathSize::Text => MathSize::Script,
|
||||
MathSize::Script | MathSize::ScriptScript => MathSize::ScriptScript,
|
||||
})
|
||||
@ -87,7 +92,8 @@ pub fn style_for_superscript(styles: StyleChain) -> LazyHash<Style> {
|
||||
|
||||
/// The style for numerators in the current style.
|
||||
pub fn style_for_numerator(styles: StyleChain) -> LazyHash<Style> {
|
||||
EquationElem::set_size(match EquationElem::size_in(styles) {
|
||||
EquationElem::size
|
||||
.set(match styles.get(EquationElem::size) {
|
||||
MathSize::Display => MathSize::Text,
|
||||
MathSize::Text => MathSize::Script,
|
||||
MathSize::Script | MathSize::ScriptScript => MathSize::ScriptScript,
|
||||
@ -97,12 +103,13 @@ pub fn style_for_numerator(styles: StyleChain) -> LazyHash<Style> {
|
||||
|
||||
/// The style for denominators in the current style.
|
||||
pub fn style_for_denominator(styles: StyleChain) -> [LazyHash<Style>; 2] {
|
||||
[style_for_numerator(styles), EquationElem::set_cramped(true).wrap()]
|
||||
[style_for_numerator(styles), EquationElem::cramped.set(true).wrap()]
|
||||
}
|
||||
|
||||
/// Styles to add font constants to the style chain.
|
||||
pub fn style_for_script_scale(ctx: &MathContext) -> LazyHash<Style> {
|
||||
EquationElem::set_script_scale((
|
||||
EquationElem::script_scale
|
||||
.set((
|
||||
ctx.constants.script_percent_scale_down(),
|
||||
ctx.constants.script_script_percent_scale_down(),
|
||||
))
|
||||
|
@ -14,7 +14,14 @@ pub fn layout_stretch(
|
||||
styles: StyleChain,
|
||||
) -> SourceResult<()> {
|
||||
let mut fragment = ctx.layout_into_fragment(&elem.body, styles)?;
|
||||
stretch_fragment(ctx, &mut fragment, None, None, elem.size(styles), Abs::zero());
|
||||
stretch_fragment(
|
||||
ctx,
|
||||
&mut fragment,
|
||||
None,
|
||||
None,
|
||||
elem.size.resolve(styles),
|
||||
Abs::zero(),
|
||||
);
|
||||
ctx.push(fragment);
|
||||
Ok(())
|
||||
}
|
||||
|
@ -77,8 +77,8 @@ fn layout_inline_text(
|
||||
Ok(FrameFragment::new(styles, frame).with_text_like(true))
|
||||
} else {
|
||||
let local = [
|
||||
TextElem::set_top_edge(TopEdge::Metric(TopEdgeMetric::Bounds)),
|
||||
TextElem::set_bottom_edge(BottomEdge::Metric(BottomEdgeMetric::Bounds)),
|
||||
TextElem::top_edge.set(TopEdge::Metric(TopEdgeMetric::Bounds)),
|
||||
TextElem::bottom_edge.set(BottomEdge::Metric(BottomEdgeMetric::Bounds)),
|
||||
]
|
||||
.map(|p| p.wrap());
|
||||
|
||||
@ -150,7 +150,7 @@ fn adjust_glyph_layout(
|
||||
styles: StyleChain,
|
||||
) {
|
||||
if glyph.class == MathClass::Large {
|
||||
if EquationElem::size_in(styles) == MathSize::Display {
|
||||
if styles.get(EquationElem::size) == MathSize::Display {
|
||||
let height = scaled!(ctx, styles, display_operator_min_height)
|
||||
.max(SQRT_2 * glyph.size.y);
|
||||
glyph.stretch_vertical(ctx, height);
|
||||
@ -169,9 +169,9 @@ fn adjust_glyph_layout(
|
||||
fn styled_char(styles: StyleChain, c: char, auto_italic: bool) -> char {
|
||||
use MathVariant::*;
|
||||
|
||||
let variant = EquationElem::variant_in(styles);
|
||||
let bold = EquationElem::bold_in(styles);
|
||||
let italic = EquationElem::italic_in(styles).unwrap_or(
|
||||
let variant = styles.get(EquationElem::variant);
|
||||
let bold = styles.get(EquationElem::bold);
|
||||
let italic = styles.get(EquationElem::italic).unwrap_or(
|
||||
auto_italic
|
||||
&& matches!(
|
||||
c,
|
||||
|
@ -56,7 +56,7 @@ pub fn layout_underbrace(
|
||||
ctx,
|
||||
styles,
|
||||
&elem.body,
|
||||
&elem.annotation(styles),
|
||||
elem.annotation.get_ref(styles),
|
||||
'⏟',
|
||||
BRACE_GAP,
|
||||
Position::Under,
|
||||
@ -75,7 +75,7 @@ pub fn layout_overbrace(
|
||||
ctx,
|
||||
styles,
|
||||
&elem.body,
|
||||
&elem.annotation(styles),
|
||||
elem.annotation.get_ref(styles),
|
||||
'⏞',
|
||||
BRACE_GAP,
|
||||
Position::Over,
|
||||
@ -94,7 +94,7 @@ pub fn layout_underbracket(
|
||||
ctx,
|
||||
styles,
|
||||
&elem.body,
|
||||
&elem.annotation(styles),
|
||||
elem.annotation.get_ref(styles),
|
||||
'⎵',
|
||||
BRACKET_GAP,
|
||||
Position::Under,
|
||||
@ -113,7 +113,7 @@ pub fn layout_overbracket(
|
||||
ctx,
|
||||
styles,
|
||||
&elem.body,
|
||||
&elem.annotation(styles),
|
||||
elem.annotation.get_ref(styles),
|
||||
'⎴',
|
||||
BRACKET_GAP,
|
||||
Position::Over,
|
||||
@ -132,7 +132,7 @@ pub fn layout_underparen(
|
||||
ctx,
|
||||
styles,
|
||||
&elem.body,
|
||||
&elem.annotation(styles),
|
||||
elem.annotation.get_ref(styles),
|
||||
'⏝',
|
||||
PAREN_GAP,
|
||||
Position::Under,
|
||||
@ -151,7 +151,7 @@ pub fn layout_overparen(
|
||||
ctx,
|
||||
styles,
|
||||
&elem.body,
|
||||
&elem.annotation(styles),
|
||||
elem.annotation.get_ref(styles),
|
||||
'⏜',
|
||||
PAREN_GAP,
|
||||
Position::Over,
|
||||
@ -170,7 +170,7 @@ pub fn layout_undershell(
|
||||
ctx,
|
||||
styles,
|
||||
&elem.body,
|
||||
&elem.annotation(styles),
|
||||
elem.annotation.get_ref(styles),
|
||||
'⏡',
|
||||
SHELL_GAP,
|
||||
Position::Under,
|
||||
@ -189,7 +189,7 @@ pub fn layout_overshell(
|
||||
ctx,
|
||||
styles,
|
||||
&elem.body,
|
||||
&elem.annotation(styles),
|
||||
elem.annotation.get_ref(styles),
|
||||
'⏠',
|
||||
SHELL_GAP,
|
||||
Position::Over,
|
||||
@ -251,7 +251,7 @@ fn layout_underoverline(
|
||||
line_pos,
|
||||
FrameItem::Shape(
|
||||
Geometry::Line(Point::with_x(line_width)).stroked(FixedStroke {
|
||||
paint: TextElem::fill_in(styles).as_decoration(),
|
||||
paint: styles.get_ref(TextElem::fill).as_decoration(),
|
||||
thickness: bar_height,
|
||||
..FixedStroke::default()
|
||||
}),
|
||||
|
@ -29,8 +29,8 @@ impl FrameModifiers {
|
||||
/// Retrieve all modifications that should be applied per-frame.
|
||||
pub fn get_in(styles: StyleChain) -> Self {
|
||||
Self {
|
||||
dest: LinkElem::current_in(styles),
|
||||
hidden: HideElem::hidden_in(styles),
|
||||
dest: styles.get_cloned(LinkElem::current),
|
||||
hidden: styles.get(HideElem::hidden),
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -83,7 +83,7 @@ pub trait FrameModifyText {
|
||||
impl FrameModifyText for Frame {
|
||||
fn modify_text(&mut self, styles: StyleChain) {
|
||||
let modifiers = FrameModifiers::get_in(styles);
|
||||
let expand_y = 0.5 * ParElem::leading_in(styles);
|
||||
let expand_y = 0.5 * styles.resolve(ParElem::leading);
|
||||
let outset = Sides::new(Abs::zero(), expand_y, Abs::zero(), expand_y);
|
||||
modify_frame(self, &modifiers, Some(outset));
|
||||
}
|
||||
@ -130,7 +130,7 @@ where
|
||||
let outer = styles;
|
||||
let mut styles = styles;
|
||||
if modifiers.dest.is_some() {
|
||||
reset = LinkElem::set_current(None).wrap();
|
||||
reset = LinkElem::current.set(None).wrap();
|
||||
styles = outer.chain(&reset);
|
||||
}
|
||||
|
||||
|
@ -1,6 +1,6 @@
|
||||
use typst_library::diag::SourceResult;
|
||||
use typst_library::engine::Engine;
|
||||
use typst_library::foundations::{Packed, Resolve, StyleChain};
|
||||
use typst_library::foundations::{Packed, StyleChain};
|
||||
use typst_library::introspection::Locator;
|
||||
use typst_library::layout::{
|
||||
Abs, Fragment, Frame, PadElem, Point, Regions, Rel, Sides, Size,
|
||||
@ -16,10 +16,10 @@ pub fn layout_pad(
|
||||
regions: Regions,
|
||||
) -> SourceResult<Fragment> {
|
||||
let padding = Sides::new(
|
||||
elem.left(styles).resolve(styles),
|
||||
elem.top(styles).resolve(styles),
|
||||
elem.right(styles).resolve(styles),
|
||||
elem.bottom(styles).resolve(styles),
|
||||
elem.left.resolve(styles),
|
||||
elem.top.resolve(styles),
|
||||
elem.right.resolve(styles),
|
||||
elem.bottom.resolve(styles),
|
||||
);
|
||||
|
||||
let mut backlog = vec![];
|
||||
|
@ -39,14 +39,14 @@ pub fn collect<'a>(
|
||||
if let Some(pagebreak) = elem.to_packed::<PagebreakElem>() {
|
||||
// Add a blank page if we encounter a strong pagebreak and there was
|
||||
// a staged empty page.
|
||||
let strong = !pagebreak.weak(styles);
|
||||
let strong = !pagebreak.weak.get(styles);
|
||||
if strong && staged_empty_page {
|
||||
let locator = locator.next(&elem.span());
|
||||
items.push(Item::Run(&[], initial, locator));
|
||||
}
|
||||
|
||||
// Add an instruction to adjust the page parity if requested.
|
||||
if let Some(parity) = pagebreak.to(styles) {
|
||||
if let Some(parity) = pagebreak.to.get(styles) {
|
||||
let locator = locator.next(&elem.span());
|
||||
items.push(Item::Parity(parity, styles, locator));
|
||||
}
|
||||
@ -56,7 +56,7 @@ pub fn collect<'a>(
|
||||
// the scope of a page set rule to ensure a page boundary. Its
|
||||
// styles correspond to the styles _before_ the page set rule, so we
|
||||
// don't want to apply it to a potential empty page.
|
||||
if !pagebreak.boundary(styles) {
|
||||
if !pagebreak.boundary.get(styles) {
|
||||
initial = styles;
|
||||
}
|
||||
|
||||
@ -94,7 +94,7 @@ pub fn collect<'a>(
|
||||
if group.iter().all(|(c, _)| c.is::<TagElem>())
|
||||
&& !(staged_empty_page
|
||||
&& children.iter().all(|&(c, s)| {
|
||||
c.to_packed::<PagebreakElem>().is_some_and(|c| c.boundary(s))
|
||||
c.to_packed::<PagebreakElem>().is_some_and(|c| c.boundary.get(s))
|
||||
}))
|
||||
{
|
||||
items.push(Item::Tags(group));
|
||||
|
@ -101,10 +101,10 @@ fn layout_page_run_impl(
|
||||
|
||||
// When one of the lengths is infinite the page fits its content along
|
||||
// that axis.
|
||||
let width = PageElem::width_in(styles).unwrap_or(Abs::inf());
|
||||
let height = PageElem::height_in(styles).unwrap_or(Abs::inf());
|
||||
let width = styles.resolve(PageElem::width).unwrap_or(Abs::inf());
|
||||
let height = styles.resolve(PageElem::height).unwrap_or(Abs::inf());
|
||||
let mut size = Size::new(width, height);
|
||||
if PageElem::flipped_in(styles) {
|
||||
if styles.get(PageElem::flipped) {
|
||||
std::mem::swap(&mut size.x, &mut size.y);
|
||||
}
|
||||
|
||||
@ -115,7 +115,7 @@ fn layout_page_run_impl(
|
||||
|
||||
// Determine the margins.
|
||||
let default = Rel::<Length>::from((2.5 / 21.0) * min);
|
||||
let margin = PageElem::margin_in(styles);
|
||||
let margin = styles.get(PageElem::margin);
|
||||
let two_sided = margin.two_sided.unwrap_or(false);
|
||||
let margin = margin
|
||||
.sides
|
||||
@ -123,21 +123,23 @@ fn layout_page_run_impl(
|
||||
.resolve(styles)
|
||||
.relative_to(size);
|
||||
|
||||
let fill = PageElem::fill_in(styles);
|
||||
let foreground = PageElem::foreground_in(styles);
|
||||
let background = PageElem::background_in(styles);
|
||||
let header_ascent = PageElem::header_ascent_in(styles).relative_to(margin.top);
|
||||
let footer_descent = PageElem::footer_descent_in(styles).relative_to(margin.bottom);
|
||||
let numbering = PageElem::numbering_in(styles);
|
||||
let supplement = match PageElem::supplement_in(styles) {
|
||||
let fill = styles.get_cloned(PageElem::fill);
|
||||
let foreground = styles.get_ref(PageElem::foreground);
|
||||
let background = styles.get_ref(PageElem::background);
|
||||
let header_ascent = styles.resolve(PageElem::header_ascent).relative_to(margin.top);
|
||||
let footer_descent =
|
||||
styles.resolve(PageElem::footer_descent).relative_to(margin.bottom);
|
||||
let numbering = styles.get_ref(PageElem::numbering);
|
||||
let supplement = match styles.get_cloned(PageElem::supplement) {
|
||||
Smart::Auto => TextElem::packed(PageElem::local_name_in(styles)),
|
||||
Smart::Custom(content) => content.unwrap_or_default(),
|
||||
};
|
||||
let number_align = PageElem::number_align_in(styles);
|
||||
let binding =
|
||||
PageElem::binding_in(styles).unwrap_or_else(|| match TextElem::dir_in(styles) {
|
||||
let number_align = styles.get(PageElem::number_align);
|
||||
let binding = styles.get(PageElem::binding).unwrap_or_else(|| {
|
||||
match styles.resolve(TextElem::dir) {
|
||||
Dir::LTR => Binding::Left,
|
||||
_ => Binding::Right,
|
||||
}
|
||||
});
|
||||
|
||||
// Construct the numbering (for header or footer).
|
||||
@ -163,8 +165,8 @@ fn layout_page_run_impl(
|
||||
counter
|
||||
});
|
||||
|
||||
let header = PageElem::header_in(styles);
|
||||
let footer = PageElem::footer_in(styles);
|
||||
let header = styles.get_ref(PageElem::header);
|
||||
let footer = styles.get_ref(PageElem::footer);
|
||||
let (header, footer) = if matches!(number_align.y(), Some(OuterVAlignment::Top)) {
|
||||
(header.as_ref().unwrap_or(&numbering_marginal), footer.as_ref().unwrap_or(&None))
|
||||
} else {
|
||||
@ -179,15 +181,15 @@ fn layout_page_run_impl(
|
||||
&mut locator,
|
||||
styles,
|
||||
Regions::repeat(area, area.map(Abs::is_finite)),
|
||||
PageElem::columns_in(styles),
|
||||
ColumnsElem::gutter_in(styles),
|
||||
styles.get(PageElem::columns),
|
||||
styles.get(ColumnsElem::gutter).resolve(styles),
|
||||
FlowMode::Root,
|
||||
)?;
|
||||
|
||||
// Layouts a single marginal.
|
||||
let mut layout_marginal = |content: &Option<Content>, area, align| {
|
||||
let Some(content) = content else { return Ok(None) };
|
||||
let aligned = content.clone().styled(AlignElem::set_alignment(align));
|
||||
let aligned = content.clone().set(AlignElem::alignment, align);
|
||||
crate::layout_frame(
|
||||
&mut engine,
|
||||
&aligned,
|
||||
|
@ -29,7 +29,7 @@ pub fn layout_repeat(
|
||||
frame.set_baseline(piece.baseline());
|
||||
}
|
||||
|
||||
let mut gap = elem.gap(styles).resolve(styles);
|
||||
let mut gap = elem.gap.resolve(styles);
|
||||
let fill = region.size.x;
|
||||
let width = piece.width();
|
||||
|
||||
@ -47,12 +47,12 @@ pub fn layout_repeat(
|
||||
let count = ((fill + gap) / (width + gap)).floor();
|
||||
let remaining = (fill + gap) % (width + gap);
|
||||
|
||||
let justify = elem.justify(styles);
|
||||
let justify = elem.justify.get(styles);
|
||||
if justify {
|
||||
gap += remaining / (count - 1.0);
|
||||
}
|
||||
|
||||
let align = AlignElem::alignment_in(styles).resolve(styles);
|
||||
let align = styles.get(AlignElem::alignment).resolve(styles);
|
||||
let mut offset = Abs::zero();
|
||||
if count == 1.0 || !justify {
|
||||
offset += align.x.position(remaining);
|
||||
|
@ -27,16 +27,20 @@ pub fn layout_line(
|
||||
region: Region,
|
||||
) -> SourceResult<Frame> {
|
||||
let resolve = |axes: Axes<Rel<Abs>>| axes.zip_map(region.size, Rel::relative_to);
|
||||
let start = resolve(elem.start(styles));
|
||||
let delta = elem.end(styles).map(|end| resolve(end) - start).unwrap_or_else(|| {
|
||||
let length = elem.length(styles);
|
||||
let angle = elem.angle(styles);
|
||||
let start = resolve(elem.start.resolve(styles));
|
||||
let delta = elem
|
||||
.end
|
||||
.resolve(styles)
|
||||
.map(|end| resolve(end) - start)
|
||||
.unwrap_or_else(|| {
|
||||
let length = elem.length.resolve(styles);
|
||||
let angle = elem.angle.get(styles);
|
||||
let x = angle.cos() * length;
|
||||
let y = angle.sin() * length;
|
||||
resolve(Axes::new(x, y))
|
||||
});
|
||||
|
||||
let stroke = elem.stroke(styles).unwrap_or_default();
|
||||
let stroke = elem.stroke.resolve(styles).unwrap_or_default();
|
||||
let size = start.max(start + delta).max(Size::zero());
|
||||
|
||||
if !size.is_finite() {
|
||||
@ -105,7 +109,7 @@ pub fn layout_path(
|
||||
add_cubic(from_point, to_point, from, to);
|
||||
}
|
||||
|
||||
if elem.closed(styles) {
|
||||
if elem.closed.get(styles) {
|
||||
let from = *vertices.last().unwrap(); // We checked that we have at least one element.
|
||||
let to = vertices[0];
|
||||
let from_point = *points.last().unwrap();
|
||||
@ -120,9 +124,9 @@ pub fn layout_path(
|
||||
}
|
||||
|
||||
// Prepare fill and stroke.
|
||||
let fill = elem.fill(styles);
|
||||
let fill_rule = elem.fill_rule(styles);
|
||||
let stroke = match elem.stroke(styles) {
|
||||
let fill = elem.fill.get_cloned(styles);
|
||||
let fill_rule = elem.fill_rule.get(styles);
|
||||
let stroke = match elem.stroke.resolve(styles) {
|
||||
Smart::Auto if fill.is_none() => Some(FixedStroke::default()),
|
||||
Smart::Auto => None,
|
||||
Smart::Custom(stroke) => stroke.map(Stroke::unwrap_or_default),
|
||||
@ -153,19 +157,19 @@ pub fn layout_curve(
|
||||
for item in &elem.components {
|
||||
match item {
|
||||
CurveComponent::Move(element) => {
|
||||
let relative = element.relative(styles);
|
||||
let relative = element.relative.get(styles);
|
||||
let point = builder.resolve_point(element.start, relative);
|
||||
builder.move_(point);
|
||||
}
|
||||
|
||||
CurveComponent::Line(element) => {
|
||||
let relative = element.relative(styles);
|
||||
let relative = element.relative.get(styles);
|
||||
let point = builder.resolve_point(element.end, relative);
|
||||
builder.line(point);
|
||||
}
|
||||
|
||||
CurveComponent::Quad(element) => {
|
||||
let relative = element.relative(styles);
|
||||
let relative = element.relative.get(styles);
|
||||
let end = builder.resolve_point(element.end, relative);
|
||||
let control = match element.control {
|
||||
Smart::Auto => {
|
||||
@ -178,7 +182,7 @@ pub fn layout_curve(
|
||||
}
|
||||
|
||||
CurveComponent::Cubic(element) => {
|
||||
let relative = element.relative(styles);
|
||||
let relative = element.relative.get(styles);
|
||||
let end = builder.resolve_point(element.end, relative);
|
||||
let c1 = match element.control_start {
|
||||
Some(Smart::Custom(p)) => builder.resolve_point(p, relative),
|
||||
@ -193,7 +197,7 @@ pub fn layout_curve(
|
||||
}
|
||||
|
||||
CurveComponent::Close(element) => {
|
||||
builder.close(element.mode(styles));
|
||||
builder.close(element.mode.get(styles));
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -208,9 +212,9 @@ pub fn layout_curve(
|
||||
}
|
||||
|
||||
// Prepare fill and stroke.
|
||||
let fill = elem.fill(styles);
|
||||
let fill_rule = elem.fill_rule(styles);
|
||||
let stroke = match elem.stroke(styles) {
|
||||
let fill = elem.fill.get_cloned(styles);
|
||||
let fill_rule = elem.fill_rule.get(styles);
|
||||
let stroke = match elem.stroke.resolve(styles) {
|
||||
Smart::Auto if fill.is_none() => Some(FixedStroke::default()),
|
||||
Smart::Auto => None,
|
||||
Smart::Custom(stroke) => stroke.map(Stroke::unwrap_or_default),
|
||||
@ -418,9 +422,9 @@ pub fn layout_polygon(
|
||||
}
|
||||
|
||||
// Prepare fill and stroke.
|
||||
let fill = elem.fill(styles);
|
||||
let fill_rule = elem.fill_rule(styles);
|
||||
let stroke = match elem.stroke(styles) {
|
||||
let fill = elem.fill.get_cloned(styles);
|
||||
let fill_rule = elem.fill_rule.get(styles);
|
||||
let stroke = match elem.stroke.resolve(styles) {
|
||||
Smart::Auto if fill.is_none() => Some(FixedStroke::default()),
|
||||
Smart::Auto => None,
|
||||
Smart::Custom(stroke) => stroke.map(Stroke::unwrap_or_default),
|
||||
@ -459,12 +463,12 @@ pub fn layout_rect(
|
||||
styles,
|
||||
region,
|
||||
ShapeKind::Rect,
|
||||
elem.body(styles),
|
||||
elem.fill(styles),
|
||||
elem.stroke(styles),
|
||||
elem.inset(styles),
|
||||
elem.outset(styles),
|
||||
elem.radius(styles),
|
||||
elem.body.get_ref(styles),
|
||||
elem.fill.get_cloned(styles),
|
||||
elem.stroke.resolve(styles),
|
||||
elem.inset.resolve(styles),
|
||||
elem.outset.resolve(styles),
|
||||
elem.radius.resolve(styles),
|
||||
elem.span(),
|
||||
)
|
||||
}
|
||||
@ -484,12 +488,12 @@ pub fn layout_square(
|
||||
styles,
|
||||
region,
|
||||
ShapeKind::Square,
|
||||
elem.body(styles),
|
||||
elem.fill(styles),
|
||||
elem.stroke(styles),
|
||||
elem.inset(styles),
|
||||
elem.outset(styles),
|
||||
elem.radius(styles),
|
||||
elem.body.get_ref(styles),
|
||||
elem.fill.get_cloned(styles),
|
||||
elem.stroke.resolve(styles),
|
||||
elem.inset.resolve(styles),
|
||||
elem.outset.resolve(styles),
|
||||
elem.radius.resolve(styles),
|
||||
elem.span(),
|
||||
)
|
||||
}
|
||||
@ -509,11 +513,11 @@ pub fn layout_ellipse(
|
||||
styles,
|
||||
region,
|
||||
ShapeKind::Ellipse,
|
||||
elem.body(styles),
|
||||
elem.fill(styles),
|
||||
elem.stroke(styles).map(|s| Sides::splat(Some(s))),
|
||||
elem.inset(styles),
|
||||
elem.outset(styles),
|
||||
elem.body.get_ref(styles),
|
||||
elem.fill.get_cloned(styles),
|
||||
elem.stroke.resolve(styles).map(|s| Sides::splat(Some(s))),
|
||||
elem.inset.resolve(styles),
|
||||
elem.outset.resolve(styles),
|
||||
Corners::splat(None),
|
||||
elem.span(),
|
||||
)
|
||||
@ -534,11 +538,11 @@ pub fn layout_circle(
|
||||
styles,
|
||||
region,
|
||||
ShapeKind::Circle,
|
||||
elem.body(styles),
|
||||
elem.fill(styles),
|
||||
elem.stroke(styles).map(|s| Sides::splat(Some(s))),
|
||||
elem.inset(styles),
|
||||
elem.outset(styles),
|
||||
elem.body.get_ref(styles),
|
||||
elem.fill.get_cloned(styles),
|
||||
elem.stroke.resolve(styles).map(|s| Sides::splat(Some(s))),
|
||||
elem.inset.resolve(styles),
|
||||
elem.outset.resolve(styles),
|
||||
Corners::splat(None),
|
||||
elem.span(),
|
||||
)
|
||||
|
@ -19,12 +19,12 @@ pub fn layout_stack(
|
||||
regions: Regions,
|
||||
) -> SourceResult<Fragment> {
|
||||
let mut layouter =
|
||||
StackLayouter::new(elem.span(), elem.dir(styles), locator, styles, regions);
|
||||
StackLayouter::new(elem.span(), elem.dir.get(styles), locator, styles, regions);
|
||||
|
||||
let axis = layouter.dir.axis();
|
||||
|
||||
// Spacing to insert before the next block.
|
||||
let spacing = elem.spacing(styles);
|
||||
let spacing = elem.spacing.get(styles);
|
||||
let mut deferred = None;
|
||||
|
||||
for child in &elem.children {
|
||||
@ -167,11 +167,11 @@ impl<'a> StackLayouter<'a> {
|
||||
|
||||
// Block-axis alignment of the `AlignElem` is respected by stacks.
|
||||
let align = if let Some(align) = block.to_packed::<AlignElem>() {
|
||||
align.alignment(styles)
|
||||
align.alignment.get(styles)
|
||||
} else if let Some(styled) = block.to_packed::<StyledElem>() {
|
||||
AlignElem::alignment_in(styles.chain(&styled.styles))
|
||||
styles.chain(&styled.styles).get(AlignElem::alignment)
|
||||
} else {
|
||||
AlignElem::alignment_in(styles)
|
||||
styles.get(AlignElem::alignment)
|
||||
}
|
||||
.resolve(styles);
|
||||
|
||||
|
@ -20,7 +20,7 @@ pub fn layout_move(
|
||||
region: Region,
|
||||
) -> SourceResult<Frame> {
|
||||
let mut frame = crate::layout_frame(engine, &elem.body, locator, styles, region)?;
|
||||
let delta = Axes::new(elem.dx(styles), elem.dy(styles)).resolve(styles);
|
||||
let delta = Axes::new(elem.dx.resolve(styles), elem.dy.resolve(styles));
|
||||
let delta = delta.zip_map(region.size, Rel::relative_to);
|
||||
frame.translate(delta.to_point());
|
||||
Ok(frame)
|
||||
@ -35,8 +35,8 @@ pub fn layout_rotate(
|
||||
styles: StyleChain,
|
||||
region: Region,
|
||||
) -> SourceResult<Frame> {
|
||||
let angle = elem.angle(styles);
|
||||
let align = elem.origin(styles).resolve(styles);
|
||||
let angle = elem.angle.get(styles);
|
||||
let align = elem.origin.resolve(styles);
|
||||
|
||||
// Compute the new region's approximate size.
|
||||
let is_finite = region.size.is_finite();
|
||||
@ -55,7 +55,7 @@ pub fn layout_rotate(
|
||||
&elem.body,
|
||||
Transform::rotate(angle),
|
||||
align,
|
||||
elem.reflow(styles),
|
||||
elem.reflow.get(styles),
|
||||
)
|
||||
}
|
||||
|
||||
@ -83,8 +83,8 @@ pub fn layout_scale(
|
||||
styles,
|
||||
&elem.body,
|
||||
Transform::scale(scale.x, scale.y),
|
||||
elem.origin(styles).resolve(styles),
|
||||
elem.reflow(styles),
|
||||
elem.origin.resolve(styles),
|
||||
elem.reflow.get(styles),
|
||||
)
|
||||
}
|
||||
|
||||
@ -121,13 +121,13 @@ fn resolve_scale(
|
||||
});
|
||||
|
||||
let x = resolve_axis(
|
||||
elem.x(styles),
|
||||
elem.x.get(styles),
|
||||
|| size.as_ref().map(|size| size.x).map_err(Clone::clone),
|
||||
styles,
|
||||
)?;
|
||||
|
||||
let y = resolve_axis(
|
||||
elem.y(styles),
|
||||
elem.y.get(styles),
|
||||
|| size.as_ref().map(|size| size.y).map_err(Clone::clone),
|
||||
styles,
|
||||
)?;
|
||||
@ -152,9 +152,9 @@ pub fn layout_skew(
|
||||
styles: StyleChain,
|
||||
region: Region,
|
||||
) -> SourceResult<Frame> {
|
||||
let ax = elem.ax(styles);
|
||||
let ay = elem.ay(styles);
|
||||
let align = elem.origin(styles).resolve(styles);
|
||||
let ax = elem.ax.get(styles);
|
||||
let ay = elem.ay.get(styles);
|
||||
let align = elem.origin.resolve(styles);
|
||||
|
||||
// Compute the new region's approximate size.
|
||||
let size = if region.size.is_finite() {
|
||||
@ -172,7 +172,7 @@ pub fn layout_skew(
|
||||
&elem.body,
|
||||
Transform::skew(ax, ay),
|
||||
align,
|
||||
elem.reflow(styles),
|
||||
elem.reflow.get(styles),
|
||||
)
|
||||
}
|
||||
|
||||
|
@ -2,52 +2,54 @@ use std::any::TypeId;
|
||||
use std::cmp::Ordering;
|
||||
use std::fmt::{self, Debug};
|
||||
use std::hash::Hash;
|
||||
use std::ptr::NonNull;
|
||||
use std::sync::LazyLock;
|
||||
use std::sync::OnceLock;
|
||||
|
||||
use ecow::EcoString;
|
||||
use smallvec::SmallVec;
|
||||
#[doc(inline)]
|
||||
pub use typst_macros::elem;
|
||||
use typst_utils::Static;
|
||||
|
||||
use crate::diag::SourceResult;
|
||||
use crate::engine::Engine;
|
||||
use crate::foundations::{
|
||||
cast, Args, Content, Dict, FieldAccessError, Func, ParamInfo, Repr, Scope, Selector,
|
||||
StyleChain, Styles, Value,
|
||||
cast, Args, Content, ContentVtable, FieldAccessError, Func, ParamInfo, Repr, Scope,
|
||||
Selector, StyleChain, Styles, Value,
|
||||
};
|
||||
use crate::text::{Lang, Region};
|
||||
|
||||
/// A document element.
|
||||
#[derive(Copy, Clone, Eq, PartialEq, Hash)]
|
||||
pub struct Element(Static<NativeElementData>);
|
||||
pub struct Element(Static<ContentVtable>);
|
||||
|
||||
impl Element {
|
||||
/// Get the element for `T`.
|
||||
pub fn of<T: NativeElement>() -> Self {
|
||||
T::elem()
|
||||
pub const fn of<T: NativeElement>() -> Self {
|
||||
T::ELEM
|
||||
}
|
||||
|
||||
/// Get the element for `T`.
|
||||
pub const fn from_vtable(vtable: &'static ContentVtable) -> Self {
|
||||
Self(Static(vtable))
|
||||
}
|
||||
|
||||
/// The element's normal name (e.g. `enum`).
|
||||
pub fn name(self) -> &'static str {
|
||||
self.0.name
|
||||
self.vtable().name
|
||||
}
|
||||
|
||||
/// The element's title case name, for use in documentation
|
||||
/// (e.g. `Numbered List`).
|
||||
pub fn title(&self) -> &'static str {
|
||||
self.0.title
|
||||
self.vtable().title
|
||||
}
|
||||
|
||||
/// Documentation for the element (as Markdown).
|
||||
pub fn docs(&self) -> &'static str {
|
||||
self.0.docs
|
||||
self.vtable().docs
|
||||
}
|
||||
|
||||
/// Search keywords for the element.
|
||||
pub fn keywords(&self) -> &'static [&'static str] {
|
||||
self.0.keywords
|
||||
self.vtable().keywords
|
||||
}
|
||||
|
||||
/// Construct an instance of this element.
|
||||
@ -56,12 +58,12 @@ impl Element {
|
||||
engine: &mut Engine,
|
||||
args: &mut Args,
|
||||
) -> SourceResult<Content> {
|
||||
(self.0.construct)(engine, args)
|
||||
(self.vtable().construct)(engine, args)
|
||||
}
|
||||
|
||||
/// Execute the set rule for the element and return the resulting style map.
|
||||
pub fn set(self, engine: &mut Engine, mut args: Args) -> SourceResult<Styles> {
|
||||
let styles = (self.0.set)(engine, &mut args)?;
|
||||
let styles = (self.vtable().set)(engine, &mut args)?;
|
||||
args.finish()?;
|
||||
Ok(styles)
|
||||
}
|
||||
@ -77,12 +79,7 @@ impl Element {
|
||||
/// Whether the element has the given capability where the capability is
|
||||
/// given by a `TypeId`.
|
||||
pub fn can_type_id(self, type_id: TypeId) -> bool {
|
||||
(self.0.vtable)(type_id).is_some()
|
||||
}
|
||||
|
||||
/// The VTable for capabilities dispatch.
|
||||
pub fn vtable(self) -> fn(of: TypeId) -> Option<NonNull<()>> {
|
||||
self.0.vtable
|
||||
(self.vtable().capability)(type_id).is_some()
|
||||
}
|
||||
|
||||
/// Create a selector for this element.
|
||||
@ -98,12 +95,29 @@ impl Element {
|
||||
|
||||
/// The element's associated scope of sub-definition.
|
||||
pub fn scope(&self) -> &'static Scope {
|
||||
&(self.0).0.scope
|
||||
(self.vtable().store)().scope.get_or_init(|| (self.vtable().scope)())
|
||||
}
|
||||
|
||||
/// Details about the element's fields.
|
||||
pub fn params(&self) -> &'static [ParamInfo] {
|
||||
&(self.0).0.params
|
||||
(self.vtable().store)().params.get_or_init(|| {
|
||||
self.vtable()
|
||||
.fields
|
||||
.iter()
|
||||
.filter(|field| !field.synthesized)
|
||||
.map(|field| ParamInfo {
|
||||
name: field.name,
|
||||
docs: field.docs,
|
||||
input: (field.input)(),
|
||||
default: field.default,
|
||||
positional: field.positional,
|
||||
named: !field.positional,
|
||||
variadic: field.variadic,
|
||||
required: field.required,
|
||||
settable: field.settable,
|
||||
})
|
||||
.collect()
|
||||
})
|
||||
}
|
||||
|
||||
/// Extract the field ID for the given field name.
|
||||
@ -111,7 +125,7 @@ impl Element {
|
||||
if name == "label" {
|
||||
return Some(255);
|
||||
}
|
||||
(self.0.field_id)(name)
|
||||
(self.vtable().field_id)(name)
|
||||
}
|
||||
|
||||
/// Extract the field name for the given field ID.
|
||||
@ -119,7 +133,7 @@ impl Element {
|
||||
if id == 255 {
|
||||
return Some("label");
|
||||
}
|
||||
(self.0.field_name)(id)
|
||||
self.vtable().field(id).map(|data| data.name)
|
||||
}
|
||||
|
||||
/// Extract the value of the field for the given field ID and style chain.
|
||||
@ -128,12 +142,20 @@ impl Element {
|
||||
id: u8,
|
||||
styles: StyleChain,
|
||||
) -> Result<Value, FieldAccessError> {
|
||||
(self.0.field_from_styles)(id, styles)
|
||||
self.vtable()
|
||||
.field(id)
|
||||
.and_then(|field| (field.get_from_styles)(styles))
|
||||
.ok_or(FieldAccessError::Unknown)
|
||||
}
|
||||
|
||||
/// The element's local name, if any.
|
||||
pub fn local_name(&self, lang: Lang, region: Option<Region>) -> Option<&'static str> {
|
||||
(self.0).0.local_name.map(|f| f(lang, region))
|
||||
self.vtable().local_name.map(|f| f(lang, region))
|
||||
}
|
||||
|
||||
/// Retrieves the element's vtable for dynamic dispatch.
|
||||
pub(super) fn vtable(&self) -> &'static ContentVtable {
|
||||
(self.0).0
|
||||
}
|
||||
}
|
||||
|
||||
@ -167,84 +189,34 @@ cast! {
|
||||
v: Func => v.element().ok_or("expected element")?,
|
||||
}
|
||||
|
||||
/// A Typst element that is defined by a native Rust type.
|
||||
pub trait NativeElement:
|
||||
Debug
|
||||
+ Clone
|
||||
+ PartialEq
|
||||
+ Hash
|
||||
+ Construct
|
||||
+ Set
|
||||
+ Capable
|
||||
+ Fields
|
||||
+ Repr
|
||||
+ Send
|
||||
+ Sync
|
||||
+ 'static
|
||||
{
|
||||
/// Get the element for the native Rust element.
|
||||
fn elem() -> Element
|
||||
where
|
||||
Self: Sized,
|
||||
{
|
||||
Element::from(Self::data())
|
||||
}
|
||||
|
||||
/// Pack the element into type-erased content.
|
||||
fn pack(self) -> Content
|
||||
where
|
||||
Self: Sized,
|
||||
{
|
||||
Content::new(self)
|
||||
}
|
||||
|
||||
/// Get the element data for the native Rust element.
|
||||
fn data() -> &'static NativeElementData
|
||||
where
|
||||
Self: Sized;
|
||||
/// Lazily initialized data for an element.
|
||||
#[derive(Default)]
|
||||
pub struct LazyElementStore {
|
||||
pub scope: OnceLock<Scope>,
|
||||
pub params: OnceLock<Vec<ParamInfo>>,
|
||||
}
|
||||
|
||||
/// Used to cast an element to a trait object for a trait it implements.
|
||||
impl LazyElementStore {
|
||||
/// Create an empty store.
|
||||
pub const fn new() -> Self {
|
||||
Self { scope: OnceLock::new(), params: OnceLock::new() }
|
||||
}
|
||||
}
|
||||
|
||||
/// A Typst element that is defined by a native Rust type.
|
||||
///
|
||||
/// # Safety
|
||||
/// If the `vtable` function returns `Some(p)`, then `p` must be a valid pointer
|
||||
/// to a vtable of `Packed<Self>` w.r.t to the trait `C` where `capability` is
|
||||
/// `TypeId::of::<dyn C>()`.
|
||||
pub unsafe trait Capable {
|
||||
/// Get the pointer to the vtable for the given capability / trait.
|
||||
fn vtable(capability: TypeId) -> Option<NonNull<()>>;
|
||||
}
|
||||
/// `ELEM` must hold the correct `Element` for `Self`.
|
||||
pub unsafe trait NativeElement:
|
||||
Debug + Clone + Hash + Construct + Set + Send + Sync + 'static
|
||||
{
|
||||
/// The associated element.
|
||||
const ELEM: Element;
|
||||
|
||||
/// Defines how fields of an element are accessed.
|
||||
pub trait Fields {
|
||||
/// An enum with the fields of the element.
|
||||
type Enum
|
||||
where
|
||||
Self: Sized;
|
||||
|
||||
/// Whether the element has the given field set.
|
||||
fn has(&self, id: u8) -> bool;
|
||||
|
||||
/// Get the field with the given field ID.
|
||||
fn field(&self, id: u8) -> Result<Value, FieldAccessError>;
|
||||
|
||||
/// Get the field with the given ID in the presence of styles.
|
||||
fn field_with_styles(
|
||||
&self,
|
||||
id: u8,
|
||||
styles: StyleChain,
|
||||
) -> Result<Value, FieldAccessError>;
|
||||
|
||||
/// Get the field with the given ID from the styles.
|
||||
fn field_from_styles(id: u8, styles: StyleChain) -> Result<Value, FieldAccessError>
|
||||
where
|
||||
Self: Sized;
|
||||
|
||||
/// Resolve all fields with the styles and save them in-place.
|
||||
fn materialize(&mut self, styles: StyleChain);
|
||||
|
||||
/// Get the fields of the element.
|
||||
fn fields(&self) -> Dict;
|
||||
/// Pack the element into type-erased content.
|
||||
fn pack(self) -> Content {
|
||||
Content::new(self)
|
||||
}
|
||||
}
|
||||
|
||||
/// An element's constructor function.
|
||||
@ -266,48 +238,6 @@ pub trait Set {
|
||||
Self: Sized;
|
||||
}
|
||||
|
||||
/// Defines a native element.
|
||||
#[derive(Debug)]
|
||||
pub struct NativeElementData {
|
||||
/// The element's normal name (e.g. `align`), as exposed to Typst.
|
||||
pub name: &'static str,
|
||||
/// The element's title case name (e.g. `Align`).
|
||||
pub title: &'static str,
|
||||
/// The documentation for this element as a string.
|
||||
pub docs: &'static str,
|
||||
/// A list of alternate search terms for this element.
|
||||
pub keywords: &'static [&'static str],
|
||||
/// The constructor for this element (see [`Construct`]).
|
||||
pub construct: fn(&mut Engine, &mut Args) -> SourceResult<Content>,
|
||||
/// Executes this element's set rule (see [`Set`]).
|
||||
pub set: fn(&mut Engine, &mut Args) -> SourceResult<Styles>,
|
||||
/// Gets the vtable for one of this element's capabilities
|
||||
/// (see [`Capable`]).
|
||||
pub vtable: fn(capability: TypeId) -> Option<NonNull<()>>,
|
||||
/// Gets the numeric index of this field by its name.
|
||||
pub field_id: fn(name: &str) -> Option<u8>,
|
||||
/// Gets the name of a field by its numeric index.
|
||||
pub field_name: fn(u8) -> Option<&'static str>,
|
||||
/// Get the field with the given ID in the presence of styles (see [`Fields`]).
|
||||
pub field_from_styles: fn(u8, StyleChain) -> Result<Value, FieldAccessError>,
|
||||
/// Gets the localized name for this element (see [`LocalName`][crate::text::LocalName]).
|
||||
pub local_name: Option<fn(Lang, Option<Region>) -> &'static str>,
|
||||
pub scope: LazyLock<Scope>,
|
||||
/// A list of parameter information for each field.
|
||||
pub params: LazyLock<Vec<ParamInfo>>,
|
||||
}
|
||||
|
||||
impl From<&'static NativeElementData> for Element {
|
||||
fn from(data: &'static NativeElementData) -> Self {
|
||||
Self(Static(data))
|
||||
}
|
||||
}
|
||||
|
||||
cast! {
|
||||
&'static NativeElementData,
|
||||
self => Element::from(self).into_value(),
|
||||
}
|
||||
|
||||
/// Synthesize fields on an element. This happens before execution of any show
|
||||
/// rule.
|
||||
pub trait Synthesize {
|
||||
@ -331,3 +261,9 @@ pub trait ShowSet {
|
||||
/// that should work even in the face of a user-defined show rule.
|
||||
fn show_set(&self, styles: StyleChain) -> Styles;
|
||||
}
|
||||
|
||||
/// Tries to extract the plain-text representation of the element.
|
||||
pub trait PlainText {
|
||||
/// Write this element's plain text into the given buffer.
|
||||
fn plain_text(&self, text: &mut EcoString);
|
||||
}
|
564
crates/typst-library/src/foundations/content/field.rs
Normal file
564
crates/typst-library/src/foundations/content/field.rs
Normal file
@ -0,0 +1,564 @@
|
||||
use std::fmt::{self, Debug};
|
||||
use std::hash::Hash;
|
||||
use std::marker::PhantomData;
|
||||
use std::sync::OnceLock;
|
||||
|
||||
use ecow::{eco_format, EcoString};
|
||||
|
||||
use crate::foundations::{
|
||||
Container, Content, FieldVtable, Fold, FoldFn, IntoValue, NativeElement, Packed,
|
||||
Property, Reflect, Repr, Resolve, StyleChain,
|
||||
};
|
||||
|
||||
/// An accessor for the `I`-th field of the element `E`. Values of this type are
|
||||
/// generated for each field of an element can be used to interact with this
|
||||
/// field programmatically, for example to access the style chain, as in
|
||||
/// `styles.get(TextElem::size)`.
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct Field<E: NativeElement, const I: u8>(pub PhantomData<E>);
|
||||
|
||||
impl<E: NativeElement, const I: u8> Field<E, I> {
|
||||
/// Creates a new zero-sized accessor.
|
||||
pub const fn new() -> Self {
|
||||
Self(PhantomData)
|
||||
}
|
||||
|
||||
/// The index of the projected field.
|
||||
pub const fn index(self) -> u8 {
|
||||
I
|
||||
}
|
||||
|
||||
/// Creates a dynamic property instance for this field.
|
||||
///
|
||||
/// Prefer [`Content::set`] or
|
||||
/// [`Styles::set`](crate::foundations::Styles::set) when working with
|
||||
/// existing content or style value.
|
||||
pub fn set(self, value: E::Type) -> Property
|
||||
where
|
||||
E: SettableProperty<I>,
|
||||
E::Type: Debug + Clone + Hash + Send + Sync + 'static,
|
||||
{
|
||||
Property::new(self, value)
|
||||
}
|
||||
}
|
||||
|
||||
impl<E: NativeElement, const I: u8> Default for Field<E, I> {
|
||||
fn default() -> Self {
|
||||
Self::new()
|
||||
}
|
||||
}
|
||||
|
||||
/// A field that is present on every instance of the element.
|
||||
pub trait RequiredField<const I: u8>: NativeElement {
|
||||
type Type: Clone;
|
||||
|
||||
const FIELD: RequiredFieldData<Self, I>;
|
||||
}
|
||||
|
||||
/// Metadata and routines for a [`RequiredField`].
|
||||
pub struct RequiredFieldData<E: RequiredField<I>, const I: u8> {
|
||||
name: &'static str,
|
||||
docs: &'static str,
|
||||
get: fn(&E) -> &E::Type,
|
||||
}
|
||||
|
||||
impl<E: RequiredField<I>, const I: u8> RequiredFieldData<E, I> {
|
||||
/// Creates the data from its parts. This is called in the `#[elem]` macro.
|
||||
pub const fn new(
|
||||
name: &'static str,
|
||||
docs: &'static str,
|
||||
get: fn(&E) -> &E::Type,
|
||||
) -> Self {
|
||||
Self { name, docs, get }
|
||||
}
|
||||
|
||||
/// Creates the vtable for a `#[required]` field.
|
||||
pub const fn vtable() -> FieldVtable<Packed<E>>
|
||||
where
|
||||
E: RequiredField<I>,
|
||||
E::Type: Reflect + IntoValue + PartialEq,
|
||||
{
|
||||
FieldVtable {
|
||||
name: E::FIELD.name,
|
||||
docs: E::FIELD.docs,
|
||||
positional: true,
|
||||
required: true,
|
||||
variadic: false,
|
||||
settable: false,
|
||||
synthesized: false,
|
||||
input: || <E::Type as Reflect>::input(),
|
||||
default: None,
|
||||
has: |_| true,
|
||||
get: |elem| Some((E::FIELD.get)(elem).clone().into_value()),
|
||||
get_with_styles: |elem, _| Some((E::FIELD.get)(elem).clone().into_value()),
|
||||
get_from_styles: |_| None,
|
||||
materialize: |_, _| {},
|
||||
eq: |a, b| (E::FIELD.get)(a) == (E::FIELD.get)(b),
|
||||
}
|
||||
}
|
||||
|
||||
/// Creates the vtable for a `#[variadic]` field.
|
||||
pub const fn vtable_variadic() -> FieldVtable<Packed<E>>
|
||||
where
|
||||
E: RequiredField<I>,
|
||||
E::Type: Container + IntoValue + PartialEq,
|
||||
<E::Type as Container>::Inner: Reflect,
|
||||
{
|
||||
FieldVtable {
|
||||
name: E::FIELD.name,
|
||||
docs: E::FIELD.docs,
|
||||
positional: true,
|
||||
required: true,
|
||||
variadic: true,
|
||||
settable: false,
|
||||
synthesized: false,
|
||||
input: || <<E::Type as Container>::Inner as Reflect>::input(),
|
||||
default: None,
|
||||
has: |_| true,
|
||||
get: |elem| Some((E::FIELD.get)(elem).clone().into_value()),
|
||||
get_with_styles: |elem, _| Some((E::FIELD.get)(elem).clone().into_value()),
|
||||
get_from_styles: |_| None,
|
||||
materialize: |_, _| {},
|
||||
eq: |a, b| (E::FIELD.get)(a) == (E::FIELD.get)(b),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A field that is initially unset, but may be set through a
|
||||
/// [`Synthesize`](crate::foundations::Synthesize) implementation.
|
||||
pub trait SynthesizedField<const I: u8>: NativeElement {
|
||||
type Type: Clone;
|
||||
|
||||
const FIELD: SynthesizedFieldData<Self, I>;
|
||||
}
|
||||
|
||||
/// Metadata and routines for a [`SynthesizedField`].
|
||||
pub struct SynthesizedFieldData<E: SynthesizedField<I>, const I: u8> {
|
||||
name: &'static str,
|
||||
docs: &'static str,
|
||||
get: fn(&E) -> &Option<E::Type>,
|
||||
}
|
||||
|
||||
impl<E: SynthesizedField<I>, const I: u8> SynthesizedFieldData<E, I> {
|
||||
/// Creates the data from its parts. This is called in the `#[elem]` macro.
|
||||
pub const fn new(
|
||||
name: &'static str,
|
||||
docs: &'static str,
|
||||
get: fn(&E) -> &Option<E::Type>,
|
||||
) -> Self {
|
||||
Self { name, docs, get }
|
||||
}
|
||||
|
||||
/// Creates type-erased metadata and routines for a `#[synthesized]` field.
|
||||
pub const fn vtable() -> FieldVtable<Packed<E>>
|
||||
where
|
||||
E: SynthesizedField<I>,
|
||||
E::Type: Reflect + IntoValue + PartialEq,
|
||||
{
|
||||
FieldVtable {
|
||||
name: E::FIELD.name,
|
||||
docs: E::FIELD.docs,
|
||||
positional: false,
|
||||
required: false,
|
||||
variadic: false,
|
||||
settable: false,
|
||||
synthesized: true,
|
||||
input: || <E::Type as Reflect>::input(),
|
||||
default: None,
|
||||
has: |elem| (E::FIELD.get)(elem).is_some(),
|
||||
get: |elem| (E::FIELD.get)(elem).clone().map(|v| v.into_value()),
|
||||
get_with_styles: |elem, _| {
|
||||
(E::FIELD.get)(elem).clone().map(|v| v.into_value())
|
||||
},
|
||||
get_from_styles: |_| None,
|
||||
materialize: |_, _| {},
|
||||
// Synthesized fields don't affect equality.
|
||||
eq: |_, _| true,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A field that is not actually there. It's only visible in the docs.
|
||||
pub trait ExternalField<const I: u8>: NativeElement {
|
||||
type Type;
|
||||
|
||||
const FIELD: ExternalFieldData<Self, I>;
|
||||
}
|
||||
|
||||
/// Metadata for an [`ExternalField`].
|
||||
pub struct ExternalFieldData<E: ExternalField<I>, const I: u8> {
|
||||
name: &'static str,
|
||||
docs: &'static str,
|
||||
default: fn() -> E::Type,
|
||||
}
|
||||
|
||||
impl<E: ExternalField<I>, const I: u8> ExternalFieldData<E, I> {
|
||||
/// Creates the data from its parts. This is called in the `#[elem]` macro.
|
||||
pub const fn new(
|
||||
name: &'static str,
|
||||
docs: &'static str,
|
||||
default: fn() -> E::Type,
|
||||
) -> Self {
|
||||
Self { name, docs, default }
|
||||
}
|
||||
|
||||
/// Creates type-erased metadata and routines for an `#[external]` field.
|
||||
pub const fn vtable() -> FieldVtable<Packed<E>>
|
||||
where
|
||||
E: ExternalField<I>,
|
||||
E::Type: Reflect + IntoValue,
|
||||
{
|
||||
FieldVtable {
|
||||
name: E::FIELD.name,
|
||||
docs: E::FIELD.docs,
|
||||
positional: false,
|
||||
required: false,
|
||||
variadic: false,
|
||||
settable: false,
|
||||
synthesized: false,
|
||||
input: || <E::Type as Reflect>::input(),
|
||||
default: Some(|| (E::FIELD.default)().into_value()),
|
||||
has: |_| false,
|
||||
get: |_| None,
|
||||
get_with_styles: |_, _| None,
|
||||
get_from_styles: |_| None,
|
||||
materialize: |_, _| {},
|
||||
eq: |_, _| true,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A field that has a default value and can be configured via a set rule, but
|
||||
/// can also present on elements and be present in the constructor.
|
||||
pub trait SettableField<const I: u8>: NativeElement {
|
||||
type Type: Clone;
|
||||
|
||||
const FIELD: SettableFieldData<Self, I>;
|
||||
}
|
||||
|
||||
/// Metadata and routines for a [`SettableField`].
|
||||
pub struct SettableFieldData<E: SettableField<I>, const I: u8> {
|
||||
get: fn(&E) -> &Settable<E, I>,
|
||||
get_mut: fn(&mut E) -> &mut Settable<E, I>,
|
||||
property: SettablePropertyData<E, I>,
|
||||
}
|
||||
|
||||
impl<E: SettableField<I>, const I: u8> SettableFieldData<E, I> {
|
||||
/// Creates the data from its parts. This is called in the `#[elem]` macro.
|
||||
pub const fn new(
|
||||
name: &'static str,
|
||||
docs: &'static str,
|
||||
positional: bool,
|
||||
get: fn(&E) -> &Settable<E, I>,
|
||||
get_mut: fn(&mut E) -> &mut Settable<E, I>,
|
||||
default: fn() -> E::Type,
|
||||
slot: fn() -> &'static OnceLock<E::Type>,
|
||||
) -> Self {
|
||||
Self {
|
||||
get,
|
||||
get_mut,
|
||||
property: SettablePropertyData::new(name, docs, positional, default, slot),
|
||||
}
|
||||
}
|
||||
|
||||
/// Ensures that the property is folded on every access. See the
|
||||
/// documentation of the [`Fold`] trait for more details.
|
||||
pub const fn with_fold(mut self) -> Self
|
||||
where
|
||||
E::Type: Fold,
|
||||
{
|
||||
self.property.fold = Some(E::Type::fold);
|
||||
self
|
||||
}
|
||||
|
||||
/// Creates type-erased metadata and routines for a normal settable field.
|
||||
pub const fn vtable() -> FieldVtable<Packed<E>>
|
||||
where
|
||||
E: SettableField<I>,
|
||||
E::Type: Reflect + IntoValue + PartialEq,
|
||||
{
|
||||
FieldVtable {
|
||||
name: E::FIELD.property.name,
|
||||
docs: E::FIELD.property.docs,
|
||||
positional: E::FIELD.property.positional,
|
||||
required: false,
|
||||
variadic: false,
|
||||
settable: true,
|
||||
synthesized: false,
|
||||
input: || <E::Type as Reflect>::input(),
|
||||
default: Some(|| E::default().into_value()),
|
||||
has: |elem| (E::FIELD.get)(elem).is_set(),
|
||||
get: |elem| (E::FIELD.get)(elem).as_option().clone().map(|v| v.into_value()),
|
||||
get_with_styles: |elem, styles| {
|
||||
Some((E::FIELD.get)(elem).get_cloned(styles).into_value())
|
||||
},
|
||||
get_from_styles: |styles| {
|
||||
Some(styles.get_cloned::<E, I>(Field::new()).into_value())
|
||||
},
|
||||
materialize: |elem, styles| {
|
||||
if !(E::FIELD.get)(elem).is_set() {
|
||||
(E::FIELD.get_mut)(elem).set(styles.get_cloned::<E, I>(Field::new()));
|
||||
}
|
||||
},
|
||||
eq: |a, b| (E::FIELD.get)(a).as_option() == (E::FIELD.get)(b).as_option(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A field that has a default value and can be configured via a set rule, but
|
||||
/// is never present on elements.
|
||||
///
|
||||
/// This is provided for all `SettableField` impls through a blanket impl. In
|
||||
/// the case of `#[ghost]` fields, which only live in the style chain and not in
|
||||
/// elements, it is also implemented manually.
|
||||
pub trait SettableProperty<const I: u8>: NativeElement {
|
||||
type Type: Clone;
|
||||
|
||||
const FIELD: SettablePropertyData<Self, I>;
|
||||
const FOLD: Option<FoldFn<Self::Type>> = Self::FIELD.fold;
|
||||
|
||||
/// Produces an instance of the property's default value.
|
||||
fn default() -> Self::Type {
|
||||
// Avoid recreating an expensive instance over and over, but also
|
||||
// avoid unnecessary lazy initialization for cheap types.
|
||||
if std::mem::needs_drop::<Self::Type>() {
|
||||
Self::default_ref().clone()
|
||||
} else {
|
||||
(Self::FIELD.default)()
|
||||
}
|
||||
}
|
||||
|
||||
/// Produces a static reference to this property's default value.
|
||||
fn default_ref() -> &'static Self::Type {
|
||||
(Self::FIELD.slot)().get_or_init(Self::FIELD.default)
|
||||
}
|
||||
}
|
||||
|
||||
impl<T, const I: u8> SettableProperty<I> for T
|
||||
where
|
||||
T: SettableField<I>,
|
||||
{
|
||||
type Type = <Self as SettableField<I>>::Type;
|
||||
|
||||
const FIELD: SettablePropertyData<Self, I> =
|
||||
<Self as SettableField<I>>::FIELD.property;
|
||||
}
|
||||
|
||||
/// Metadata and routines for a [`SettableProperty`].
|
||||
pub struct SettablePropertyData<E: SettableProperty<I>, const I: u8> {
|
||||
name: &'static str,
|
||||
docs: &'static str,
|
||||
positional: bool,
|
||||
default: fn() -> E::Type,
|
||||
slot: fn() -> &'static OnceLock<E::Type>,
|
||||
fold: Option<FoldFn<E::Type>>,
|
||||
}
|
||||
|
||||
impl<E: SettableProperty<I>, const I: u8> SettablePropertyData<E, I> {
|
||||
/// Creates the data from its parts. This is called in the `#[elem]` macro.
|
||||
pub const fn new(
|
||||
name: &'static str,
|
||||
docs: &'static str,
|
||||
positional: bool,
|
||||
default: fn() -> E::Type,
|
||||
slot: fn() -> &'static OnceLock<E::Type>,
|
||||
) -> Self {
|
||||
Self { name, docs, positional, default, slot, fold: None }
|
||||
}
|
||||
|
||||
/// Ensures that the property is folded on every access. See the
|
||||
/// documentation of the [`Fold`] trait for more details.
|
||||
pub const fn with_fold(self) -> Self
|
||||
where
|
||||
E::Type: Fold,
|
||||
{
|
||||
Self { fold: Some(E::Type::fold), ..self }
|
||||
}
|
||||
|
||||
/// Creates type-erased metadata and routines for a `#[ghost]` field.
|
||||
pub const fn vtable() -> FieldVtable<Packed<E>>
|
||||
where
|
||||
E: SettableProperty<I>,
|
||||
E::Type: Reflect + IntoValue + PartialEq,
|
||||
{
|
||||
FieldVtable {
|
||||
name: E::FIELD.name,
|
||||
docs: E::FIELD.docs,
|
||||
positional: E::FIELD.positional,
|
||||
required: false,
|
||||
variadic: false,
|
||||
settable: true,
|
||||
synthesized: false,
|
||||
input: || <E::Type as Reflect>::input(),
|
||||
default: Some(|| E::default().into_value()),
|
||||
has: |_| false,
|
||||
get: |_| None,
|
||||
get_with_styles: |_, styles| {
|
||||
Some(styles.get_cloned::<E, I>(Field::new()).into_value())
|
||||
},
|
||||
get_from_styles: |styles| {
|
||||
Some(styles.get_cloned::<E, I>(Field::new()).into_value())
|
||||
},
|
||||
materialize: |_, _| {},
|
||||
eq: |_, _| true,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A settable property that can be accessed by reference (because it is not
|
||||
/// folded).
|
||||
pub trait RefableProperty<const I: u8>: SettableProperty<I> {}
|
||||
|
||||
/// A settable field of an element.
|
||||
///
|
||||
/// The field can be in two states: Unset or present.
|
||||
///
|
||||
/// See [`StyleChain`] for more details about the available accessor methods.
|
||||
#[derive(Copy, Clone, Hash)]
|
||||
pub struct Settable<E: NativeElement, const I: u8>(Option<E::Type>)
|
||||
where
|
||||
E: SettableProperty<I>;
|
||||
|
||||
impl<E: NativeElement, const I: u8> Settable<E, I>
|
||||
where
|
||||
E: SettableProperty<I>,
|
||||
{
|
||||
/// Creates a new unset instance.
|
||||
pub fn new() -> Self {
|
||||
Self(None)
|
||||
}
|
||||
|
||||
/// Sets the instance to a value.
|
||||
pub fn set(&mut self, value: E::Type) {
|
||||
self.0 = Some(value);
|
||||
}
|
||||
|
||||
/// Clears the value from the instance.
|
||||
pub fn unset(&mut self) {
|
||||
self.0 = None;
|
||||
}
|
||||
|
||||
/// Views the type as an [`Option`] which is `Some` if the type is set
|
||||
/// and `None` if it is unset.
|
||||
pub fn as_option(&self) -> &Option<E::Type> {
|
||||
&self.0
|
||||
}
|
||||
|
||||
/// Views the type as a mutable [`Option`].
|
||||
pub fn as_option_mut(&mut self) -> &mut Option<E::Type> {
|
||||
&mut self.0
|
||||
}
|
||||
|
||||
/// Whether the field is set.
|
||||
pub fn is_set(&self) -> bool {
|
||||
self.0.is_some()
|
||||
}
|
||||
|
||||
/// Retrieves the value given styles. The styles are used if the value is
|
||||
/// unset.
|
||||
pub fn get<'a>(&'a self, styles: StyleChain<'a>) -> E::Type
|
||||
where
|
||||
E::Type: Copy,
|
||||
{
|
||||
self.get_cloned(styles)
|
||||
}
|
||||
|
||||
/// Retrieves and clones the value given styles. The styles are used if the
|
||||
/// value is unset or if it needs folding.
|
||||
pub fn get_cloned<'a>(&'a self, styles: StyleChain<'a>) -> E::Type {
|
||||
if let Some(fold) = E::FOLD {
|
||||
let mut res = styles.get_cloned::<E, I>(Field::new());
|
||||
if let Some(value) = &self.0 {
|
||||
res = fold(value.clone(), res);
|
||||
}
|
||||
res
|
||||
} else if let Some(value) = &self.0 {
|
||||
value.clone()
|
||||
} else {
|
||||
styles.get_cloned::<E, I>(Field::new())
|
||||
}
|
||||
}
|
||||
|
||||
/// Retrieves a reference to the value given styles. The styles are used if
|
||||
/// the value is unset.
|
||||
pub fn get_ref<'a>(&'a self, styles: StyleChain<'a>) -> &'a E::Type
|
||||
where
|
||||
E: RefableProperty<I>,
|
||||
{
|
||||
if let Some(value) = &self.0 {
|
||||
value
|
||||
} else {
|
||||
styles.get_ref::<E, I>(Field::new())
|
||||
}
|
||||
}
|
||||
|
||||
/// Retrieves the value and then immediately [resolves](Resolve) it.
|
||||
pub fn resolve<'a>(&'a self, styles: StyleChain<'a>) -> <E::Type as Resolve>::Output
|
||||
where
|
||||
E::Type: Resolve,
|
||||
{
|
||||
self.get_cloned(styles).resolve(styles)
|
||||
}
|
||||
}
|
||||
|
||||
impl<E: NativeElement, const I: u8> Debug for Settable<E, I>
|
||||
where
|
||||
E: SettableProperty<I>,
|
||||
E::Type: Debug,
|
||||
{
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
self.0.fmt(f)
|
||||
}
|
||||
}
|
||||
|
||||
impl<E: NativeElement, const I: u8> Default for Settable<E, I>
|
||||
where
|
||||
E: SettableProperty<I>,
|
||||
{
|
||||
fn default() -> Self {
|
||||
Self(None)
|
||||
}
|
||||
}
|
||||
|
||||
impl<E: NativeElement, const I: u8> From<Option<E::Type>> for Settable<E, I>
|
||||
where
|
||||
E: SettableProperty<I>,
|
||||
{
|
||||
fn from(value: Option<E::Type>) -> Self {
|
||||
Self(value)
|
||||
}
|
||||
}
|
||||
|
||||
/// An error arising when trying to access a field of content.
|
||||
#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
|
||||
pub enum FieldAccessError {
|
||||
Unknown,
|
||||
Unset,
|
||||
}
|
||||
|
||||
impl FieldAccessError {
|
||||
/// Formats the error message given the content and the field name.
|
||||
#[cold]
|
||||
pub fn message(self, content: &Content, field: &str) -> EcoString {
|
||||
let elem_name = content.elem().name();
|
||||
match self {
|
||||
FieldAccessError::Unknown => {
|
||||
eco_format!("{elem_name} does not have field {}", field.repr())
|
||||
}
|
||||
FieldAccessError::Unset => {
|
||||
eco_format!(
|
||||
"field {} in {elem_name} is not known at this point",
|
||||
field.repr()
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Formats the error message for an `at` calls without a default value.
|
||||
#[cold]
|
||||
pub fn message_no_default(self, content: &Content, field: &str) -> EcoString {
|
||||
let mut msg = self.message(content, field);
|
||||
msg.push_str(" and no default was specified");
|
||||
msg
|
||||
}
|
||||
}
|
@ -1,23 +1,33 @@
|
||||
use std::any::TypeId;
|
||||
mod element;
|
||||
mod field;
|
||||
mod packed;
|
||||
mod raw;
|
||||
mod vtable;
|
||||
|
||||
pub use self::element::*;
|
||||
pub use self::field::*;
|
||||
pub use self::packed::Packed;
|
||||
pub use self::vtable::{ContentVtable, FieldVtable};
|
||||
#[doc(inline)]
|
||||
pub use typst_macros::elem;
|
||||
|
||||
use std::fmt::{self, Debug, Formatter};
|
||||
use std::hash::{Hash, Hasher};
|
||||
use std::hash::Hash;
|
||||
use std::iter::{self, Sum};
|
||||
use std::marker::PhantomData;
|
||||
use std::ops::{Add, AddAssign, ControlFlow, Deref, DerefMut};
|
||||
use std::sync::Arc;
|
||||
use std::ops::{Add, AddAssign, ControlFlow};
|
||||
|
||||
use comemo::Tracked;
|
||||
use ecow::{eco_format, EcoString};
|
||||
use serde::{Serialize, Serializer};
|
||||
|
||||
use typst_syntax::Span;
|
||||
use typst_utils::{fat, singleton, LazyHash, SmallBitSet};
|
||||
use typst_utils::singleton;
|
||||
|
||||
use crate::diag::{SourceResult, StrResult};
|
||||
use crate::engine::Engine;
|
||||
use crate::foundations::{
|
||||
elem, func, scope, ty, Context, Dict, Element, Fields, IntoValue, Label,
|
||||
NativeElement, Recipe, RecipeIndex, Repr, Selector, Str, Style, StyleChain, Styles,
|
||||
Value,
|
||||
func, repr, scope, ty, Context, Dict, IntoValue, Label, Property, Recipe,
|
||||
RecipeIndex, Repr, Selector, Str, Style, StyleChain, Styles, Value,
|
||||
};
|
||||
use crate::introspection::Location;
|
||||
use crate::layout::{AlignElem, Alignment, Axes, Length, MoveElem, PadElem, Rel, Sides};
|
||||
@ -68,43 +78,14 @@ use crate::text::UnderlineElem;
|
||||
/// elements the content is composed of and what fields they have.
|
||||
/// Alternatively, you can inspect the output of the [`repr`] function.
|
||||
#[ty(scope, cast)]
|
||||
#[derive(Clone, Hash)]
|
||||
#[allow(clippy::derived_hash_with_manual_eq)]
|
||||
pub struct Content {
|
||||
/// The partially element-dependent inner data.
|
||||
inner: Arc<Inner<dyn Bounds>>,
|
||||
/// The element's source code location.
|
||||
span: Span,
|
||||
}
|
||||
|
||||
/// The inner representation behind the `Arc`.
|
||||
#[derive(Hash)]
|
||||
struct Inner<T: ?Sized + 'static> {
|
||||
/// An optional label attached to the element.
|
||||
label: Option<Label>,
|
||||
/// The element's location which identifies it in the layouted output.
|
||||
location: Option<Location>,
|
||||
/// Manages the element during realization.
|
||||
/// - If bit 0 is set, the element is prepared.
|
||||
/// - If bit n is set, the element is guarded against the n-th show rule
|
||||
/// recipe from the top of the style chain (counting from 1).
|
||||
lifecycle: SmallBitSet,
|
||||
/// The element's raw data.
|
||||
elem: LazyHash<T>,
|
||||
}
|
||||
#[derive(Clone, PartialEq, Hash)]
|
||||
#[repr(transparent)]
|
||||
pub struct Content(raw::RawContent);
|
||||
|
||||
impl Content {
|
||||
/// Creates a new content from an element.
|
||||
pub fn new<T: NativeElement>(elem: T) -> Self {
|
||||
Self {
|
||||
inner: Arc::new(Inner {
|
||||
label: None,
|
||||
location: None,
|
||||
lifecycle: SmallBitSet::new(),
|
||||
elem: elem.into(),
|
||||
}),
|
||||
span: Span::detached(),
|
||||
}
|
||||
Self(raw::RawContent::new(elem))
|
||||
}
|
||||
|
||||
/// Creates a empty sequence content.
|
||||
@ -114,25 +95,25 @@ impl Content {
|
||||
|
||||
/// Get the element of this content.
|
||||
pub fn elem(&self) -> Element {
|
||||
self.inner.elem.dyn_elem()
|
||||
self.0.elem()
|
||||
}
|
||||
|
||||
/// Get the span of the content.
|
||||
pub fn span(&self) -> Span {
|
||||
self.span
|
||||
self.0.span()
|
||||
}
|
||||
|
||||
/// Set the span of the content.
|
||||
pub fn spanned(mut self, span: Span) -> Self {
|
||||
if self.span.is_detached() {
|
||||
self.span = span;
|
||||
if self.0.span().is_detached() {
|
||||
*self.0.span_mut() = span;
|
||||
}
|
||||
self
|
||||
}
|
||||
|
||||
/// Get the label of the content.
|
||||
pub fn label(&self) -> Option<Label> {
|
||||
self.inner.label
|
||||
self.0.meta().label
|
||||
}
|
||||
|
||||
/// Attach a label to the content.
|
||||
@ -143,7 +124,7 @@ impl Content {
|
||||
|
||||
/// Set the label of the content.
|
||||
pub fn set_label(&mut self, label: Label) {
|
||||
self.make_mut().label = Some(label);
|
||||
self.0.meta_mut().label = Some(label);
|
||||
}
|
||||
|
||||
/// Assigns a location to the content.
|
||||
@ -159,28 +140,28 @@ impl Content {
|
||||
|
||||
/// Set the location of the content.
|
||||
pub fn set_location(&mut self, location: Location) {
|
||||
self.make_mut().location = Some(location);
|
||||
self.0.meta_mut().location = Some(location);
|
||||
}
|
||||
|
||||
/// Check whether a show rule recipe is disabled.
|
||||
pub fn is_guarded(&self, index: RecipeIndex) -> bool {
|
||||
self.inner.lifecycle.contains(index.0)
|
||||
self.0.meta().lifecycle.contains(index.0)
|
||||
}
|
||||
|
||||
/// Disable a show rule recipe.
|
||||
pub fn guarded(mut self, index: RecipeIndex) -> Self {
|
||||
self.make_mut().lifecycle.insert(index.0);
|
||||
self.0.meta_mut().lifecycle.insert(index.0);
|
||||
self
|
||||
}
|
||||
|
||||
/// Whether this content has already been prepared.
|
||||
pub fn is_prepared(&self) -> bool {
|
||||
self.inner.lifecycle.contains(0)
|
||||
self.0.meta().lifecycle.contains(0)
|
||||
}
|
||||
|
||||
/// Mark this content as prepared.
|
||||
pub fn mark_prepared(&mut self) {
|
||||
self.make_mut().lifecycle.insert(0);
|
||||
self.0.meta_mut().lifecycle.insert(0);
|
||||
}
|
||||
|
||||
/// Get a field by ID.
|
||||
@ -198,9 +179,14 @@ impl Content {
|
||||
return Ok(label.into_value());
|
||||
}
|
||||
}
|
||||
match styles {
|
||||
Some(styles) => self.inner.elem.field_with_styles(id, styles),
|
||||
None => self.inner.elem.field(id),
|
||||
|
||||
match self.0.handle().field(id) {
|
||||
Some(handle) => match styles {
|
||||
Some(styles) => handle.get_with_styles(styles),
|
||||
None => handle.get(),
|
||||
}
|
||||
.ok_or(FieldAccessError::Unset),
|
||||
None => Err(FieldAccessError::Unknown),
|
||||
}
|
||||
}
|
||||
|
||||
@ -215,8 +201,11 @@ impl Content {
|
||||
.map(|label| label.into_value())
|
||||
.ok_or(FieldAccessError::Unknown);
|
||||
}
|
||||
let id = self.elem().field_id(name).ok_or(FieldAccessError::Unknown)?;
|
||||
self.get(id, None)
|
||||
|
||||
match self.elem().field_id(name).and_then(|id| self.0.handle().field(id)) {
|
||||
Some(handle) => handle.get().ok_or(FieldAccessError::Unset),
|
||||
None => Err(FieldAccessError::Unknown),
|
||||
}
|
||||
}
|
||||
|
||||
/// Get a field by ID, returning a missing field error if it does not exist.
|
||||
@ -240,7 +229,9 @@ impl Content {
|
||||
|
||||
/// Resolve all fields with the styles and save them in-place.
|
||||
pub fn materialize(&mut self, styles: StyleChain) {
|
||||
self.make_mut().elem.materialize(styles);
|
||||
for id in 0..self.elem().vtable().fields.len() as u8 {
|
||||
self.0.handle_mut().field(id).unwrap().materialize(styles);
|
||||
}
|
||||
}
|
||||
|
||||
/// Create a new sequence element from multiples elements.
|
||||
@ -257,7 +248,7 @@ impl Content {
|
||||
|
||||
/// Whether the contained element is of type `T`.
|
||||
pub fn is<T: NativeElement>(&self) -> bool {
|
||||
self.inner.elem.dyn_type_id() == TypeId::of::<T>()
|
||||
self.0.is::<T>()
|
||||
}
|
||||
|
||||
/// Downcasts the element to a packed value.
|
||||
@ -280,16 +271,6 @@ impl Content {
|
||||
self.into_packed::<T>().map(Packed::unpack)
|
||||
}
|
||||
|
||||
/// Makes sure the content is not shared and returns a mutable reference to
|
||||
/// the inner data.
|
||||
fn make_mut(&mut self) -> &mut Inner<dyn Bounds> {
|
||||
let arc = &mut self.inner;
|
||||
if Arc::strong_count(arc) > 1 || Arc::weak_count(arc) > 0 {
|
||||
*self = arc.elem.dyn_clone(arc, self.span);
|
||||
}
|
||||
Arc::get_mut(&mut self.inner).unwrap()
|
||||
}
|
||||
|
||||
/// Whether the contained element has the given capability.
|
||||
pub fn can<C>(&self) -> bool
|
||||
where
|
||||
@ -304,13 +285,7 @@ impl Content {
|
||||
where
|
||||
C: ?Sized + 'static,
|
||||
{
|
||||
// Safety: The vtable comes from the `Capable` implementation which
|
||||
// guarantees to return a matching vtable for `Packed<T>` and `C`.
|
||||
// Since any `Packed<T>` is a repr(transparent) `Content`, we can also
|
||||
// use a `*const Content` pointer.
|
||||
let vtable = self.elem().vtable()(TypeId::of::<C>())?;
|
||||
let data = self as *const Content as *const ();
|
||||
Some(unsafe { &*fat::from_raw_parts(data, vtable.as_ptr()) })
|
||||
self.0.with::<C>()
|
||||
}
|
||||
|
||||
/// Cast to a mutable trait object if the contained element has the given
|
||||
@ -319,18 +294,7 @@ impl Content {
|
||||
where
|
||||
C: ?Sized + 'static,
|
||||
{
|
||||
// Safety: The vtable comes from the `Capable` implementation which
|
||||
// guarantees to return a matching vtable for `Packed<T>` and `C`.
|
||||
// Since any `Packed<T>` is a repr(transparent) `Content`, we can also
|
||||
// use a `*const Content` pointer.
|
||||
//
|
||||
// The resulting trait object contains an `&mut Packed<T>`. We do _not_
|
||||
// need to ensure that we hold the only reference to the `Arc` here
|
||||
// because `Packed<T>`'s DerefMut impl will take care of that if
|
||||
// mutable access is required.
|
||||
let vtable = self.elem().vtable()(TypeId::of::<C>())?;
|
||||
let data = self as *mut Content as *mut ();
|
||||
Some(unsafe { &mut *fat::from_raw_parts_mut(data, vtable.as_ptr()) })
|
||||
self.0.with_mut::<C>()
|
||||
}
|
||||
|
||||
/// Whether the content is an empty sequence.
|
||||
@ -372,6 +336,15 @@ impl Content {
|
||||
Self::sequence(std::iter::repeat_with(|| self.clone()).take(count))
|
||||
}
|
||||
|
||||
/// Sets a style property on the content.
|
||||
pub fn set<E, const I: u8>(self, field: Field<E, I>, value: E::Type) -> Self
|
||||
where
|
||||
E: SettableProperty<I>,
|
||||
E::Type: Debug + Clone + Hash + Send + Sync + 'static,
|
||||
{
|
||||
self.styled(Property::new(field, value))
|
||||
}
|
||||
|
||||
/// Style this content with a style entry.
|
||||
pub fn styled(mut self, style: impl Into<Style>) -> Self {
|
||||
if let Some(style_elem) = self.to_packed_mut::<StyledElem>() {
|
||||
@ -476,7 +449,7 @@ impl Content {
|
||||
|
||||
// Call f on the element itself before recursively iterating its fields.
|
||||
f(self.clone())?;
|
||||
for (_, value) in self.inner.elem.fields() {
|
||||
for (_, value) in self.fields() {
|
||||
walk_value(value, f)?;
|
||||
}
|
||||
ControlFlow::Continue(())
|
||||
@ -504,12 +477,12 @@ impl Content {
|
||||
|
||||
/// Link the content somewhere.
|
||||
pub fn linked(self, dest: Destination) -> Self {
|
||||
self.styled(LinkElem::set_current(Some(dest)))
|
||||
self.set(LinkElem::current, Some(dest))
|
||||
}
|
||||
|
||||
/// Set alignments for this content.
|
||||
pub fn aligned(self, align: Alignment) -> Self {
|
||||
self.styled(AlignElem::set_alignment(align))
|
||||
self.set(AlignElem::alignment, align)
|
||||
}
|
||||
|
||||
/// Pad this content at the sides.
|
||||
@ -562,7 +535,10 @@ impl Content {
|
||||
return false;
|
||||
};
|
||||
|
||||
self.inner.elem.has(id)
|
||||
match self.0.handle().field(id) {
|
||||
Some(field) => field.has(),
|
||||
None => false,
|
||||
}
|
||||
}
|
||||
|
||||
/// Access the specified field on the content. Returns the default value if
|
||||
@ -592,7 +568,12 @@ impl Content {
|
||||
/// ```
|
||||
#[func]
|
||||
pub fn fields(&self) -> Dict {
|
||||
let mut dict = self.inner.elem.fields();
|
||||
let mut dict = Dict::new();
|
||||
for field in self.0.handle().fields() {
|
||||
if let Some(value) = field.get() {
|
||||
dict.insert(field.name.into(), value);
|
||||
}
|
||||
}
|
||||
if let Some(label) = self.label() {
|
||||
dict.insert("label".into(), label.into_value());
|
||||
}
|
||||
@ -605,7 +586,7 @@ impl Content {
|
||||
/// used with [counters]($counter), [state] and [queries]($query).
|
||||
#[func]
|
||||
pub fn location(&self) -> Option<Location> {
|
||||
self.inner.location
|
||||
self.0.meta().location
|
||||
}
|
||||
}
|
||||
|
||||
@ -617,7 +598,7 @@ impl Default for Content {
|
||||
|
||||
impl Debug for Content {
|
||||
fn fmt(&self, f: &mut Formatter) -> fmt::Result {
|
||||
self.inner.elem.fmt(f)
|
||||
self.0.fmt(f)
|
||||
}
|
||||
}
|
||||
|
||||
@ -627,16 +608,22 @@ impl<T: NativeElement> From<T> for Content {
|
||||
}
|
||||
}
|
||||
|
||||
impl PartialEq for Content {
|
||||
fn eq(&self, other: &Self) -> bool {
|
||||
// Additional short circuit for different elements.
|
||||
self.elem() == other.elem() && self.inner.elem.dyn_eq(other)
|
||||
}
|
||||
}
|
||||
|
||||
impl Repr for Content {
|
||||
fn repr(&self) -> EcoString {
|
||||
self.inner.elem.repr()
|
||||
self.0.handle().repr().unwrap_or_else(|| {
|
||||
let fields = self
|
||||
.0
|
||||
.handle()
|
||||
.fields()
|
||||
.filter_map(|field| field.get().map(|v| (field.name, v.repr())))
|
||||
.map(|(name, value)| eco_format!("{name}: {value}"))
|
||||
.collect::<Vec<_>>();
|
||||
eco_format!(
|
||||
"{}{}",
|
||||
self.elem().name(),
|
||||
repr::pretty_array_like(&fields, false),
|
||||
)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
@ -717,190 +704,8 @@ impl Serialize for Content {
|
||||
}
|
||||
}
|
||||
|
||||
/// The trait that combines all the other traits into a trait object.
|
||||
trait Bounds: Debug + Repr + Fields + Send + Sync + 'static {
|
||||
fn dyn_type_id(&self) -> TypeId;
|
||||
fn dyn_elem(&self) -> Element;
|
||||
fn dyn_clone(&self, inner: &Inner<dyn Bounds>, span: Span) -> Content;
|
||||
fn dyn_hash(&self, hasher: &mut dyn Hasher);
|
||||
fn dyn_eq(&self, other: &Content) -> bool;
|
||||
}
|
||||
|
||||
impl<T: NativeElement> Bounds for T {
|
||||
fn dyn_type_id(&self) -> TypeId {
|
||||
TypeId::of::<Self>()
|
||||
}
|
||||
|
||||
fn dyn_elem(&self) -> Element {
|
||||
Self::elem()
|
||||
}
|
||||
|
||||
fn dyn_clone(&self, inner: &Inner<dyn Bounds>, span: Span) -> Content {
|
||||
Content {
|
||||
inner: Arc::new(Inner {
|
||||
label: inner.label,
|
||||
location: inner.location,
|
||||
lifecycle: inner.lifecycle.clone(),
|
||||
elem: LazyHash::reuse(self.clone(), &inner.elem),
|
||||
}),
|
||||
span,
|
||||
}
|
||||
}
|
||||
|
||||
fn dyn_hash(&self, mut state: &mut dyn Hasher) {
|
||||
TypeId::of::<Self>().hash(&mut state);
|
||||
self.hash(&mut state);
|
||||
}
|
||||
|
||||
fn dyn_eq(&self, other: &Content) -> bool {
|
||||
let Some(other) = other.to_packed::<Self>() else {
|
||||
return false;
|
||||
};
|
||||
*self == **other
|
||||
}
|
||||
}
|
||||
|
||||
impl Hash for dyn Bounds {
|
||||
fn hash<H: Hasher>(&self, state: &mut H) {
|
||||
self.dyn_hash(state);
|
||||
}
|
||||
}
|
||||
|
||||
/// A packed element of a static type.
|
||||
#[derive(Clone, PartialEq, Hash)]
|
||||
#[repr(transparent)]
|
||||
pub struct Packed<T: NativeElement>(
|
||||
/// Invariant: Must be of type `T`.
|
||||
Content,
|
||||
PhantomData<T>,
|
||||
);
|
||||
|
||||
impl<T: NativeElement> Packed<T> {
|
||||
/// Pack element while retaining its static type.
|
||||
pub fn new(element: T) -> Self {
|
||||
// Safety: The element is known to be of type `T`.
|
||||
Packed(element.pack(), PhantomData)
|
||||
}
|
||||
|
||||
/// Try to cast type-erased content into a statically known packed element.
|
||||
pub fn from_ref(content: &Content) -> Option<&Self> {
|
||||
if content.is::<T>() {
|
||||
// Safety:
|
||||
// - We have checked the type.
|
||||
// - Packed<T> is repr(transparent).
|
||||
return Some(unsafe { std::mem::transmute::<&Content, &Packed<T>>(content) });
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
/// Try to cast type-erased content into a statically known packed element.
|
||||
pub fn from_mut(content: &mut Content) -> Option<&mut Self> {
|
||||
if content.is::<T>() {
|
||||
// Safety:
|
||||
// - We have checked the type.
|
||||
// - Packed<T> is repr(transparent).
|
||||
return Some(unsafe {
|
||||
std::mem::transmute::<&mut Content, &mut Packed<T>>(content)
|
||||
});
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
/// Try to cast type-erased content into a statically known packed element.
|
||||
pub fn from_owned(content: Content) -> Result<Self, Content> {
|
||||
if content.is::<T>() {
|
||||
// Safety:
|
||||
// - We have checked the type.
|
||||
// - Packed<T> is repr(transparent).
|
||||
return Ok(unsafe { std::mem::transmute::<Content, Packed<T>>(content) });
|
||||
}
|
||||
Err(content)
|
||||
}
|
||||
|
||||
/// Pack back into content.
|
||||
pub fn pack(self) -> Content {
|
||||
self.0
|
||||
}
|
||||
|
||||
/// Extract the raw underlying element.
|
||||
pub fn unpack(self) -> T {
|
||||
// This function doesn't yet need owned self, but might in the future.
|
||||
(*self).clone()
|
||||
}
|
||||
|
||||
/// The element's span.
|
||||
pub fn span(&self) -> Span {
|
||||
self.0.span()
|
||||
}
|
||||
|
||||
/// Set the span of the element.
|
||||
pub fn spanned(self, span: Span) -> Self {
|
||||
Self(self.0.spanned(span), PhantomData)
|
||||
}
|
||||
|
||||
/// Accesses the label of the element.
|
||||
pub fn label(&self) -> Option<Label> {
|
||||
self.0.label()
|
||||
}
|
||||
|
||||
/// Accesses the location of the element.
|
||||
pub fn location(&self) -> Option<Location> {
|
||||
self.0.location()
|
||||
}
|
||||
|
||||
/// Sets the location of the element.
|
||||
pub fn set_location(&mut self, location: Location) {
|
||||
self.0.set_location(location);
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: NativeElement> AsRef<T> for Packed<T> {
|
||||
fn as_ref(&self) -> &T {
|
||||
self
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: NativeElement> AsMut<T> for Packed<T> {
|
||||
fn as_mut(&mut self) -> &mut T {
|
||||
self
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: NativeElement> Deref for Packed<T> {
|
||||
type Target = T;
|
||||
|
||||
fn deref(&self) -> &Self::Target {
|
||||
// Safety:
|
||||
// - Packed<T> guarantees that the content trait object wraps
|
||||
// an element of type `T`.
|
||||
// - This downcast works the same way as dyn Any's does. We can't reuse
|
||||
// that one because we don't want to pay the cost for every deref.
|
||||
let elem = &*self.0.inner.elem;
|
||||
unsafe { &*(elem as *const dyn Bounds as *const T) }
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: NativeElement> DerefMut for Packed<T> {
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
// Safety:
|
||||
// - Packed<T> guarantees that the content trait object wraps
|
||||
// an element of type `T`.
|
||||
// - We have guaranteed unique access thanks to `make_mut`.
|
||||
// - This downcast works the same way as dyn Any's does. We can't reuse
|
||||
// that one because we don't want to pay the cost for every deref.
|
||||
let elem = &mut *self.0.make_mut().elem;
|
||||
unsafe { &mut *(elem as *mut dyn Bounds as *mut T) }
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: NativeElement + Debug> Debug for Packed<T> {
|
||||
fn fmt(&self, f: &mut Formatter) -> fmt::Result {
|
||||
self.0.fmt(f)
|
||||
}
|
||||
}
|
||||
|
||||
/// A sequence of content.
|
||||
#[elem(Debug, Repr, PartialEq)]
|
||||
#[elem(Debug, Repr)]
|
||||
pub struct SequenceElem {
|
||||
/// The elements.
|
||||
#[required]
|
||||
@ -922,19 +727,13 @@ impl Default for SequenceElem {
|
||||
}
|
||||
}
|
||||
|
||||
impl PartialEq for SequenceElem {
|
||||
fn eq(&self, other: &Self) -> bool {
|
||||
self.children.iter().eq(other.children.iter())
|
||||
}
|
||||
}
|
||||
|
||||
impl Repr for SequenceElem {
|
||||
fn repr(&self) -> EcoString {
|
||||
if self.children.is_empty() {
|
||||
"[]".into()
|
||||
} else {
|
||||
let elements = crate::foundations::repr::pretty_array_like(
|
||||
&self.children.iter().map(|c| c.inner.elem.repr()).collect::<Vec<_>>(),
|
||||
&self.children.iter().map(|c| c.repr()).collect::<Vec<_>>(),
|
||||
false,
|
||||
);
|
||||
eco_format!("sequence{}", elements)
|
||||
@ -974,49 +773,8 @@ impl Repr for StyledElem {
|
||||
}
|
||||
}
|
||||
|
||||
/// Tries to extract the plain-text representation of the element.
|
||||
pub trait PlainText {
|
||||
/// Write this element's plain text into the given buffer.
|
||||
fn plain_text(&self, text: &mut EcoString);
|
||||
}
|
||||
|
||||
/// An error arising when trying to access a field of content.
|
||||
#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
|
||||
pub enum FieldAccessError {
|
||||
Unknown,
|
||||
Unset,
|
||||
Internal,
|
||||
}
|
||||
|
||||
impl FieldAccessError {
|
||||
/// Formats the error message given the content and the field name.
|
||||
#[cold]
|
||||
pub fn message(self, content: &Content, field: &str) -> EcoString {
|
||||
let elem_name = content.elem().name();
|
||||
match self {
|
||||
FieldAccessError::Unknown => {
|
||||
eco_format!("{elem_name} does not have field {}", field.repr())
|
||||
}
|
||||
FieldAccessError::Unset => {
|
||||
eco_format!(
|
||||
"field {} in {elem_name} is not known at this point",
|
||||
field.repr()
|
||||
)
|
||||
}
|
||||
FieldAccessError::Internal => {
|
||||
eco_format!(
|
||||
"internal error when accessing field {} in {elem_name} – this is a bug",
|
||||
field.repr()
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Formats the error message for an `at` calls without a default value.
|
||||
#[cold]
|
||||
pub fn message_no_default(self, content: &Content, field: &str) -> EcoString {
|
||||
let mut msg = self.message(content, field);
|
||||
msg.push_str(" and no default was specified");
|
||||
msg
|
||||
impl<T: NativeElement> IntoValue for T {
|
||||
fn into_value(self) -> Value {
|
||||
Value::Content(self.pack())
|
||||
}
|
||||
}
|
147
crates/typst-library/src/foundations/content/packed.rs
Normal file
147
crates/typst-library/src/foundations/content/packed.rs
Normal file
@ -0,0 +1,147 @@
|
||||
use std::fmt::{self, Debug, Formatter};
|
||||
use std::hash::{Hash, Hasher};
|
||||
use std::marker::PhantomData;
|
||||
use std::ops::{Deref, DerefMut};
|
||||
|
||||
use typst_syntax::Span;
|
||||
|
||||
use crate::foundations::{Content, Label, NativeElement};
|
||||
use crate::introspection::Location;
|
||||
|
||||
/// A packed element of a static type.
|
||||
#[derive(Clone)]
|
||||
#[repr(transparent)]
|
||||
pub struct Packed<T: NativeElement>(
|
||||
/// Invariant: Must be of type `T`.
|
||||
Content,
|
||||
PhantomData<T>,
|
||||
);
|
||||
|
||||
impl<T: NativeElement> Packed<T> {
|
||||
/// Pack element while retaining its static type.
|
||||
pub fn new(element: T) -> Self {
|
||||
// Safety: The element is known to be of type `T`.
|
||||
Packed(element.pack(), PhantomData)
|
||||
}
|
||||
|
||||
/// Try to cast type-erased content into a statically known packed element.
|
||||
pub fn from_ref(content: &Content) -> Option<&Self> {
|
||||
if content.is::<T>() {
|
||||
// Safety:
|
||||
// - We have checked the type.
|
||||
// - Packed<T> is repr(transparent).
|
||||
return Some(unsafe { std::mem::transmute::<&Content, &Packed<T>>(content) });
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
/// Try to cast type-erased content into a statically known packed element.
|
||||
pub fn from_mut(content: &mut Content) -> Option<&mut Self> {
|
||||
if content.is::<T>() {
|
||||
// Safety:
|
||||
// - We have checked the type.
|
||||
// - Packed<T> is repr(transparent).
|
||||
return Some(unsafe {
|
||||
std::mem::transmute::<&mut Content, &mut Packed<T>>(content)
|
||||
});
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
/// Try to cast type-erased content into a statically known packed element.
|
||||
pub fn from_owned(content: Content) -> Result<Self, Content> {
|
||||
if content.is::<T>() {
|
||||
// Safety:
|
||||
// - We have checked the type.
|
||||
// - Packed<T> is repr(transparent).
|
||||
return Ok(unsafe { std::mem::transmute::<Content, Packed<T>>(content) });
|
||||
}
|
||||
Err(content)
|
||||
}
|
||||
|
||||
/// Pack back into content.
|
||||
pub fn pack(self) -> Content {
|
||||
self.0
|
||||
}
|
||||
|
||||
/// Extract the raw underlying element.
|
||||
pub fn unpack(self) -> T {
|
||||
// This function doesn't yet need owned self, but might in the future.
|
||||
(*self).clone()
|
||||
}
|
||||
|
||||
/// The element's span.
|
||||
pub fn span(&self) -> Span {
|
||||
self.0.span()
|
||||
}
|
||||
|
||||
/// Set the span of the element.
|
||||
pub fn spanned(self, span: Span) -> Self {
|
||||
Self(self.0.spanned(span), PhantomData)
|
||||
}
|
||||
|
||||
/// Accesses the label of the element.
|
||||
pub fn label(&self) -> Option<Label> {
|
||||
self.0.label()
|
||||
}
|
||||
|
||||
/// Accesses the location of the element.
|
||||
pub fn location(&self) -> Option<Location> {
|
||||
self.0.location()
|
||||
}
|
||||
|
||||
/// Sets the location of the element.
|
||||
pub fn set_location(&mut self, location: Location) {
|
||||
self.0.set_location(location);
|
||||
}
|
||||
|
||||
pub fn as_content(&self) -> &Content {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: NativeElement> AsRef<T> for Packed<T> {
|
||||
fn as_ref(&self) -> &T {
|
||||
self
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: NativeElement> AsMut<T> for Packed<T> {
|
||||
fn as_mut(&mut self) -> &mut T {
|
||||
self
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: NativeElement> Deref for Packed<T> {
|
||||
type Target = T;
|
||||
|
||||
fn deref(&self) -> &Self::Target {
|
||||
// Safety: Packed<T> guarantees that the content is of element type `T`.
|
||||
unsafe { (self.0).0.data::<T>() }
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: NativeElement> DerefMut for Packed<T> {
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
// Safety: Packed<T> guarantees that the content is of element type `T`.
|
||||
unsafe { (self.0).0.data_mut::<T>() }
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: NativeElement + Debug> Debug for Packed<T> {
|
||||
fn fmt(&self, f: &mut Formatter) -> fmt::Result {
|
||||
self.0.fmt(f)
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: NativeElement> PartialEq for Packed<T> {
|
||||
fn eq(&self, other: &Self) -> bool {
|
||||
self.0 == other.0
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: NativeElement> Hash for Packed<T> {
|
||||
fn hash<H: Hasher>(&self, state: &mut H) {
|
||||
self.0.hash(state);
|
||||
}
|
||||
}
|
426
crates/typst-library/src/foundations/content/raw.rs
Normal file
426
crates/typst-library/src/foundations/content/raw.rs
Normal file
@ -0,0 +1,426 @@
|
||||
use std::any::TypeId;
|
||||
use std::fmt::{self, Debug, Formatter};
|
||||
use std::hash::{Hash, Hasher};
|
||||
use std::ptr::NonNull;
|
||||
use std::sync::atomic::{self, AtomicUsize, Ordering};
|
||||
|
||||
use typst_syntax::Span;
|
||||
use typst_utils::{fat, HashLock, SmallBitSet};
|
||||
|
||||
use super::vtable;
|
||||
use crate::foundations::{Element, Label, NativeElement, Packed};
|
||||
use crate::introspection::Location;
|
||||
|
||||
/// The raw, low-level implementation of content.
|
||||
///
|
||||
/// The `ptr` + `elem` fields implement a fat pointer setup similar to an
|
||||
/// `Arc<Inner<dyn Trait>>`, but in a manual way, allowing us to have a custom
|
||||
/// [vtable].
|
||||
pub struct RawContent {
|
||||
/// A type-erased pointer to an allocation containing two things:
|
||||
/// - A header that is the same for all elements
|
||||
/// - Element-specific `data` that holds the specific element
|
||||
///
|
||||
/// This pointer is valid for both a `Header` and an `Inner<E>` where
|
||||
/// `E::ELEM == self.elem` and can be freely cast between both. This is
|
||||
/// possible because
|
||||
/// - `Inner<E>` is `repr(C)`
|
||||
/// - The first field of `Inner<E>` is `Header`
|
||||
/// - ISO/IEC 9899:TC2 C standard § 6.7.2.1 - 13 states that a pointer to a
|
||||
/// structure "points to its initial member" with no padding at the start
|
||||
ptr: NonNull<Header>,
|
||||
/// Describes which kind of element this content holds. This is used for
|
||||
///
|
||||
/// - Direct comparisons, e.g. `is::<HeadingElem>()`
|
||||
/// - Behavior: An `Element` is just a pointer to a `ContentVtable`
|
||||
/// containing not just data, but also function pointers for various
|
||||
/// element-specific operations that can be performed
|
||||
///
|
||||
/// It is absolutely crucial that `elem == <E as NativeElement>::ELEM` for
|
||||
/// `Inner<E>` pointed to by `ptr`. Otherwise, things will go very wrong
|
||||
/// since we'd be using the wrong vtable.
|
||||
elem: Element,
|
||||
/// The content's span.
|
||||
span: Span,
|
||||
}
|
||||
|
||||
/// The allocated part of an element's representation.
|
||||
///
|
||||
/// This is `repr(C)` to ensure that a pointer to the whole structure may be
|
||||
/// cast to a pointer to its first field.
|
||||
#[repr(C)]
|
||||
struct Inner<E> {
|
||||
/// It is crucial that this is the first field because we cast between
|
||||
/// pointers to `Inner<E>` and pointers to `Header`. See the documentation
|
||||
/// of `RawContent::ptr` for more details.
|
||||
header: Header,
|
||||
/// The element struct. E.g. `E = HeadingElem`.
|
||||
data: E,
|
||||
}
|
||||
|
||||
/// The header that is shared by all elements.
|
||||
struct Header {
|
||||
/// The element's reference count. This works just like for `Arc`.
|
||||
/// Unfortunately, we have to reimplement reference counting because we
|
||||
/// have a custom fat pointer and `Arc` wouldn't know how to drop its
|
||||
/// contents. Something with `ManuallyDrop<Arc<_>>` might also work, but at
|
||||
/// that point we're not gaining much and with the way it's implemented now
|
||||
/// we can also skip the unnecessary weak reference count.
|
||||
refs: AtomicUsize,
|
||||
/// Metadata for the element.
|
||||
meta: Meta,
|
||||
/// A cell for memoizing the hash of just the `data` part of the content.
|
||||
hash: HashLock,
|
||||
}
|
||||
|
||||
/// Metadata that elements can hold.
|
||||
#[derive(Clone, Hash)]
|
||||
pub(super) struct Meta {
|
||||
/// An optional label attached to the element.
|
||||
pub label: Option<Label>,
|
||||
/// The element's location which identifies it in the laid-out output.
|
||||
pub location: Option<Location>,
|
||||
/// Manages the element during realization.
|
||||
/// - If bit 0 is set, the element is prepared.
|
||||
/// - If bit n is set, the element is guarded against the n-th show rule
|
||||
/// recipe from the top of the style chain (counting from 1).
|
||||
pub lifecycle: SmallBitSet,
|
||||
}
|
||||
|
||||
impl RawContent {
|
||||
/// Creates raw content wrapping an element, with all metadata set to
|
||||
/// default (including a detached span).
|
||||
pub(super) fn new<E: NativeElement>(data: E) -> Self {
|
||||
Self::create(
|
||||
data,
|
||||
Meta {
|
||||
label: None,
|
||||
location: None,
|
||||
lifecycle: SmallBitSet::new(),
|
||||
},
|
||||
HashLock::new(),
|
||||
Span::detached(),
|
||||
)
|
||||
}
|
||||
|
||||
/// Creates and allocates raw content.
|
||||
fn create<E: NativeElement>(data: E, meta: Meta, hash: HashLock, span: Span) -> Self {
|
||||
let raw = Box::into_raw(Box::<Inner<E>>::new(Inner {
|
||||
header: Header { refs: AtomicUsize::new(1), meta, hash },
|
||||
data,
|
||||
}));
|
||||
|
||||
// Safety: `Box` always holds a non-null pointer. See also
|
||||
// `Box::into_non_null` (which is unstable).
|
||||
let non_null = unsafe { NonNull::new_unchecked(raw) };
|
||||
|
||||
// Safety: See `RawContent::ptr`.
|
||||
let ptr = non_null.cast::<Header>();
|
||||
|
||||
Self { ptr, elem: E::ELEM, span }
|
||||
}
|
||||
|
||||
/// Destroys raw content and deallocates.
|
||||
///
|
||||
/// # Safety
|
||||
/// - The reference count must be zero.
|
||||
/// - The raw content must be be of type `E`.
|
||||
pub(super) unsafe fn drop_impl<E: NativeElement>(&mut self) {
|
||||
debug_assert_eq!(self.header().refs.load(Ordering::Relaxed), 0);
|
||||
|
||||
// Safety:
|
||||
// - The caller guarantees that the content is of type `E`.
|
||||
// - Thus, `ptr` must have been created from `Box<Inner<E>>` (see
|
||||
// `RawContent::ptr`).
|
||||
// - And to clean it up, we can just reproduce our box.
|
||||
unsafe {
|
||||
let ptr = self.ptr.cast::<Inner<E>>();
|
||||
drop(Box::<Inner<E>>::from_raw(ptr.as_ptr()));
|
||||
}
|
||||
}
|
||||
|
||||
/// Clones a packed element into new raw content.
|
||||
pub(super) fn clone_impl<E: NativeElement>(elem: &Packed<E>) -> Self {
|
||||
let raw = &elem.as_content().0;
|
||||
let header = raw.header();
|
||||
RawContent::create(
|
||||
elem.as_ref().clone(),
|
||||
header.meta.clone(),
|
||||
header.hash.clone(),
|
||||
raw.span,
|
||||
)
|
||||
}
|
||||
|
||||
/// Accesses the header part of the raw content.
|
||||
fn header(&self) -> &Header {
|
||||
// Safety: `self.ptr` is a valid pointer to a header structure.
|
||||
unsafe { self.ptr.as_ref() }
|
||||
}
|
||||
|
||||
/// Mutably accesses the header part of the raw content.
|
||||
fn header_mut(&mut self) -> &mut Header {
|
||||
self.make_unique();
|
||||
|
||||
// Safety:
|
||||
// - `self.ptr` is a valid pointer to a header structure.
|
||||
// - We have unique access to the backing allocation (just ensured).
|
||||
unsafe { self.ptr.as_mut() }
|
||||
}
|
||||
|
||||
/// Retrieves the contained element **without checking that the content is
|
||||
/// of the correct type.**
|
||||
///
|
||||
/// # Safety
|
||||
/// This must be preceded by a check to [`is`]. The safe API for this is
|
||||
/// [`Content::to_packed`] and the [`Packed`] struct.
|
||||
pub(super) unsafe fn data<E: NativeElement>(&self) -> &E {
|
||||
debug_assert!(self.is::<E>());
|
||||
|
||||
// Safety:
|
||||
// - The caller guarantees that the content is of type `E`.
|
||||
// - `self.ptr` is a valid pointer to an `Inner<E>` (see
|
||||
// `RawContent::ptr`).
|
||||
unsafe { &self.ptr.cast::<Inner<E>>().as_ref().data }
|
||||
}
|
||||
|
||||
/// Retrieves the contained element mutably **without checking that the
|
||||
/// content is of the correct type.**
|
||||
///
|
||||
/// Ensures that the element's allocation is unique.
|
||||
///
|
||||
/// # Safety
|
||||
/// This must be preceded by a check to [`is`]. The safe API for this is
|
||||
/// [`Content::to_packed_mut`] and the [`Packed`] struct.
|
||||
pub(super) unsafe fn data_mut<E: NativeElement>(&mut self) -> &mut E {
|
||||
debug_assert!(self.is::<E>());
|
||||
|
||||
// Ensure that the memoized hash is reset because we may mutate the
|
||||
// element.
|
||||
self.header_mut().hash.reset();
|
||||
|
||||
// Safety:
|
||||
// - The caller guarantees that the content is of type `E`.
|
||||
// - `self.ptr` is a valid pointer to an `Inner<E>` (see
|
||||
// `RawContent::ptr`).
|
||||
// - We have unique access to the backing allocation (due to header_mut).
|
||||
unsafe { &mut self.ptr.cast::<Inner<E>>().as_mut().data }
|
||||
}
|
||||
|
||||
/// Ensures that we have unique access to the backing allocation by cloning
|
||||
/// if the reference count exceeds 1. This is used before performing
|
||||
/// mutable operations, implementing a clone-on-write scheme.
|
||||
fn make_unique(&mut self) {
|
||||
if self.header().refs.load(Ordering::Relaxed) > 1 {
|
||||
*self = self.handle().clone();
|
||||
}
|
||||
}
|
||||
|
||||
/// Retrieves the element this content is for.
|
||||
pub(super) fn elem(&self) -> Element {
|
||||
self.elem
|
||||
}
|
||||
|
||||
/// Whether this content holds an element of type `E`.
|
||||
pub(super) fn is<E: NativeElement>(&self) -> bool {
|
||||
self.elem == E::ELEM
|
||||
}
|
||||
|
||||
/// Retrieves the content's span.
|
||||
pub(super) fn span(&self) -> Span {
|
||||
self.span
|
||||
}
|
||||
|
||||
/// Retrieves the content's span mutably.
|
||||
pub(super) fn span_mut(&mut self) -> &mut Span {
|
||||
&mut self.span
|
||||
}
|
||||
|
||||
/// Retrieves the content's metadata.
|
||||
pub(super) fn meta(&self) -> &Meta {
|
||||
&self.header().meta
|
||||
}
|
||||
|
||||
/// Retrieves the content's metadata mutably.
|
||||
pub(super) fn meta_mut(&mut self) -> &mut Meta {
|
||||
&mut self.header_mut().meta
|
||||
}
|
||||
|
||||
/// Casts into a trait object for a given trait if the packed element
|
||||
/// implements said trait.
|
||||
pub(super) fn with<C>(&self) -> Option<&C>
|
||||
where
|
||||
C: ?Sized + 'static,
|
||||
{
|
||||
// Safety: The vtable comes from the `Capable` implementation which
|
||||
// guarantees to return a matching vtable for `Packed<T>` and `C`. Since
|
||||
// any `Packed<T>` is repr(transparent) with `Content` and `RawContent`,
|
||||
// we can also use a `*const RawContent` pointer.
|
||||
let vtable = (self.elem.vtable().capability)(TypeId::of::<C>())?;
|
||||
let data = self as *const Self as *const ();
|
||||
Some(unsafe { &*fat::from_raw_parts(data, vtable.as_ptr()) })
|
||||
}
|
||||
|
||||
/// Casts into a mutable trait object for a given trait if the packed
|
||||
/// element implements said trait.
|
||||
pub(super) fn with_mut<C>(&mut self) -> Option<&mut C>
|
||||
where
|
||||
C: ?Sized + 'static,
|
||||
{
|
||||
// Safety: The vtable comes from the `Capable` implementation which
|
||||
// guarantees to return a matching vtable for `Packed<T>` and `C`. Since
|
||||
// any `Packed<T>` is repr(transparent) with `Content` and `RawContent`,
|
||||
// we can also use a `*const Content` pointer.
|
||||
//
|
||||
// The resulting trait object contains an `&mut Packed<T>`. We do _not_
|
||||
// need to ensure that we hold the only reference to the `Arc` here
|
||||
// because `Packed<T>`'s DerefMut impl will take care of that if mutable
|
||||
// access is required.
|
||||
let vtable = (self.elem.vtable().capability)(TypeId::of::<C>())?;
|
||||
let data = self as *mut Self as *mut ();
|
||||
Some(unsafe { &mut *fat::from_raw_parts_mut(data, vtable.as_ptr()) })
|
||||
}
|
||||
}
|
||||
|
||||
impl RawContent {
|
||||
/// Retrieves the element's vtable.
|
||||
pub(super) fn handle(&self) -> vtable::ContentHandle<&RawContent> {
|
||||
// Safety `self.elem.vtable()` is a matching vtable for `self`.
|
||||
unsafe { vtable::Handle::new(self, self.elem.vtable()) }
|
||||
}
|
||||
|
||||
/// Retrieves the element's vtable.
|
||||
pub(super) fn handle_mut(&mut self) -> vtable::ContentHandle<&mut RawContent> {
|
||||
// Safety `self.elem.vtable()` is a matching vtable for `self`.
|
||||
unsafe { vtable::Handle::new(self, self.elem.vtable()) }
|
||||
}
|
||||
|
||||
/// Retrieves the element's vtable.
|
||||
pub(super) fn handle_pair<'a, 'b>(
|
||||
&'a self,
|
||||
other: &'b RawContent,
|
||||
) -> Option<vtable::ContentHandle<(&'a RawContent, &'b RawContent)>> {
|
||||
(self.elem == other.elem).then(|| {
|
||||
// Safety:
|
||||
// - `self.elem.vtable()` is a matching vtable for `self`.
|
||||
// - It's also matching for `other` because `self.elem == other.elem`.
|
||||
unsafe { vtable::Handle::new((self, other), self.elem.vtable()) }
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl Debug for RawContent {
|
||||
fn fmt(&self, f: &mut Formatter) -> fmt::Result {
|
||||
self.handle().debug(f)
|
||||
}
|
||||
}
|
||||
|
||||
impl Clone for RawContent {
|
||||
fn clone(&self) -> Self {
|
||||
// See Arc's clone impl for details about memory ordering.
|
||||
let prev = self.header().refs.fetch_add(1, Ordering::Relaxed);
|
||||
|
||||
// See Arc's clone impl details about guarding against incredibly
|
||||
// degenerate programs.
|
||||
if prev > isize::MAX as usize {
|
||||
ref_count_overflow(self.ptr, self.elem, self.span);
|
||||
}
|
||||
|
||||
Self { ptr: self.ptr, elem: self.elem, span: self.span }
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for RawContent {
|
||||
fn drop(&mut self) {
|
||||
// Drop our ref-count. If there was more than one content before
|
||||
// (including this one), we shouldn't deallocate. See Arc's drop impl
|
||||
// for details about memory ordering.
|
||||
if self.header().refs.fetch_sub(1, Ordering::Release) != 1 {
|
||||
return;
|
||||
}
|
||||
|
||||
// See Arc's drop impl for details.
|
||||
atomic::fence(Ordering::Acquire);
|
||||
|
||||
// Safety:
|
||||
// No other content references the backing allocation (just checked)
|
||||
unsafe {
|
||||
self.handle_mut().drop();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl PartialEq for RawContent {
|
||||
fn eq(&self, other: &Self) -> bool {
|
||||
let Some(handle) = self.handle_pair(other) else { return false };
|
||||
handle
|
||||
.eq()
|
||||
.unwrap_or_else(|| handle.fields().all(|handle| handle.eq()))
|
||||
}
|
||||
}
|
||||
|
||||
impl Hash for RawContent {
|
||||
fn hash<H: Hasher>(&self, state: &mut H) {
|
||||
self.elem.hash(state);
|
||||
let header = self.header();
|
||||
header.meta.hash(state);
|
||||
header.hash.get_or_insert_with(|| self.handle().hash()).hash(state);
|
||||
self.span.hash(state);
|
||||
}
|
||||
}
|
||||
|
||||
// Safety:
|
||||
// - Works like `Arc`.
|
||||
// - `NativeElement` implies `Send` and `Sync`, see below.
|
||||
unsafe impl Sync for RawContent {}
|
||||
unsafe impl Send for RawContent {}
|
||||
|
||||
fn _ensure_send_sync<T: NativeElement>() {
|
||||
fn needs_send_sync<T: Send + Sync>() {}
|
||||
needs_send_sync::<T>();
|
||||
}
|
||||
|
||||
#[cold]
|
||||
fn ref_count_overflow(ptr: NonNull<Header>, elem: Element, span: Span) -> ! {
|
||||
// Drop to decrement the ref count to counter the increment in `clone()`
|
||||
drop(RawContent { ptr, elem, span });
|
||||
panic!("reference count overflow");
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use crate::foundations::{NativeElement, Repr, StyleChain, Value};
|
||||
use crate::introspection::Location;
|
||||
use crate::model::HeadingElem;
|
||||
use crate::text::TextElem;
|
||||
|
||||
#[test]
|
||||
fn test_miri() {
|
||||
let styles = StyleChain::default();
|
||||
|
||||
let mut first = HeadingElem::new(TextElem::packed("Hi!")).with_offset(2).pack();
|
||||
let hash1 = typst_utils::hash128(&first);
|
||||
first.set_location(Location::new(10));
|
||||
let _ = format!("{first:?}");
|
||||
let _ = first.repr();
|
||||
|
||||
assert!(first.is::<HeadingElem>());
|
||||
assert!(!first.is::<TextElem>());
|
||||
assert_eq!(first.to_packed::<TextElem>(), None);
|
||||
assert_eq!(first.location(), Some(Location::new(10)));
|
||||
assert_eq!(first.field_by_name("offset"), Ok(Value::Int(2)));
|
||||
assert!(!first.has("depth".into()));
|
||||
|
||||
let second = first.clone();
|
||||
first.materialize(styles);
|
||||
|
||||
let first_packed = first.to_packed::<HeadingElem>().unwrap();
|
||||
let second_packed = second.to_packed::<HeadingElem>().unwrap();
|
||||
|
||||
assert!(first.has("depth".into()));
|
||||
assert!(!second.has("depth".into()));
|
||||
assert!(first_packed.depth.is_set());
|
||||
assert!(!second_packed.depth.is_set());
|
||||
assert_ne!(first, second);
|
||||
assert_ne!(hash1, typst_utils::hash128(&first));
|
||||
}
|
||||
}
|
383
crates/typst-library/src/foundations/content/vtable.rs
Normal file
383
crates/typst-library/src/foundations/content/vtable.rs
Normal file
@ -0,0 +1,383 @@
|
||||
//! A custom [vtable] implementation for content.
|
||||
//!
|
||||
//! This is similar to what is generated by the Rust compiler under the hood
|
||||
//! when using trait objects. However, ours has two key advantages:
|
||||
//!
|
||||
//! - It can store a _slice_ of sub-vtables for field-specific operations.
|
||||
//! - It can store not only methods, but also plain data, allowing us to access
|
||||
//! that data without going through dynamic dispatch.
|
||||
//!
|
||||
//! Because our vtable pointers are backed by `static` variables, we can also
|
||||
//! perform checks for element types by comparing raw vtable pointers giving us
|
||||
//! `RawContent::is` without dynamic dispatch.
|
||||
//!
|
||||
//! Overall, the custom vtable gives us just a little more flexibility and
|
||||
//! optimizability than using built-in trait objects.
|
||||
//!
|
||||
//! Note that all vtable methods receive elements of type `Packed<E>`, but some
|
||||
//! only perform actions on the `E` itself, with the shared part kept outside of
|
||||
//! the vtable (e.g. `hash`), while some perform the full action (e.g. `clone`
|
||||
//! as it needs to return new, fully populated raw content). Which one it is, is
|
||||
//! documented for each.
|
||||
//!
|
||||
//! # Safety
|
||||
//! This module contains a lot of `unsafe` keywords, but almost all of it is the
|
||||
//! same and quite straightfoward. All function pointers that operate on a
|
||||
//! specific element type are marked as unsafe. In combination with `repr(C)`,
|
||||
//! this grants us the ability to safely transmute a `ContentVtable<Packed<E>>`
|
||||
//! into a `ContentVtable<RawContent>` (or just short `ContentVtable`). Callers
|
||||
//! of functions marked as unsafe have to guarantee that the `ContentVtable` was
|
||||
//! transmuted from the same `E` as the RawContent was constructed from. The
|
||||
//! `Handle` struct provides a safe access layer, moving the guarantee that the
|
||||
//! vtable is matching into a single spot.
|
||||
//!
|
||||
//! [vtable]: https://en.wikipedia.org/wiki/Virtual_method_table
|
||||
|
||||
use std::any::TypeId;
|
||||
use std::fmt::{self, Debug, Formatter};
|
||||
use std::ops::Deref;
|
||||
use std::ptr::NonNull;
|
||||
|
||||
use ecow::EcoString;
|
||||
|
||||
use super::raw::RawContent;
|
||||
use crate::diag::SourceResult;
|
||||
use crate::engine::Engine;
|
||||
use crate::foundations::{
|
||||
Args, CastInfo, Construct, Content, LazyElementStore, NativeElement, NativeScope,
|
||||
Packed, Repr, Scope, Set, StyleChain, Styles, Value,
|
||||
};
|
||||
use crate::text::{Lang, LocalName, Region};
|
||||
|
||||
/// Encapsulates content and a vtable, granting safe access to vtable operations.
|
||||
pub(super) struct Handle<T, V: 'static>(T, &'static V);
|
||||
|
||||
impl<T, V> Handle<T, V> {
|
||||
/// Produces a new handle from content and a vtable.
|
||||
///
|
||||
/// # Safety
|
||||
/// The content and vtable must be matching, i.e. `vtable` must be derived
|
||||
/// from the content's vtable.
|
||||
pub(super) unsafe fn new(content: T, vtable: &'static V) -> Self {
|
||||
Self(content, vtable)
|
||||
}
|
||||
}
|
||||
|
||||
impl<T, V> Deref for Handle<T, V> {
|
||||
type Target = V;
|
||||
|
||||
fn deref(&self) -> &Self::Target {
|
||||
self.1
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) type ContentHandle<T> = Handle<T, ContentVtable>;
|
||||
pub(super) type FieldHandle<T> = Handle<T, FieldVtable>;
|
||||
|
||||
/// A vtable for performing element-specific actions on type-erased content.
|
||||
/// Also contains general metadata for the specific element.
|
||||
#[repr(C)]
|
||||
pub struct ContentVtable<T: 'static = RawContent> {
|
||||
/// The element's normal name, as in code.
|
||||
pub(super) name: &'static str,
|
||||
/// The element's title-cased name.
|
||||
pub(super) title: &'static str,
|
||||
/// The element's documentation (as Markdown).
|
||||
pub(super) docs: &'static str,
|
||||
/// Search keywords for the documentation.
|
||||
pub(super) keywords: &'static [&'static str],
|
||||
|
||||
/// Subvtables for all fields of the element.
|
||||
pub(super) fields: &'static [FieldVtable<T>],
|
||||
/// Determines the ID for a field name. This is a separate function instead
|
||||
/// of searching through `fields` so that Rust can generate optimized code
|
||||
/// for the string matching.
|
||||
pub(super) field_id: fn(name: &str) -> Option<u8>,
|
||||
|
||||
/// The constructor of the element.
|
||||
pub(super) construct: fn(&mut Engine, &mut Args) -> SourceResult<Content>,
|
||||
/// The set rule of the element.
|
||||
pub(super) set: fn(&mut Engine, &mut Args) -> SourceResult<Styles>,
|
||||
/// The element's local name in a specific lang-region pairing.
|
||||
pub(super) local_name: Option<fn(Lang, Option<Region>) -> &'static str>,
|
||||
/// Produces the associated [`Scope`] of the element.
|
||||
pub(super) scope: fn() -> Scope,
|
||||
/// If the `capability` function returns `Some(p)`, then `p` must be a valid
|
||||
/// pointer to a native Rust vtable of `Packed<Self>` w.r.t to the trait `C`
|
||||
/// where `capability` is `TypeId::of::<dyn C>()`.
|
||||
pub(super) capability: fn(capability: TypeId) -> Option<NonNull<()>>,
|
||||
|
||||
/// The `Drop` impl (for the whole raw content). The content must have a
|
||||
/// reference count of zero and may not be used anymore after `drop` was
|
||||
/// called.
|
||||
pub(super) drop: unsafe fn(&mut RawContent),
|
||||
/// The `Clone` impl (for the whole raw content).
|
||||
pub(super) clone: unsafe fn(&T) -> RawContent,
|
||||
/// The `Hash` impl (for just the element).
|
||||
pub(super) hash: unsafe fn(&T) -> u128,
|
||||
/// The `Debug` impl (for just the element).
|
||||
pub(super) debug: unsafe fn(&T, &mut Formatter) -> fmt::Result,
|
||||
/// The `PartialEq` impl (for just the element). If this is `None`,
|
||||
/// field-wise equality checks (via `FieldVtable`) should be performed.
|
||||
pub(super) eq: Option<unsafe fn(&T, &T) -> bool>,
|
||||
/// The `Repr` impl (for just the element). If this is `None`, a generic
|
||||
/// name + fields representation should be produced.
|
||||
pub(super) repr: Option<unsafe fn(&T) -> EcoString>,
|
||||
|
||||
/// Produces a reference to a `static` variable holding a `LazyElementStore`
|
||||
/// that is unique for this element and can be populated with data that is
|
||||
/// somewhat costly to initialize at runtime and shouldn't be initialized
|
||||
/// over and over again. Must be a function rather than a direct reference
|
||||
/// so that we can store the vtable in a `const` without Rust complaining
|
||||
/// about the presence of interior mutability.
|
||||
pub(super) store: fn() -> &'static LazyElementStore,
|
||||
}
|
||||
|
||||
impl ContentVtable {
|
||||
/// Creates the vtable for an element.
|
||||
pub const fn new<E: NativeElement>(
|
||||
name: &'static str,
|
||||
title: &'static str,
|
||||
docs: &'static str,
|
||||
fields: &'static [FieldVtable<Packed<E>>],
|
||||
field_id: fn(name: &str) -> Option<u8>,
|
||||
capability: fn(TypeId) -> Option<NonNull<()>>,
|
||||
store: fn() -> &'static LazyElementStore,
|
||||
) -> ContentVtable<Packed<E>> {
|
||||
ContentVtable {
|
||||
name,
|
||||
title,
|
||||
docs,
|
||||
keywords: &[],
|
||||
fields,
|
||||
field_id,
|
||||
construct: <E as Construct>::construct,
|
||||
set: <E as Set>::set,
|
||||
local_name: None,
|
||||
scope: || Scope::new(),
|
||||
capability,
|
||||
drop: RawContent::drop_impl::<E>,
|
||||
clone: RawContent::clone_impl::<E>,
|
||||
hash: |elem| typst_utils::hash128(elem.as_ref()),
|
||||
debug: |elem, f| Debug::fmt(elem.as_ref(), f),
|
||||
eq: None,
|
||||
repr: None,
|
||||
store,
|
||||
}
|
||||
}
|
||||
|
||||
/// Retrieves the vtable of the element with the given ID.
|
||||
pub fn field(&self, id: u8) -> Option<&'static FieldVtable> {
|
||||
self.fields.get(usize::from(id))
|
||||
}
|
||||
}
|
||||
|
||||
impl<E: NativeElement> ContentVtable<Packed<E>> {
|
||||
/// Attaches search keywords for the documentation.
|
||||
pub const fn with_keywords(mut self, keywords: &'static [&'static str]) -> Self {
|
||||
self.keywords = keywords;
|
||||
self
|
||||
}
|
||||
|
||||
/// Takes a [`Repr`] impl into account.
|
||||
pub const fn with_repr(mut self) -> Self
|
||||
where
|
||||
E: Repr,
|
||||
{
|
||||
self.repr = Some(|e| E::repr(&**e));
|
||||
self
|
||||
}
|
||||
|
||||
/// Takes a [`PartialEq`] impl into account.
|
||||
pub const fn with_partial_eq(mut self) -> Self
|
||||
where
|
||||
E: PartialEq,
|
||||
{
|
||||
self.eq = Some(|a, b| E::eq(&**a, &**b));
|
||||
self
|
||||
}
|
||||
|
||||
/// Takes a [`LocalName`] impl into account.
|
||||
pub const fn with_local_name(mut self) -> Self
|
||||
where
|
||||
Packed<E>: LocalName,
|
||||
{
|
||||
self.local_name = Some(<Packed<E> as LocalName>::local_name);
|
||||
self
|
||||
}
|
||||
|
||||
/// Takes a [`NativeScope`] impl into account.
|
||||
pub const fn with_scope(mut self) -> Self
|
||||
where
|
||||
E: NativeScope,
|
||||
{
|
||||
self.scope = || E::scope();
|
||||
self
|
||||
}
|
||||
|
||||
/// Type-erases the data.
|
||||
pub const fn erase(self) -> ContentVtable {
|
||||
// Safety:
|
||||
// - `ContentVtable` is `repr(C)`.
|
||||
// - `ContentVtable` does not hold any `E`-specific data except for
|
||||
// function pointers.
|
||||
// - All functions pointers have the same memory layout.
|
||||
// - All functions containing `E` are marked as unsafe and callers need
|
||||
// to uphold the guarantee that they only call them with raw content
|
||||
// that is of type `E`.
|
||||
// - `Packed<E>` and `RawContent` have the exact same memory layout
|
||||
// because of `repr(transparent)`.
|
||||
unsafe {
|
||||
std::mem::transmute::<ContentVtable<Packed<E>>, ContentVtable<RawContent>>(
|
||||
self,
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> ContentHandle<T> {
|
||||
/// Provides safe access to operations for the field with the given `id`.
|
||||
pub(super) fn field(self, id: u8) -> Option<FieldHandle<T>> {
|
||||
self.fields.get(usize::from(id)).map(|vtable| {
|
||||
// Safety: Field vtables are of same type as the content vtable.
|
||||
unsafe { Handle::new(self.0, vtable) }
|
||||
})
|
||||
}
|
||||
|
||||
/// Provides safe access to all field operations.
|
||||
pub(super) fn fields(self) -> impl Iterator<Item = FieldHandle<T>>
|
||||
where
|
||||
T: Copy,
|
||||
{
|
||||
self.fields.iter().map(move |vtable| {
|
||||
// Safety: Field vtables are of same type as the content vtable.
|
||||
unsafe { Handle::new(self.0, vtable) }
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl ContentHandle<&RawContent> {
|
||||
/// See [`ContentVtable::debug`].
|
||||
pub fn debug(&self, f: &mut Formatter) -> fmt::Result {
|
||||
// Safety: `Handle` has the invariant that the vtable is matching.
|
||||
unsafe { (self.1.debug)(self.0, f) }
|
||||
}
|
||||
|
||||
/// See [`ContentVtable::repr`].
|
||||
pub fn repr(&self) -> Option<EcoString> {
|
||||
// Safety: `Handle` has the invariant that the vtable is matching.
|
||||
unsafe { self.1.repr.map(|f| f(self.0)) }
|
||||
}
|
||||
|
||||
/// See [`ContentVtable::clone`].
|
||||
pub fn clone(&self) -> RawContent {
|
||||
// Safety: `Handle` has the invariant that the vtable is matching.
|
||||
unsafe { (self.1.clone)(self.0) }
|
||||
}
|
||||
|
||||
/// See [`ContentVtable::hash`].
|
||||
pub fn hash(&self) -> u128 {
|
||||
// Safety: `Handle` has the invariant that the vtable is matching.
|
||||
unsafe { (self.1.hash)(self.0) }
|
||||
}
|
||||
}
|
||||
|
||||
impl ContentHandle<&mut RawContent> {
|
||||
/// See [`ContentVtable::drop`].
|
||||
pub unsafe fn drop(&mut self) {
|
||||
// Safety:
|
||||
// - `Handle` has the invariant that the vtable is matching.
|
||||
// - The caller satifies the requirements of `drop`
|
||||
unsafe { (self.1.drop)(self.0) }
|
||||
}
|
||||
}
|
||||
|
||||
impl ContentHandle<(&RawContent, &RawContent)> {
|
||||
/// See [`ContentVtable::eq`].
|
||||
pub fn eq(&self) -> Option<bool> {
|
||||
// Safety: `Handle` has the invariant that the vtable is matching.
|
||||
let (a, b) = self.0;
|
||||
unsafe { self.1.eq.map(|f| f(a, b)) }
|
||||
}
|
||||
}
|
||||
|
||||
/// A vtable for performing field-specific actions on type-erased
|
||||
/// content. Also contains general metadata for the specific field.
|
||||
#[repr(C)]
|
||||
pub struct FieldVtable<T: 'static = RawContent> {
|
||||
/// The field's name, as in code.
|
||||
pub(super) name: &'static str,
|
||||
/// The fields's documentation (as Markdown).
|
||||
pub(super) docs: &'static str,
|
||||
|
||||
/// Whether the field's parameter is positional.
|
||||
pub(super) positional: bool,
|
||||
/// Whether the field's parameter is variadic.
|
||||
pub(super) variadic: bool,
|
||||
/// Whether the field's parameter is required.
|
||||
pub(super) required: bool,
|
||||
/// Whether the field can be set via a set rule.
|
||||
pub(super) settable: bool,
|
||||
/// Whether the field is synthesized (i.e. initially not present).
|
||||
pub(super) synthesized: bool,
|
||||
/// Reflects what types the field's parameter accepts.
|
||||
pub(super) input: fn() -> CastInfo,
|
||||
/// Produces the default value of the field, if any. This would e.g. be
|
||||
/// `None` for a required parameter.
|
||||
pub(super) default: Option<fn() -> Value>,
|
||||
|
||||
/// Whether the field is set on the given element. Always true for required
|
||||
/// fields, but can be false for settable or synthesized fields.
|
||||
pub(super) has: unsafe fn(elem: &T) -> bool,
|
||||
/// Retrieves the field and [turns it into a
|
||||
/// value](crate::foundations::IntoValue).
|
||||
pub(super) get: unsafe fn(elem: &T) -> Option<Value>,
|
||||
/// Retrieves the field given styles. The resulting value may come from the
|
||||
/// element, the style chain, or a mix (if it's a
|
||||
/// [`Fold`](crate::foundations::Fold) field).
|
||||
pub(super) get_with_styles: unsafe fn(elem: &T, StyleChain) -> Option<Value>,
|
||||
/// Retrieves the field just from the styles.
|
||||
pub(super) get_from_styles: fn(StyleChain) -> Option<Value>,
|
||||
/// Sets the field from the styles if it is currently unset. (Or merges
|
||||
/// with the style data in case of a `Fold` field).
|
||||
pub(super) materialize: unsafe fn(elem: &mut T, styles: StyleChain),
|
||||
/// Compares the field for equality.
|
||||
pub(super) eq: unsafe fn(a: &T, b: &T) -> bool,
|
||||
}
|
||||
|
||||
impl FieldHandle<&RawContent> {
|
||||
/// See [`FieldVtable::has`].
|
||||
pub fn has(&self) -> bool {
|
||||
// Safety: `Handle` has the invariant that the vtable is matching.
|
||||
unsafe { (self.1.has)(self.0) }
|
||||
}
|
||||
|
||||
/// See [`FieldVtable::get`].
|
||||
pub fn get(&self) -> Option<Value> {
|
||||
// Safety: `Handle` has the invariant that the vtable is matching.
|
||||
unsafe { (self.1.get)(self.0) }
|
||||
}
|
||||
|
||||
/// See [`FieldVtable::get_with_styles`].
|
||||
pub fn get_with_styles(&self, styles: StyleChain) -> Option<Value> {
|
||||
// Safety: `Handle` has the invariant that the vtable is matching.
|
||||
unsafe { (self.1.get_with_styles)(self.0, styles) }
|
||||
}
|
||||
}
|
||||
|
||||
impl FieldHandle<&mut RawContent> {
|
||||
/// See [`FieldVtable::materialize`].
|
||||
pub fn materialize(&mut self, styles: StyleChain) {
|
||||
// Safety: `Handle` has the invariant that the vtable is matching.
|
||||
unsafe { (self.1.materialize)(self.0, styles) }
|
||||
}
|
||||
}
|
||||
|
||||
impl FieldHandle<(&RawContent, &RawContent)> {
|
||||
/// See [`FieldVtable::eq`].
|
||||
pub fn eq(&self) -> bool {
|
||||
// Safety: `Handle` has the invariant that the vtable is matching.
|
||||
let (a, b) = self.0;
|
||||
unsafe { (self.1.eq)(a, b) }
|
||||
}
|
||||
}
|
@ -17,7 +17,6 @@ mod datetime;
|
||||
mod decimal;
|
||||
mod dict;
|
||||
mod duration;
|
||||
mod element;
|
||||
mod fields;
|
||||
mod float;
|
||||
mod func;
|
||||
@ -49,7 +48,6 @@ pub use self::datetime::*;
|
||||
pub use self::decimal::*;
|
||||
pub use self::dict::*;
|
||||
pub use self::duration::*;
|
||||
pub use self::element::*;
|
||||
pub use self::fields::*;
|
||||
pub use self::float::*;
|
||||
pub use self::func::*;
|
||||
|
@ -8,8 +8,7 @@ use typst_syntax::Span;
|
||||
|
||||
use crate::diag::{bail, DeprecationSink, HintedStrResult, HintedString, StrResult};
|
||||
use crate::foundations::{
|
||||
Element, Func, IntoValue, NativeElement, NativeFunc, NativeFuncData, NativeType,
|
||||
Type, Value,
|
||||
Func, IntoValue, NativeElement, NativeFunc, NativeFuncData, NativeType, Value,
|
||||
};
|
||||
use crate::{Category, Library};
|
||||
|
||||
@ -149,15 +148,15 @@ impl Scope {
|
||||
/// Define a native type.
|
||||
#[track_caller]
|
||||
pub fn define_type<T: NativeType>(&mut self) -> &mut Binding {
|
||||
let data = T::data();
|
||||
self.define(data.name, Type::from(data))
|
||||
let ty = T::ty();
|
||||
self.define(ty.short_name(), ty)
|
||||
}
|
||||
|
||||
/// Define a native element.
|
||||
#[track_caller]
|
||||
pub fn define_elem<T: NativeElement>(&mut self) -> &mut Binding {
|
||||
let data = T::data();
|
||||
self.define(data.name, Element::from(data))
|
||||
let elem = T::ELEM;
|
||||
self.define(elem.name(), elem)
|
||||
}
|
||||
|
||||
/// Define a built-in with compile-time known name and returns a mutable
|
||||
|
@ -21,12 +21,12 @@ macro_rules! __select_where {
|
||||
let mut fields = ::smallvec::SmallVec::new();
|
||||
$(
|
||||
fields.push((
|
||||
<$ty as $crate::foundations::Fields>::Enum::$field as u8,
|
||||
<$ty>::$field.index(),
|
||||
$crate::foundations::IntoValue::into_value($value),
|
||||
));
|
||||
)*
|
||||
$crate::foundations::Selector::Elem(
|
||||
<$ty as $crate::foundations::NativeElement>::elem(),
|
||||
<$ty as $crate::foundations::NativeElement>::ELEM,
|
||||
Some(fields),
|
||||
)
|
||||
}};
|
||||
|
@ -12,8 +12,8 @@ use typst_utils::LazyHash;
|
||||
use crate::diag::{SourceResult, Trace, Tracepoint};
|
||||
use crate::engine::Engine;
|
||||
use crate::foundations::{
|
||||
cast, ty, Content, Context, Element, Func, NativeElement, OneOrMultiple, Repr,
|
||||
Selector,
|
||||
cast, ty, Content, Context, Element, Field, Func, NativeElement, OneOrMultiple,
|
||||
RefableProperty, Repr, Selector, SettableProperty,
|
||||
};
|
||||
use crate::text::{FontFamily, FontList, TextElem};
|
||||
|
||||
@ -48,7 +48,16 @@ impl Styles {
|
||||
/// If the property needs folding and the value is already contained in the
|
||||
/// style map, `self` contributes the outer values and `value` is the inner
|
||||
/// one.
|
||||
pub fn set(&mut self, style: impl Into<Style>) {
|
||||
pub fn set<E, const I: u8>(&mut self, field: Field<E, I>, value: E::Type)
|
||||
where
|
||||
E: SettableProperty<I>,
|
||||
E::Type: Debug + Clone + Hash + Send + Sync + 'static,
|
||||
{
|
||||
self.push(Property::new(field, value));
|
||||
}
|
||||
|
||||
/// Add a new style to the list.
|
||||
pub fn push(&mut self, style: impl Into<Style>) {
|
||||
self.0.push(LazyHash::new(style.into()));
|
||||
}
|
||||
|
||||
@ -101,22 +110,25 @@ impl Styles {
|
||||
}
|
||||
|
||||
/// Whether there is a style for the given field of the given element.
|
||||
pub fn has<T: NativeElement>(&self, field: u8) -> bool {
|
||||
let elem = T::elem();
|
||||
pub fn has<E: NativeElement, const I: u8>(&self, _: Field<E, I>) -> bool {
|
||||
let elem = E::ELEM;
|
||||
self.0
|
||||
.iter()
|
||||
.filter_map(|style| style.property())
|
||||
.any(|property| property.is_of(elem) && property.id == field)
|
||||
.any(|property| property.is_of(elem) && property.id == I)
|
||||
}
|
||||
|
||||
/// Set a font family composed of a preferred family and existing families
|
||||
/// from a style chain.
|
||||
pub fn set_family(&mut self, preferred: FontFamily, existing: StyleChain) {
|
||||
self.set(TextElem::set_font(FontList(
|
||||
self.set(
|
||||
TextElem::font,
|
||||
FontList(
|
||||
std::iter::once(preferred)
|
||||
.chain(TextElem::font_in(existing).into_iter().cloned())
|
||||
.chain(existing.get_ref(TextElem::font).into_iter().cloned())
|
||||
.collect(),
|
||||
)));
|
||||
),
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@ -281,14 +293,14 @@ pub struct Property {
|
||||
|
||||
impl Property {
|
||||
/// Create a new property from a key-value pair.
|
||||
pub fn new<E, T>(id: u8, value: T) -> Self
|
||||
pub fn new<E, const I: u8>(_: Field<E, I>, value: E::Type) -> Self
|
||||
where
|
||||
E: NativeElement,
|
||||
T: Debug + Clone + Hash + Send + Sync + 'static,
|
||||
E: SettableProperty<I>,
|
||||
E::Type: Debug + Clone + Hash + Send + Sync + 'static,
|
||||
{
|
||||
Self {
|
||||
elem: E::elem(),
|
||||
id,
|
||||
elem: E::ELEM,
|
||||
id: I,
|
||||
value: Block::new(value),
|
||||
span: Span::detached(),
|
||||
liftable: false,
|
||||
@ -340,8 +352,11 @@ impl Block {
|
||||
}
|
||||
|
||||
/// Downcasts the block to the specified type.
|
||||
fn downcast<T: 'static>(&self) -> Option<&T> {
|
||||
self.0.as_any().downcast_ref()
|
||||
fn downcast<T: 'static>(&self, func: Element, id: u8) -> &T {
|
||||
self.0
|
||||
.as_any()
|
||||
.downcast_ref()
|
||||
.unwrap_or_else(|| block_wrong_type(func, id, self))
|
||||
}
|
||||
}
|
||||
|
||||
@ -528,6 +543,103 @@ impl<'a> StyleChain<'a> {
|
||||
Self { head: &root.0, tail: None }
|
||||
}
|
||||
|
||||
/// Retrieves the value of the given field from the style chain.
|
||||
///
|
||||
/// A `Field` value is a zero-sized value that specifies which field of an
|
||||
/// element you want to retrieve on the type-system level. It also ensures
|
||||
/// that Rust can infer the correct return type.
|
||||
///
|
||||
/// Should be preferred over [`get_cloned`](Self::get_cloned) or
|
||||
/// [`get_ref`](Self::get_ref), but is only available for [`Copy`] types.
|
||||
/// For other types an explicit decision needs to be made whether cloning is
|
||||
/// necessary.
|
||||
pub fn get<E, const I: u8>(self, field: Field<E, I>) -> E::Type
|
||||
where
|
||||
E: SettableProperty<I>,
|
||||
E::Type: Copy,
|
||||
{
|
||||
self.get_cloned(field)
|
||||
}
|
||||
|
||||
/// Retrieves and clones the value from the style chain.
|
||||
///
|
||||
/// Prefer [`get`](Self::get) if the type is `Copy` and
|
||||
/// [`get_ref`](Self::get_ref) if a reference suffices.
|
||||
pub fn get_cloned<E, const I: u8>(self, _: Field<E, I>) -> E::Type
|
||||
where
|
||||
E: SettableProperty<I>,
|
||||
{
|
||||
if let Some(fold) = E::FOLD {
|
||||
self.get_folded::<E::Type>(E::ELEM, I, fold, E::default())
|
||||
} else {
|
||||
self.get_unfolded::<E::Type>(E::ELEM, I)
|
||||
.cloned()
|
||||
.unwrap_or_else(E::default)
|
||||
}
|
||||
}
|
||||
|
||||
/// Retrieves a reference to the value of the given field from the style
|
||||
/// chain.
|
||||
///
|
||||
/// Not possible if the value needs folding.
|
||||
pub fn get_ref<E, const I: u8>(self, _: Field<E, I>) -> &'a E::Type
|
||||
where
|
||||
E: RefableProperty<I>,
|
||||
{
|
||||
self.get_unfolded(E::ELEM, I).unwrap_or_else(|| E::default_ref())
|
||||
}
|
||||
|
||||
/// Retrieves the value and then immediately [resolves](Resolve) it.
|
||||
pub fn resolve<E, const I: u8>(
|
||||
self,
|
||||
field: Field<E, I>,
|
||||
) -> <E::Type as Resolve>::Output
|
||||
where
|
||||
E: SettableProperty<I>,
|
||||
E::Type: Resolve,
|
||||
{
|
||||
self.get_cloned(field).resolve(self)
|
||||
}
|
||||
|
||||
/// Retrieves a reference to a field, also taking into account the
|
||||
/// instance's value if any.
|
||||
fn get_unfolded<T: 'static>(self, func: Element, id: u8) -> Option<&'a T> {
|
||||
self.find(func, id).map(|block| block.downcast(func, id))
|
||||
}
|
||||
|
||||
/// Retrieves a reference to a field, also taking into account the
|
||||
/// instance's value if any.
|
||||
fn get_folded<T: 'static + Clone>(
|
||||
self,
|
||||
func: Element,
|
||||
id: u8,
|
||||
fold: fn(T, T) -> T,
|
||||
default: T,
|
||||
) -> T {
|
||||
let iter = self
|
||||
.properties(func, id)
|
||||
.map(|block| block.downcast::<T>(func, id).clone());
|
||||
|
||||
if let Some(folded) = iter.reduce(fold) {
|
||||
fold(folded, default)
|
||||
} else {
|
||||
default
|
||||
}
|
||||
}
|
||||
|
||||
/// Iterate over all values for the given property in the chain.
|
||||
fn find(self, func: Element, id: u8) -> Option<&'a Block> {
|
||||
self.properties(func, id).next()
|
||||
}
|
||||
|
||||
/// Iterate over all values for the given property in the chain.
|
||||
fn properties(self, func: Element, id: u8) -> impl Iterator<Item = &'a Block> {
|
||||
self.entries()
|
||||
.filter_map(|style| style.property())
|
||||
.filter(move |property| property.is(func, id))
|
||||
.map(|property| &property.value)
|
||||
}
|
||||
|
||||
/// Make the given chainable the first link of this chain.
|
||||
///
|
||||
/// The resulting style chain contains styles from `local` as well as
|
||||
@ -540,80 +652,6 @@ impl<'a> StyleChain<'a> {
|
||||
Chainable::chain(local, self)
|
||||
}
|
||||
|
||||
/// Cast the first value for the given property in the chain.
|
||||
pub fn get<T: Clone + 'static>(
|
||||
self,
|
||||
func: Element,
|
||||
id: u8,
|
||||
inherent: Option<&T>,
|
||||
default: impl Fn() -> T,
|
||||
) -> T {
|
||||
self.properties::<T>(func, id, inherent)
|
||||
.next()
|
||||
.cloned()
|
||||
.unwrap_or_else(default)
|
||||
}
|
||||
|
||||
/// Cast the first value for the given property in the chain,
|
||||
/// returning a borrowed value.
|
||||
pub fn get_ref<T: 'static>(
|
||||
self,
|
||||
func: Element,
|
||||
id: u8,
|
||||
inherent: Option<&'a T>,
|
||||
default: impl Fn() -> &'a T,
|
||||
) -> &'a T {
|
||||
self.properties::<T>(func, id, inherent)
|
||||
.next()
|
||||
.unwrap_or_else(default)
|
||||
}
|
||||
|
||||
/// Cast the first value for the given property in the chain, taking
|
||||
/// `Fold` implementations into account.
|
||||
pub fn get_folded<T: Fold + Clone + 'static>(
|
||||
self,
|
||||
func: Element,
|
||||
id: u8,
|
||||
inherent: Option<&T>,
|
||||
default: impl Fn() -> T,
|
||||
) -> T {
|
||||
fn next<T: Fold>(
|
||||
mut values: impl Iterator<Item = T>,
|
||||
default: &impl Fn() -> T,
|
||||
) -> T {
|
||||
values
|
||||
.next()
|
||||
.map(|value| value.fold(next(values, default)))
|
||||
.unwrap_or_else(default)
|
||||
}
|
||||
next(self.properties::<T>(func, id, inherent).cloned(), &default)
|
||||
}
|
||||
|
||||
/// Iterate over all values for the given property in the chain.
|
||||
fn properties<T: 'static>(
|
||||
self,
|
||||
func: Element,
|
||||
id: u8,
|
||||
inherent: Option<&'a T>,
|
||||
) -> impl Iterator<Item = &'a T> {
|
||||
inherent.into_iter().chain(
|
||||
self.entries()
|
||||
.filter_map(|style| style.property())
|
||||
.filter(move |property| property.is(func, id))
|
||||
.map(|property| &property.value)
|
||||
.map(move |value| {
|
||||
value.downcast().unwrap_or_else(|| {
|
||||
panic!(
|
||||
"attempted to read a value of a different type than was written {}.{}: {:?}",
|
||||
func.name(),
|
||||
func.field_name(id).unwrap(),
|
||||
value
|
||||
)
|
||||
})
|
||||
}),
|
||||
)
|
||||
}
|
||||
|
||||
/// Iterate over the entries of the chain.
|
||||
pub fn entries(self) -> Entries<'a> {
|
||||
Entries { inner: [].as_slice().iter(), links: self.links() }
|
||||
@ -804,6 +842,9 @@ impl<T: Resolve> Resolve for Option<T> {
|
||||
/// #set rect(stroke: 4pt)
|
||||
/// #rect()
|
||||
/// ```
|
||||
///
|
||||
/// Note: Folding must be associative, i.e. any implementation must satisfy
|
||||
/// `fold(fold(a, b), c) == fold(a, fold(b, c))`.
|
||||
pub trait Fold {
|
||||
/// Fold this inner value with an outer folded value.
|
||||
fn fold(self, outer: Self) -> Self;
|
||||
@ -847,6 +888,9 @@ impl<T> Fold for OneOrMultiple<T> {
|
||||
}
|
||||
}
|
||||
|
||||
/// A [folding](Fold) function.
|
||||
pub type FoldFn<T> = fn(T, T) -> T;
|
||||
|
||||
/// A variant of fold for foldable optional (`Option<T>`) values where an inner
|
||||
/// `None` value isn't respected (contrary to `Option`'s usual `Fold`
|
||||
/// implementation, with which folding with an inner `None` always returns
|
||||
@ -884,3 +928,13 @@ impl Fold for Depth {
|
||||
Self(outer.0 + self.0)
|
||||
}
|
||||
}
|
||||
|
||||
#[cold]
|
||||
fn block_wrong_type(func: Element, id: u8, value: &Block) -> ! {
|
||||
panic!(
|
||||
"attempted to read a value of a different type than was written {}.{}: {:?}",
|
||||
func.name(),
|
||||
func.field_name(id).unwrap(),
|
||||
value
|
||||
)
|
||||
}
|
||||
|
@ -73,5 +73,5 @@ pub struct TargetElem {
|
||||
/// ```
|
||||
#[func(contextual)]
|
||||
pub fn target(context: Tracked<Context>) -> HintedStrResult<Target> {
|
||||
Ok(TargetElem::target_in(context.styles()?))
|
||||
Ok(context.styles()?.get(TargetElem::target))
|
||||
}
|
||||
|
@ -47,21 +47,22 @@ pub struct HtmlElem {
|
||||
pub tag: HtmlTag,
|
||||
|
||||
/// The element's HTML attributes.
|
||||
#[borrowed]
|
||||
pub attrs: HtmlAttrs,
|
||||
|
||||
/// The contents of the HTML element.
|
||||
///
|
||||
/// The body can be arbitrary Typst content.
|
||||
#[positional]
|
||||
#[borrowed]
|
||||
pub body: Option<Content>,
|
||||
}
|
||||
|
||||
impl HtmlElem {
|
||||
/// Add an attribute to the element.
|
||||
pub fn with_attr(mut self, attr: HtmlAttr, value: impl Into<EcoString>) -> Self {
|
||||
self.attrs.get_or_insert_with(Default::default).push(attr, value);
|
||||
self.attrs
|
||||
.as_option_mut()
|
||||
.get_or_insert_with(Default::default)
|
||||
.push(attr, value);
|
||||
self
|
||||
}
|
||||
}
|
||||
|
@ -127,12 +127,12 @@ fn construct(element: &'static data::ElemInfo, args: &mut Args) -> SourceResult<
|
||||
let tag = HtmlTag::constant(element.name);
|
||||
let mut elem = HtmlElem::new(tag);
|
||||
if !attrs.0.is_empty() {
|
||||
elem.push_attrs(attrs);
|
||||
elem.attrs.set(attrs);
|
||||
}
|
||||
|
||||
if !tag::is_void(tag) {
|
||||
let body = args.eat::<Content>()?;
|
||||
elem.push_body(body);
|
||||
elem.body.set(body);
|
||||
}
|
||||
|
||||
Ok(elem.into_value())
|
||||
|
@ -338,7 +338,7 @@ impl Counter {
|
||||
|
||||
/// The selector relevant for this counter's updates.
|
||||
fn selector(&self) -> Selector {
|
||||
let mut selector = select_where!(CounterUpdateElem, Key => self.0.clone());
|
||||
let mut selector = select_where!(CounterUpdateElem, key => self.0.clone());
|
||||
|
||||
if let CounterKey::Selector(key) = &self.0 {
|
||||
selector = Selector::Or(eco_vec![selector, key.clone()]);
|
||||
@ -367,16 +367,16 @@ impl Counter {
|
||||
.or_else(|| {
|
||||
let styles = styles?;
|
||||
match self.0 {
|
||||
CounterKey::Page => PageElem::numbering_in(styles).clone(),
|
||||
CounterKey::Page => styles.get_cloned(PageElem::numbering),
|
||||
CounterKey::Selector(Selector::Elem(func, _)) => {
|
||||
if func == HeadingElem::elem() {
|
||||
HeadingElem::numbering_in(styles).clone()
|
||||
} else if func == FigureElem::elem() {
|
||||
FigureElem::numbering_in(styles).clone()
|
||||
} else if func == EquationElem::elem() {
|
||||
EquationElem::numbering_in(styles).clone()
|
||||
} else if func == FootnoteElem::elem() {
|
||||
Some(FootnoteElem::numbering_in(styles).clone())
|
||||
if func == HeadingElem::ELEM {
|
||||
styles.get_cloned(HeadingElem::numbering)
|
||||
} else if func == FigureElem::ELEM {
|
||||
styles.get_cloned(FigureElem::numbering)
|
||||
} else if func == EquationElem::ELEM {
|
||||
styles.get_cloned(EquationElem::numbering)
|
||||
} else if func == FootnoteElem::ELEM {
|
||||
Some(styles.get_cloned(FootnoteElem::numbering))
|
||||
} else {
|
||||
None
|
||||
}
|
||||
@ -398,7 +398,7 @@ impl Counter {
|
||||
|
||||
/// Selects all state updates.
|
||||
pub fn select_any() -> Selector {
|
||||
CounterUpdateElem::elem().select()
|
||||
CounterUpdateElem::ELEM.select()
|
||||
}
|
||||
}
|
||||
|
||||
@ -565,14 +565,14 @@ pub enum CounterKey {
|
||||
cast! {
|
||||
CounterKey,
|
||||
self => match self {
|
||||
Self::Page => PageElem::elem().into_value(),
|
||||
Self::Page => PageElem::ELEM.into_value(),
|
||||
Self::Selector(v) => v.into_value(),
|
||||
Self::Str(v) => v.into_value(),
|
||||
},
|
||||
v: Str => Self::Str(v),
|
||||
v: Label => Self::Selector(Selector::Label(v)),
|
||||
v: Element => {
|
||||
if v == PageElem::elem() {
|
||||
if v == PageElem::ELEM {
|
||||
Self::Page
|
||||
} else {
|
||||
Self::Selector(LocatableSelector::from_value(v.into_value())?.0)
|
||||
|
@ -259,12 +259,12 @@ impl State {
|
||||
|
||||
/// The selector for this state's updates.
|
||||
fn selector(&self) -> Selector {
|
||||
select_where!(StateUpdateElem, Key => self.key.clone())
|
||||
select_where!(StateUpdateElem, key => self.key.clone())
|
||||
}
|
||||
|
||||
/// Selects all state updates.
|
||||
pub fn select_any() -> Selector {
|
||||
StateUpdateElem::elem().select()
|
||||
StateUpdateElem::ELEM.select()
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -100,7 +100,7 @@ pub struct AlignElem {
|
||||
impl Show for Packed<AlignElem> {
|
||||
#[typst_macros::time(name = "align", span = self.span())]
|
||||
fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
|
||||
Ok(self.body.clone().aligned(self.alignment(styles)))
|
||||
Ok(self.body.clone().aligned(self.alignment.get(styles)))
|
||||
}
|
||||
}
|
||||
|
||||
@ -277,7 +277,7 @@ impl Resolve for Alignment {
|
||||
type Output = Axes<FixedAlignment>;
|
||||
|
||||
fn resolve(self, styles: StyleChain) -> Self::Output {
|
||||
self.fix(TextElem::dir_in(styles))
|
||||
self.fix(styles.resolve(TextElem::dir))
|
||||
}
|
||||
}
|
||||
|
||||
@ -378,7 +378,7 @@ impl Resolve for HAlignment {
|
||||
type Output = FixedAlignment;
|
||||
|
||||
fn resolve(self, styles: StyleChain) -> Self::Output {
|
||||
self.fix(TextElem::dir_in(styles))
|
||||
self.fix(styles.resolve(TextElem::dir))
|
||||
}
|
||||
}
|
||||
|
||||
@ -414,7 +414,7 @@ impl Resolve for OuterHAlignment {
|
||||
type Output = FixedAlignment;
|
||||
|
||||
fn resolve(self, styles: StyleChain) -> Self::Output {
|
||||
self.fix(TextElem::dir_in(styles))
|
||||
self.fix(styles.resolve(TextElem::dir))
|
||||
}
|
||||
}
|
||||
|
||||
@ -636,7 +636,7 @@ where
|
||||
type Output = Axes<FixedAlignment>;
|
||||
|
||||
fn resolve(self, styles: StyleChain) -> Self::Output {
|
||||
self.fix(TextElem::dir_in(styles))
|
||||
self.fix(styles.resolve(TextElem::dir))
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -49,7 +49,6 @@ pub struct ColumnsElem {
|
||||
pub count: NonZeroUsize,
|
||||
|
||||
/// The size of the gutter space between each column.
|
||||
#[resolve]
|
||||
#[default(Ratio::new(0.04).into())]
|
||||
pub gutter: Rel<Length>,
|
||||
|
||||
|
@ -51,7 +51,6 @@ pub struct BoxElem {
|
||||
/// ```example
|
||||
/// Image: #box(baseline: 40%, image("tiger.jpg", width: 2cm)).
|
||||
/// ```
|
||||
#[resolve]
|
||||
pub baseline: Rel<Length>,
|
||||
|
||||
/// The box's background color. See the
|
||||
@ -60,13 +59,11 @@ pub struct BoxElem {
|
||||
|
||||
/// The box's border color. See the
|
||||
/// [rectangle's documentation]($rect.stroke) for more details.
|
||||
#[resolve]
|
||||
#[fold]
|
||||
pub stroke: Sides<Option<Option<Stroke>>>,
|
||||
|
||||
/// How much to round the box's corners. See the
|
||||
/// [rectangle's documentation]($rect.radius) for more details.
|
||||
#[resolve]
|
||||
#[fold]
|
||||
pub radius: Corners<Option<Rel<Length>>>,
|
||||
|
||||
@ -78,7 +75,6 @@ pub struct BoxElem {
|
||||
/// ```example
|
||||
/// #rect(inset: 0pt)[Tight]
|
||||
/// ```
|
||||
#[resolve]
|
||||
#[fold]
|
||||
pub inset: Sides<Option<Rel<Length>>>,
|
||||
|
||||
@ -97,7 +93,6 @@ pub struct BoxElem {
|
||||
/// radius: 2pt,
|
||||
/// )[rectangle].
|
||||
/// ```
|
||||
#[resolve]
|
||||
#[fold]
|
||||
pub outset: Sides<Option<Rel<Length>>>,
|
||||
|
||||
@ -119,7 +114,6 @@ pub struct BoxElem {
|
||||
|
||||
/// The contents of the box.
|
||||
#[positional]
|
||||
#[borrowed]
|
||||
pub body: Option<Content>,
|
||||
}
|
||||
|
||||
@ -262,25 +256,21 @@ pub struct BlockElem {
|
||||
|
||||
/// The block's border color. See the
|
||||
/// [rectangle's documentation]($rect.stroke) for more details.
|
||||
#[resolve]
|
||||
#[fold]
|
||||
pub stroke: Sides<Option<Option<Stroke>>>,
|
||||
|
||||
/// How much to round the block's corners. See the
|
||||
/// [rectangle's documentation]($rect.radius) for more details.
|
||||
#[resolve]
|
||||
#[fold]
|
||||
pub radius: Corners<Option<Rel<Length>>>,
|
||||
|
||||
/// How much to pad the block's content. See the
|
||||
/// [box's documentation]($box.inset) for more details.
|
||||
#[resolve]
|
||||
#[fold]
|
||||
pub inset: Sides<Option<Rel<Length>>>,
|
||||
|
||||
/// How much to expand the block's size without affecting the layout. See
|
||||
/// the [box's documentation]($box.outset) for more details.
|
||||
#[resolve]
|
||||
#[fold]
|
||||
pub outset: Sides<Option<Rel<Length>>>,
|
||||
|
||||
@ -358,7 +348,6 @@ pub struct BlockElem {
|
||||
|
||||
/// The contents of the block.
|
||||
#[positional]
|
||||
#[borrowed]
|
||||
pub body: Option<BlockBody>,
|
||||
}
|
||||
|
||||
|
@ -167,7 +167,7 @@ impl Resolve for Em {
|
||||
if self.is_zero() {
|
||||
Abs::zero()
|
||||
} else {
|
||||
self.at(TextElem::size_in(styles))
|
||||
self.at(styles.resolve(TextElem::size))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -144,14 +144,12 @@ pub struct GridElem {
|
||||
/// with that many `{auto}`-sized columns. Note that opposed to rows and
|
||||
/// gutters, providing a single track size will only ever create a single
|
||||
/// column.
|
||||
#[borrowed]
|
||||
pub columns: TrackSizings,
|
||||
|
||||
/// The row sizes.
|
||||
///
|
||||
/// If there are more cells than fit the defined rows, the last row is
|
||||
/// repeated until there are no more cells.
|
||||
#[borrowed]
|
||||
pub rows: TrackSizings,
|
||||
|
||||
/// The gaps between rows and columns.
|
||||
@ -169,12 +167,10 @@ pub struct GridElem {
|
||||
let gutter = args.named("gutter")?;
|
||||
args.named("column-gutter")?.or_else(|| gutter.clone())
|
||||
)]
|
||||
#[borrowed]
|
||||
pub column_gutter: TrackSizings,
|
||||
|
||||
/// The gaps between rows.
|
||||
#[parse(args.named("row-gutter")?.or_else(|| gutter.clone()))]
|
||||
#[borrowed]
|
||||
pub row_gutter: TrackSizings,
|
||||
|
||||
/// How to fill the cells.
|
||||
@ -197,7 +193,6 @@ pub struct GridElem {
|
||||
/// [O], [X], [O], [X],
|
||||
/// )
|
||||
/// ```
|
||||
#[borrowed]
|
||||
pub fill: Celled<Option<Paint>>,
|
||||
|
||||
/// How to align the cells' content.
|
||||
@ -209,7 +204,6 @@ pub struct GridElem {
|
||||
///
|
||||
/// You can find an example for this argument at the
|
||||
/// [`table.align`]($table.align) parameter.
|
||||
#[borrowed]
|
||||
pub align: Celled<Smart<Alignment>>,
|
||||
|
||||
/// How to [stroke]($stroke) the cells.
|
||||
@ -289,7 +283,6 @@ pub struct GridElem {
|
||||
/// ),
|
||||
/// )
|
||||
/// ```
|
||||
#[resolve]
|
||||
#[fold]
|
||||
pub stroke: Celled<Sides<Option<Option<Arc<Stroke>>>>>,
|
||||
|
||||
@ -541,7 +534,6 @@ pub struct GridHLine {
|
||||
///
|
||||
/// Specifying `{none}` removes any lines previously placed across this
|
||||
/// line's range, including hlines or per-cell stroke below it.
|
||||
#[resolve]
|
||||
#[fold]
|
||||
#[default(Some(Arc::new(Stroke::default())))]
|
||||
pub stroke: Option<Arc<Stroke>>,
|
||||
@ -596,7 +588,6 @@ pub struct GridVLine {
|
||||
///
|
||||
/// Specifying `{none}` removes any lines previously placed across this
|
||||
/// line's range, including vlines or per-cell stroke below it.
|
||||
#[resolve]
|
||||
#[fold]
|
||||
#[default(Some(Arc::new(Stroke::default())))]
|
||||
pub stroke: Option<Arc<Stroke>>,
|
||||
@ -742,7 +733,6 @@ pub struct GridCell {
|
||||
pub inset: Smart<Sides<Option<Rel<Length>>>>,
|
||||
|
||||
/// The cell's [stroke]($grid.stroke) override.
|
||||
#[resolve]
|
||||
#[fold]
|
||||
pub stroke: Sides<Option<Option<Arc<Stroke>>>>,
|
||||
|
||||
@ -760,7 +750,7 @@ cast! {
|
||||
|
||||
impl Show for Packed<GridCell> {
|
||||
fn show(&self, _engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
|
||||
show_grid_cell(self.body.clone(), self.inset(styles), self.align(styles))
|
||||
show_grid_cell(self.body.clone(), self.inset.get(styles), self.align.get(styles))
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -31,14 +31,14 @@ pub fn grid_to_cellgrid<'a>(
|
||||
locator: Locator<'a>,
|
||||
styles: StyleChain,
|
||||
) -> SourceResult<CellGrid<'a>> {
|
||||
let inset = elem.inset(styles);
|
||||
let align = elem.align(styles);
|
||||
let columns = elem.columns(styles);
|
||||
let rows = elem.rows(styles);
|
||||
let column_gutter = elem.column_gutter(styles);
|
||||
let row_gutter = elem.row_gutter(styles);
|
||||
let fill = elem.fill(styles);
|
||||
let stroke = elem.stroke(styles);
|
||||
let inset = elem.inset.get_cloned(styles);
|
||||
let align = elem.align.get_ref(styles);
|
||||
let columns = elem.columns.get_ref(styles);
|
||||
let rows = elem.rows.get_ref(styles);
|
||||
let column_gutter = elem.column_gutter.get_ref(styles);
|
||||
let row_gutter = elem.row_gutter.get_ref(styles);
|
||||
let fill = elem.fill.get_ref(styles);
|
||||
let stroke = elem.stroke.resolve(styles);
|
||||
|
||||
let tracks = Axes::new(columns.0.as_slice(), rows.0.as_slice());
|
||||
let gutter = Axes::new(column_gutter.0.as_slice(), row_gutter.0.as_slice());
|
||||
@ -47,13 +47,13 @@ pub fn grid_to_cellgrid<'a>(
|
||||
let resolve_item = |item: &GridItem| grid_item_to_resolvable(item, styles);
|
||||
let children = elem.children.iter().map(|child| match child {
|
||||
GridChild::Header(header) => ResolvableGridChild::Header {
|
||||
repeat: header.repeat(styles),
|
||||
level: header.level(styles),
|
||||
repeat: header.repeat.get(styles),
|
||||
level: header.level.get(styles),
|
||||
span: header.span(),
|
||||
items: header.children.iter().map(resolve_item),
|
||||
},
|
||||
GridChild::Footer(footer) => ResolvableGridChild::Footer {
|
||||
repeat: footer.repeat(styles),
|
||||
repeat: footer.repeat.get(styles),
|
||||
span: footer.span(),
|
||||
items: footer.children.iter().map(resolve_item),
|
||||
},
|
||||
@ -85,14 +85,14 @@ pub fn table_to_cellgrid<'a>(
|
||||
locator: Locator<'a>,
|
||||
styles: StyleChain,
|
||||
) -> SourceResult<CellGrid<'a>> {
|
||||
let inset = elem.inset(styles);
|
||||
let align = elem.align(styles);
|
||||
let columns = elem.columns(styles);
|
||||
let rows = elem.rows(styles);
|
||||
let column_gutter = elem.column_gutter(styles);
|
||||
let row_gutter = elem.row_gutter(styles);
|
||||
let fill = elem.fill(styles);
|
||||
let stroke = elem.stroke(styles);
|
||||
let inset = elem.inset.get_cloned(styles);
|
||||
let align = elem.align.get_ref(styles);
|
||||
let columns = elem.columns.get_ref(styles);
|
||||
let rows = elem.rows.get_ref(styles);
|
||||
let column_gutter = elem.column_gutter.get_ref(styles);
|
||||
let row_gutter = elem.row_gutter.get_ref(styles);
|
||||
let fill = elem.fill.get_ref(styles);
|
||||
let stroke = elem.stroke.resolve(styles);
|
||||
|
||||
let tracks = Axes::new(columns.0.as_slice(), rows.0.as_slice());
|
||||
let gutter = Axes::new(column_gutter.0.as_slice(), row_gutter.0.as_slice());
|
||||
@ -101,13 +101,13 @@ pub fn table_to_cellgrid<'a>(
|
||||
let resolve_item = |item: &TableItem| table_item_to_resolvable(item, styles);
|
||||
let children = elem.children.iter().map(|child| match child {
|
||||
TableChild::Header(header) => ResolvableGridChild::Header {
|
||||
repeat: header.repeat(styles),
|
||||
level: header.level(styles),
|
||||
repeat: header.repeat.get(styles),
|
||||
level: header.level.get(styles),
|
||||
span: header.span(),
|
||||
items: header.children.iter().map(resolve_item),
|
||||
},
|
||||
TableChild::Footer(footer) => ResolvableGridChild::Footer {
|
||||
repeat: footer.repeat(styles),
|
||||
repeat: footer.repeat.get(styles),
|
||||
span: footer.span(),
|
||||
items: footer.children.iter().map(resolve_item),
|
||||
},
|
||||
@ -137,27 +137,27 @@ fn grid_item_to_resolvable(
|
||||
) -> ResolvableGridItem<Packed<GridCell>> {
|
||||
match item {
|
||||
GridItem::HLine(hline) => ResolvableGridItem::HLine {
|
||||
y: hline.y(styles),
|
||||
start: hline.start(styles),
|
||||
end: hline.end(styles),
|
||||
stroke: hline.stroke(styles),
|
||||
y: hline.y.get(styles),
|
||||
start: hline.start.get(styles),
|
||||
end: hline.end.get(styles),
|
||||
stroke: hline.stroke.resolve(styles),
|
||||
span: hline.span(),
|
||||
position: match hline.position(styles) {
|
||||
position: match hline.position.get(styles) {
|
||||
OuterVAlignment::Top => LinePosition::Before,
|
||||
OuterVAlignment::Bottom => LinePosition::After,
|
||||
},
|
||||
},
|
||||
GridItem::VLine(vline) => ResolvableGridItem::VLine {
|
||||
x: vline.x(styles),
|
||||
start: vline.start(styles),
|
||||
end: vline.end(styles),
|
||||
stroke: vline.stroke(styles),
|
||||
x: vline.x.get(styles),
|
||||
start: vline.start.get(styles),
|
||||
end: vline.end.get(styles),
|
||||
stroke: vline.stroke.resolve(styles),
|
||||
span: vline.span(),
|
||||
position: match vline.position(styles) {
|
||||
OuterHAlignment::Left if TextElem::dir_in(styles) == Dir::RTL => {
|
||||
position: match vline.position.get(styles) {
|
||||
OuterHAlignment::Left if styles.resolve(TextElem::dir) == Dir::RTL => {
|
||||
LinePosition::After
|
||||
}
|
||||
OuterHAlignment::Right if TextElem::dir_in(styles) == Dir::RTL => {
|
||||
OuterHAlignment::Right if styles.resolve(TextElem::dir) == Dir::RTL => {
|
||||
LinePosition::Before
|
||||
}
|
||||
OuterHAlignment::Start | OuterHAlignment::Left => LinePosition::Before,
|
||||
@ -174,27 +174,27 @@ fn table_item_to_resolvable(
|
||||
) -> ResolvableGridItem<Packed<TableCell>> {
|
||||
match item {
|
||||
TableItem::HLine(hline) => ResolvableGridItem::HLine {
|
||||
y: hline.y(styles),
|
||||
start: hline.start(styles),
|
||||
end: hline.end(styles),
|
||||
stroke: hline.stroke(styles),
|
||||
y: hline.y.get(styles),
|
||||
start: hline.start.get(styles),
|
||||
end: hline.end.get(styles),
|
||||
stroke: hline.stroke.resolve(styles),
|
||||
span: hline.span(),
|
||||
position: match hline.position(styles) {
|
||||
position: match hline.position.get(styles) {
|
||||
OuterVAlignment::Top => LinePosition::Before,
|
||||
OuterVAlignment::Bottom => LinePosition::After,
|
||||
},
|
||||
},
|
||||
TableItem::VLine(vline) => ResolvableGridItem::VLine {
|
||||
x: vline.x(styles),
|
||||
start: vline.start(styles),
|
||||
end: vline.end(styles),
|
||||
stroke: vline.stroke(styles),
|
||||
x: vline.x.get(styles),
|
||||
start: vline.start.get(styles),
|
||||
end: vline.end.get(styles),
|
||||
stroke: vline.stroke.resolve(styles),
|
||||
span: vline.span(),
|
||||
position: match vline.position(styles) {
|
||||
OuterHAlignment::Left if TextElem::dir_in(styles) == Dir::RTL => {
|
||||
position: match vline.position.get(styles) {
|
||||
OuterHAlignment::Left if styles.resolve(TextElem::dir) == Dir::RTL => {
|
||||
LinePosition::After
|
||||
}
|
||||
OuterHAlignment::Right if TextElem::dir_in(styles) == Dir::RTL => {
|
||||
OuterHAlignment::Right if styles.resolve(TextElem::dir) == Dir::RTL => {
|
||||
LinePosition::Before
|
||||
}
|
||||
OuterHAlignment::Start | OuterHAlignment::Left => LinePosition::Before,
|
||||
@ -219,12 +219,12 @@ impl ResolvableCell for Packed<TableCell> {
|
||||
styles: StyleChain,
|
||||
) -> Cell<'a> {
|
||||
let cell = &mut *self;
|
||||
let colspan = cell.colspan(styles);
|
||||
let rowspan = cell.rowspan(styles);
|
||||
let breakable = cell.breakable(styles).unwrap_or(breakable);
|
||||
let fill = cell.fill(styles).unwrap_or_else(|| fill.clone());
|
||||
let colspan = cell.colspan.get(styles);
|
||||
let rowspan = cell.rowspan.get(styles);
|
||||
let breakable = cell.breakable.get(styles).unwrap_or(breakable);
|
||||
let fill = cell.fill.get_cloned(styles).unwrap_or_else(|| fill.clone());
|
||||
|
||||
let cell_stroke = cell.stroke(styles);
|
||||
let cell_stroke = cell.stroke.resolve(styles);
|
||||
let stroke_overridden =
|
||||
cell_stroke.as_ref().map(|side| matches!(side, Some(Some(_))));
|
||||
|
||||
@ -238,22 +238,22 @@ impl ResolvableCell for Packed<TableCell> {
|
||||
// cell stroke is the same as specifying 'none', so we equate the two
|
||||
// concepts.
|
||||
let stroke = cell_stroke.fold(stroke).map(Option::flatten);
|
||||
cell.push_x(Smart::Custom(x));
|
||||
cell.push_y(Smart::Custom(y));
|
||||
cell.push_fill(Smart::Custom(fill.clone()));
|
||||
cell.push_align(match align {
|
||||
Smart::Custom(align) => {
|
||||
Smart::Custom(cell.align(styles).map_or(align, |inner| inner.fold(align)))
|
||||
}
|
||||
cell.x.set(Smart::Custom(x));
|
||||
cell.y.set(Smart::Custom(y));
|
||||
cell.fill.set(Smart::Custom(fill.clone()));
|
||||
cell.align.set(match align {
|
||||
Smart::Custom(align) => Smart::Custom(
|
||||
cell.align.get(styles).map_or(align, |inner| inner.fold(align)),
|
||||
),
|
||||
// Don't fold if the table is using outer alignment. Use the
|
||||
// cell's alignment instead (which, in the end, will fold with
|
||||
// the outer alignment when it is effectively displayed).
|
||||
Smart::Auto => cell.align(styles),
|
||||
Smart::Auto => cell.align.get(styles),
|
||||
});
|
||||
cell.push_inset(Smart::Custom(
|
||||
cell.inset(styles).map_or(inset, |inner| inner.fold(inset)),
|
||||
cell.inset.set(Smart::Custom(
|
||||
cell.inset.get(styles).map_or(inset, |inner| inner.fold(inset)),
|
||||
));
|
||||
cell.push_stroke(
|
||||
cell.stroke.set(
|
||||
// Here we convert the resolved stroke to a regular stroke, however
|
||||
// with resolved units (that is, 'em' converted to absolute units).
|
||||
// We also convert any stroke unspecified by both the cell and the
|
||||
@ -266,7 +266,7 @@ impl ResolvableCell for Packed<TableCell> {
|
||||
}))
|
||||
}),
|
||||
);
|
||||
cell.push_breakable(Smart::Custom(breakable));
|
||||
cell.breakable.set(Smart::Custom(breakable));
|
||||
Cell {
|
||||
body: self.pack(),
|
||||
locator,
|
||||
@ -280,19 +280,19 @@ impl ResolvableCell for Packed<TableCell> {
|
||||
}
|
||||
|
||||
fn x(&self, styles: StyleChain) -> Smart<usize> {
|
||||
(**self).x(styles)
|
||||
self.x.get(styles)
|
||||
}
|
||||
|
||||
fn y(&self, styles: StyleChain) -> Smart<usize> {
|
||||
(**self).y(styles)
|
||||
self.y.get(styles)
|
||||
}
|
||||
|
||||
fn colspan(&self, styles: StyleChain) -> NonZeroUsize {
|
||||
(**self).colspan(styles)
|
||||
self.colspan.get(styles)
|
||||
}
|
||||
|
||||
fn rowspan(&self, styles: StyleChain) -> NonZeroUsize {
|
||||
(**self).rowspan(styles)
|
||||
self.rowspan.get(styles)
|
||||
}
|
||||
|
||||
fn span(&self) -> Span {
|
||||
@ -314,12 +314,12 @@ impl ResolvableCell for Packed<GridCell> {
|
||||
styles: StyleChain,
|
||||
) -> Cell<'a> {
|
||||
let cell = &mut *self;
|
||||
let colspan = cell.colspan(styles);
|
||||
let rowspan = cell.rowspan(styles);
|
||||
let breakable = cell.breakable(styles).unwrap_or(breakable);
|
||||
let fill = cell.fill(styles).unwrap_or_else(|| fill.clone());
|
||||
let colspan = cell.colspan.get(styles);
|
||||
let rowspan = cell.rowspan.get(styles);
|
||||
let breakable = cell.breakable.get(styles).unwrap_or(breakable);
|
||||
let fill = cell.fill.get_cloned(styles).unwrap_or_else(|| fill.clone());
|
||||
|
||||
let cell_stroke = cell.stroke(styles);
|
||||
let cell_stroke = cell.stroke.resolve(styles);
|
||||
let stroke_overridden =
|
||||
cell_stroke.as_ref().map(|side| matches!(side, Some(Some(_))));
|
||||
|
||||
@ -333,22 +333,22 @@ impl ResolvableCell for Packed<GridCell> {
|
||||
// cell stroke is the same as specifying 'none', so we equate the two
|
||||
// concepts.
|
||||
let stroke = cell_stroke.fold(stroke).map(Option::flatten);
|
||||
cell.push_x(Smart::Custom(x));
|
||||
cell.push_y(Smart::Custom(y));
|
||||
cell.push_fill(Smart::Custom(fill.clone()));
|
||||
cell.push_align(match align {
|
||||
Smart::Custom(align) => {
|
||||
Smart::Custom(cell.align(styles).map_or(align, |inner| inner.fold(align)))
|
||||
}
|
||||
cell.x.set(Smart::Custom(x));
|
||||
cell.y.set(Smart::Custom(y));
|
||||
cell.fill.set(Smart::Custom(fill.clone()));
|
||||
cell.align.set(match align {
|
||||
Smart::Custom(align) => Smart::Custom(
|
||||
cell.align.get(styles).map_or(align, |inner| inner.fold(align)),
|
||||
),
|
||||
// Don't fold if the grid is using outer alignment. Use the
|
||||
// cell's alignment instead (which, in the end, will fold with
|
||||
// the outer alignment when it is effectively displayed).
|
||||
Smart::Auto => cell.align(styles),
|
||||
Smart::Auto => cell.align.get(styles),
|
||||
});
|
||||
cell.push_inset(Smart::Custom(
|
||||
cell.inset(styles).map_or(inset, |inner| inner.fold(inset)),
|
||||
cell.inset.set(Smart::Custom(
|
||||
cell.inset.get(styles).map_or(inset, |inner| inner.fold(inset)),
|
||||
));
|
||||
cell.push_stroke(
|
||||
cell.stroke.set(
|
||||
// Here we convert the resolved stroke to a regular stroke, however
|
||||
// with resolved units (that is, 'em' converted to absolute units).
|
||||
// We also convert any stroke unspecified by both the cell and the
|
||||
@ -361,7 +361,7 @@ impl ResolvableCell for Packed<GridCell> {
|
||||
}))
|
||||
}),
|
||||
);
|
||||
cell.push_breakable(Smart::Custom(breakable));
|
||||
cell.breakable.set(Smart::Custom(breakable));
|
||||
Cell {
|
||||
body: self.pack(),
|
||||
locator,
|
||||
@ -375,19 +375,19 @@ impl ResolvableCell for Packed<GridCell> {
|
||||
}
|
||||
|
||||
fn x(&self, styles: StyleChain) -> Smart<usize> {
|
||||
(**self).x(styles)
|
||||
self.x.get(styles)
|
||||
}
|
||||
|
||||
fn y(&self, styles: StyleChain) -> Smart<usize> {
|
||||
(**self).y(styles)
|
||||
self.y.get(styles)
|
||||
}
|
||||
|
||||
fn colspan(&self, styles: StyleChain) -> NonZeroUsize {
|
||||
(**self).colspan(styles)
|
||||
self.colspan.get(styles)
|
||||
}
|
||||
|
||||
fn rowspan(&self, styles: StyleChain) -> NonZeroUsize {
|
||||
(**self).rowspan(styles)
|
||||
self.rowspan.get(styles)
|
||||
}
|
||||
|
||||
fn span(&self) -> Span {
|
||||
|
@ -29,6 +29,6 @@ pub struct HideElem {
|
||||
impl Show for Packed<HideElem> {
|
||||
#[typst_macros::time(name = "hide", span = self.span())]
|
||||
fn show(&self, _: &mut Engine, _: StyleChain) -> SourceResult<Content> {
|
||||
Ok(self.body.clone().styled(HideElem::set_hidden(true)))
|
||||
Ok(self.body.clone().set(HideElem::hidden, true))
|
||||
}
|
||||
}
|
||||
|
@ -60,7 +60,6 @@ pub struct PageElem {
|
||||
/// box(square(width: 1cm))
|
||||
/// }
|
||||
/// ```
|
||||
#[resolve]
|
||||
#[parse(
|
||||
let paper = args.named_or_find::<Paper>("paper")?;
|
||||
args.named("width")?
|
||||
@ -77,7 +76,6 @@ pub struct PageElem {
|
||||
/// page set rule. Most examples throughout this documentation use `{auto}`
|
||||
/// for the height of the page to dynamically grow and shrink to fit their
|
||||
/// content.
|
||||
#[resolve]
|
||||
#[parse(
|
||||
args.named("height")?
|
||||
.or_else(|| paper.map(|paper| Smart::Custom(paper.height().into())))
|
||||
@ -201,7 +199,6 @@ pub struct PageElem {
|
||||
/// #set text(fill: rgb("fdfdfd"))
|
||||
/// *Dark mode enabled.*
|
||||
/// ```
|
||||
#[borrowed]
|
||||
#[ghost]
|
||||
pub fill: Smart<Option<Paint>>,
|
||||
|
||||
@ -219,7 +216,6 @@ pub struct PageElem {
|
||||
///
|
||||
/// #lorem(48)
|
||||
/// ```
|
||||
#[borrowed]
|
||||
#[ghost]
|
||||
pub numbering: Option<Numbering>,
|
||||
|
||||
@ -276,12 +272,10 @@ pub struct PageElem {
|
||||
///
|
||||
/// #lorem(19)
|
||||
/// ```
|
||||
#[borrowed]
|
||||
#[ghost]
|
||||
pub header: Smart<Option<Content>>,
|
||||
|
||||
/// The amount the header is raised into the top margin.
|
||||
#[resolve]
|
||||
#[default(Ratio::new(0.3).into())]
|
||||
#[ghost]
|
||||
pub header_ascent: Rel<Length>,
|
||||
@ -314,12 +308,10 @@ pub struct PageElem {
|
||||
///
|
||||
/// #lorem(48)
|
||||
/// ```
|
||||
#[borrowed]
|
||||
#[ghost]
|
||||
pub footer: Smart<Option<Content>>,
|
||||
|
||||
/// The amount the footer is lowered into the bottom margin.
|
||||
#[resolve]
|
||||
#[default(Ratio::new(0.3).into())]
|
||||
#[ghost]
|
||||
pub footer_descent: Rel<Length>,
|
||||
@ -340,7 +332,6 @@ pub struct PageElem {
|
||||
/// In the year 2023, we plan to take
|
||||
/// over the world (of typesetting).
|
||||
/// ```
|
||||
#[borrowed]
|
||||
#[ghost]
|
||||
pub background: Option<Content>,
|
||||
|
||||
@ -355,7 +346,6 @@ pub struct PageElem {
|
||||
/// "Weak Reject" because they did
|
||||
/// not understand our approach...
|
||||
/// ```
|
||||
#[borrowed]
|
||||
#[ghost]
|
||||
pub foreground: Option<Content>,
|
||||
|
||||
|
@ -134,7 +134,6 @@ pub struct PlaceElem {
|
||||
///
|
||||
/// Has no effect if `float` is `{false}`.
|
||||
#[default(Em::new(1.5).into())]
|
||||
#[resolve]
|
||||
pub clearance: Length,
|
||||
|
||||
/// The horizontal displacement of the placed content.
|
||||
|
@ -62,7 +62,6 @@ pub struct AccentElem {
|
||||
/// ```example
|
||||
/// $dash(A, size: #150%)$
|
||||
/// ```
|
||||
#[resolve]
|
||||
#[default(Rel::one())]
|
||||
pub size: Rel<Length>,
|
||||
|
||||
|
@ -59,9 +59,9 @@ impl Packed<AttachElem> {
|
||||
|
||||
macro_rules! merge {
|
||||
($content:ident) => {
|
||||
if base.$content.is_none() && elem.$content.is_some() {
|
||||
if !base.$content.is_set() && elem.$content.is_set() {
|
||||
base.$content = elem.$content.clone();
|
||||
elem.$content = None;
|
||||
elem.$content.unset();
|
||||
}
|
||||
};
|
||||
}
|
||||
@ -152,7 +152,6 @@ pub struct StretchElem {
|
||||
|
||||
/// The size to stretch to, relative to the maximum size of the glyph and
|
||||
/// its attachments.
|
||||
#[resolve]
|
||||
#[default(Rel::one())]
|
||||
pub size: Rel<Length>,
|
||||
}
|
||||
|
@ -29,7 +29,6 @@ pub struct CancelElem {
|
||||
/// $ a + cancel(x, length: #200%)
|
||||
/// - cancel(x, length: #200%) $
|
||||
/// ```
|
||||
#[resolve]
|
||||
#[default(Rel::new(Ratio::one(), Abs::pt(3.0).into()))]
|
||||
pub length: Rel<Length>,
|
||||
|
||||
@ -89,7 +88,6 @@ pub struct CancelElem {
|
||||
/// ),
|
||||
/// ) $
|
||||
/// ```
|
||||
#[resolve]
|
||||
#[fold]
|
||||
#[default(Stroke {
|
||||
// Default stroke has 0.5pt for better visuals.
|
||||
|
@ -63,7 +63,6 @@ pub struct EquationElem {
|
||||
/// With @ratio, we get:
|
||||
/// $ F_n = floor(1 / sqrt(5) phi.alt^n) $
|
||||
/// ```
|
||||
#[borrowed]
|
||||
pub numbering: Option<Numbering>,
|
||||
|
||||
/// The alignment of the equation numbering.
|
||||
@ -152,7 +151,7 @@ impl Synthesize for Packed<EquationElem> {
|
||||
engine: &mut Engine,
|
||||
styles: StyleChain,
|
||||
) -> SourceResult<()> {
|
||||
let supplement = match self.as_ref().supplement(styles) {
|
||||
let supplement = match self.as_ref().supplement.get_ref(styles) {
|
||||
Smart::Auto => TextElem::packed(Self::local_name_in(styles)),
|
||||
Smart::Custom(None) => Content::empty(),
|
||||
Smart::Custom(Some(supplement)) => {
|
||||
@ -160,14 +159,15 @@ impl Synthesize for Packed<EquationElem> {
|
||||
}
|
||||
};
|
||||
|
||||
self.push_supplement(Smart::Custom(Some(Supplement::Content(supplement))));
|
||||
self.supplement
|
||||
.set(Smart::Custom(Some(Supplement::Content(supplement))));
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl Show for Packed<EquationElem> {
|
||||
fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
|
||||
if self.block(styles) {
|
||||
if self.block.get(styles) {
|
||||
Ok(BlockElem::multi_layouter(
|
||||
self.clone(),
|
||||
engine.routines.layout_equation_block,
|
||||
@ -185,25 +185,27 @@ impl Show for Packed<EquationElem> {
|
||||
impl ShowSet for Packed<EquationElem> {
|
||||
fn show_set(&self, styles: StyleChain) -> Styles {
|
||||
let mut out = Styles::new();
|
||||
if self.block(styles) {
|
||||
out.set(AlignElem::set_alignment(Alignment::CENTER));
|
||||
out.set(BlockElem::set_breakable(false));
|
||||
out.set(ParLine::set_numbering(None));
|
||||
out.set(EquationElem::set_size(MathSize::Display));
|
||||
if self.block.get(styles) {
|
||||
out.set(AlignElem::alignment, Alignment::CENTER);
|
||||
out.set(AlignElem::alignment, Alignment::CENTER);
|
||||
out.set(BlockElem::breakable, false);
|
||||
out.set(ParLine::numbering, None);
|
||||
out.set(EquationElem::size, MathSize::Display);
|
||||
} else {
|
||||
out.set(EquationElem::set_size(MathSize::Text));
|
||||
out.set(EquationElem::size, MathSize::Text);
|
||||
}
|
||||
out.set(TextElem::set_weight(FontWeight::from_number(450)));
|
||||
out.set(TextElem::set_font(FontList(vec![FontFamily::new(
|
||||
"New Computer Modern Math",
|
||||
)])));
|
||||
out.set(TextElem::weight, FontWeight::from_number(450));
|
||||
out.set(
|
||||
TextElem::font,
|
||||
FontList(vec![FontFamily::new("New Computer Modern Math")]),
|
||||
);
|
||||
out
|
||||
}
|
||||
}
|
||||
|
||||
impl Count for Packed<EquationElem> {
|
||||
fn update(&self) -> Option<CounterUpdate> {
|
||||
(self.block(StyleChain::default()) && self.numbering().is_some())
|
||||
(self.block.get(StyleChain::default()) && self.numbering().is_some())
|
||||
.then(|| CounterUpdate::Step(NonZeroUsize::ONE))
|
||||
}
|
||||
}
|
||||
@ -215,24 +217,24 @@ impl LocalName for Packed<EquationElem> {
|
||||
impl Refable for Packed<EquationElem> {
|
||||
fn supplement(&self) -> Content {
|
||||
// After synthesis, this should always be custom content.
|
||||
match (**self).supplement(StyleChain::default()) {
|
||||
match self.supplement.get_cloned(StyleChain::default()) {
|
||||
Smart::Custom(Some(Supplement::Content(content))) => content,
|
||||
_ => Content::empty(),
|
||||
}
|
||||
}
|
||||
|
||||
fn counter(&self) -> Counter {
|
||||
Counter::of(EquationElem::elem())
|
||||
Counter::of(EquationElem::ELEM)
|
||||
}
|
||||
|
||||
fn numbering(&self) -> Option<&Numbering> {
|
||||
(**self).numbering(StyleChain::default()).as_ref()
|
||||
self.numbering.get_ref(StyleChain::default()).as_ref()
|
||||
}
|
||||
}
|
||||
|
||||
impl Outlinable for Packed<EquationElem> {
|
||||
fn outlined(&self) -> bool {
|
||||
self.block(StyleChain::default()) && self.numbering().is_some()
|
||||
self.block.get(StyleChain::default()) && self.numbering().is_some()
|
||||
}
|
||||
|
||||
fn prefix(&self, numbers: Content) -> Content {
|
||||
|
@ -9,7 +9,6 @@ use crate::math::Mathy;
|
||||
#[elem(title = "Left/Right", Mathy)]
|
||||
pub struct LrElem {
|
||||
/// The size of the brackets, relative to the height of the wrapped content.
|
||||
#[resolve]
|
||||
#[default(Rel::one())]
|
||||
pub size: Rel<Length>,
|
||||
|
||||
@ -130,7 +129,7 @@ fn delimited(
|
||||
]));
|
||||
// Push size only if size is provided
|
||||
if let Some(size) = size {
|
||||
elem.push_size(size);
|
||||
elem.size.set(size);
|
||||
}
|
||||
elem.pack().spanned(span)
|
||||
}
|
||||
|
@ -46,7 +46,6 @@ pub struct VecElem {
|
||||
/// #set math.vec(align: right)
|
||||
/// $ vec(-1, 1, -1) $
|
||||
/// ```
|
||||
#[resolve]
|
||||
#[default(HAlignment::Center)]
|
||||
pub align: HAlignment,
|
||||
|
||||
@ -56,7 +55,6 @@ pub struct VecElem {
|
||||
/// #set math.vec(gap: 1em)
|
||||
/// $ vec(1, 2) $
|
||||
/// ```
|
||||
#[resolve]
|
||||
#[default(DEFAULT_ROW_GAP.into())]
|
||||
pub gap: Rel<Length>,
|
||||
|
||||
@ -107,7 +105,6 @@ pub struct MatElem {
|
||||
/// #set math.mat(align: right)
|
||||
/// $ mat(-1, 1, 1; 1, -1, 1; 1, 1, -1) $
|
||||
/// ```
|
||||
#[resolve]
|
||||
#[default(HAlignment::Center)]
|
||||
pub align: HAlignment,
|
||||
|
||||
@ -141,7 +138,6 @@ pub struct MatElem {
|
||||
/// ```example
|
||||
/// $ mat(0, 0, 0; 1, 1, 1; augment: #(hline: 1, stroke: 2pt + green)) $
|
||||
/// ```
|
||||
#[resolve]
|
||||
#[fold]
|
||||
pub augment: Option<Augment>,
|
||||
|
||||
@ -162,7 +158,6 @@ pub struct MatElem {
|
||||
/// #set math.mat(row-gap: 1em)
|
||||
/// $ mat(1, 2; 3, 4) $
|
||||
/// ```
|
||||
#[resolve]
|
||||
#[parse(
|
||||
let gap = args.named("gap")?;
|
||||
args.named("row-gap")?.or(gap)
|
||||
@ -176,7 +171,6 @@ pub struct MatElem {
|
||||
/// #set math.mat(column-gap: 1em)
|
||||
/// $ mat(1, 2; 3, 4) $
|
||||
/// ```
|
||||
#[resolve]
|
||||
#[parse(args.named("column-gap")?.or(gap))]
|
||||
#[default(DEFAULT_COL_GAP.into())]
|
||||
pub column_gap: Rel<Length>,
|
||||
@ -259,7 +253,6 @@ pub struct CasesElem {
|
||||
/// #set math.cases(gap: 1em)
|
||||
/// $ x = cases(1, 2) $
|
||||
/// ```
|
||||
#[resolve]
|
||||
#[default(DEFAULT_ROW_GAP.into())]
|
||||
pub gap: Rel<Length>,
|
||||
|
||||
|
@ -11,7 +11,7 @@ pub fn bold(
|
||||
/// The content to style.
|
||||
body: Content,
|
||||
) -> Content {
|
||||
body.styled(EquationElem::set_bold(true))
|
||||
body.set(EquationElem::bold, true)
|
||||
}
|
||||
|
||||
/// Upright (non-italic) font style in math.
|
||||
@ -24,7 +24,7 @@ pub fn upright(
|
||||
/// The content to style.
|
||||
body: Content,
|
||||
) -> Content {
|
||||
body.styled(EquationElem::set_italic(Smart::Custom(false)))
|
||||
body.set(EquationElem::italic, Smart::Custom(false))
|
||||
}
|
||||
|
||||
/// Italic font style in math.
|
||||
@ -35,7 +35,7 @@ pub fn italic(
|
||||
/// The content to style.
|
||||
body: Content,
|
||||
) -> Content {
|
||||
body.styled(EquationElem::set_italic(Smart::Custom(true)))
|
||||
body.set(EquationElem::italic, Smart::Custom(true))
|
||||
}
|
||||
|
||||
/// Serif (roman) font style in math.
|
||||
@ -46,7 +46,7 @@ pub fn serif(
|
||||
/// The content to style.
|
||||
body: Content,
|
||||
) -> Content {
|
||||
body.styled(EquationElem::set_variant(MathVariant::Serif))
|
||||
body.set(EquationElem::variant, MathVariant::Serif)
|
||||
}
|
||||
|
||||
/// Sans-serif font style in math.
|
||||
@ -59,7 +59,7 @@ pub fn sans(
|
||||
/// The content to style.
|
||||
body: Content,
|
||||
) -> Content {
|
||||
body.styled(EquationElem::set_variant(MathVariant::Sans))
|
||||
body.set(EquationElem::variant, MathVariant::Sans)
|
||||
}
|
||||
|
||||
/// Calligraphic font style in math.
|
||||
@ -93,7 +93,7 @@ pub fn cal(
|
||||
/// The content to style.
|
||||
body: Content,
|
||||
) -> Content {
|
||||
body.styled(EquationElem::set_variant(MathVariant::Cal))
|
||||
body.set(EquationElem::variant, MathVariant::Cal)
|
||||
}
|
||||
|
||||
/// Fraktur font style in math.
|
||||
@ -106,7 +106,7 @@ pub fn frak(
|
||||
/// The content to style.
|
||||
body: Content,
|
||||
) -> Content {
|
||||
body.styled(EquationElem::set_variant(MathVariant::Frak))
|
||||
body.set(EquationElem::variant, MathVariant::Frak)
|
||||
}
|
||||
|
||||
/// Monospace font style in math.
|
||||
@ -119,7 +119,7 @@ pub fn mono(
|
||||
/// The content to style.
|
||||
body: Content,
|
||||
) -> Content {
|
||||
body.styled(EquationElem::set_variant(MathVariant::Mono))
|
||||
body.set(EquationElem::variant, MathVariant::Mono)
|
||||
}
|
||||
|
||||
/// Blackboard bold (double-struck) font style in math.
|
||||
@ -137,7 +137,7 @@ pub fn bb(
|
||||
/// The content to style.
|
||||
body: Content,
|
||||
) -> Content {
|
||||
body.styled(EquationElem::set_variant(MathVariant::Bb))
|
||||
body.set(EquationElem::variant, MathVariant::Bb)
|
||||
}
|
||||
|
||||
/// Forced display style in math.
|
||||
@ -157,8 +157,8 @@ pub fn display(
|
||||
#[default(false)]
|
||||
cramped: bool,
|
||||
) -> Content {
|
||||
body.styled(EquationElem::set_size(MathSize::Display))
|
||||
.styled(EquationElem::set_cramped(cramped))
|
||||
body.set(EquationElem::size, MathSize::Display)
|
||||
.set(EquationElem::cramped, cramped)
|
||||
}
|
||||
|
||||
/// Forced inline (text) style in math.
|
||||
@ -179,8 +179,8 @@ pub fn inline(
|
||||
#[default(false)]
|
||||
cramped: bool,
|
||||
) -> Content {
|
||||
body.styled(EquationElem::set_size(MathSize::Text))
|
||||
.styled(EquationElem::set_cramped(cramped))
|
||||
body.set(EquationElem::size, MathSize::Text)
|
||||
.set(EquationElem::cramped, cramped)
|
||||
}
|
||||
|
||||
/// Forced script style in math.
|
||||
@ -200,8 +200,8 @@ pub fn script(
|
||||
#[default(true)]
|
||||
cramped: bool,
|
||||
) -> Content {
|
||||
body.styled(EquationElem::set_size(MathSize::Script))
|
||||
.styled(EquationElem::set_cramped(cramped))
|
||||
body.set(EquationElem::size, MathSize::Script)
|
||||
.set(EquationElem::cramped, cramped)
|
||||
}
|
||||
|
||||
/// Forced second script style in math.
|
||||
@ -222,8 +222,8 @@ pub fn sscript(
|
||||
#[default(true)]
|
||||
cramped: bool,
|
||||
) -> Content {
|
||||
body.styled(EquationElem::set_size(MathSize::ScriptScript))
|
||||
.styled(EquationElem::set_cramped(cramped))
|
||||
body.set(EquationElem::size, MathSize::ScriptScript)
|
||||
.set(EquationElem::cramped, cramped)
|
||||
}
|
||||
|
||||
/// The size of elements in an equation.
|
||||
|
@ -158,7 +158,7 @@ pub struct BibliographyElem {
|
||||
impl BibliographyElem {
|
||||
/// Find the document's bibliography.
|
||||
pub fn find(introspector: Tracked<Introspector>) -> StrResult<Packed<Self>> {
|
||||
let query = introspector.query(&Self::elem().select());
|
||||
let query = introspector.query(&Self::ELEM.select());
|
||||
let mut iter = query.iter();
|
||||
let Some(elem) = iter.next() else {
|
||||
bail!("the document does not contain a bibliography");
|
||||
@ -175,7 +175,7 @@ impl BibliographyElem {
|
||||
pub fn has(engine: &Engine, key: Label) -> bool {
|
||||
engine
|
||||
.introspector
|
||||
.query(&Self::elem().select())
|
||||
.query(&Self::ELEM.select())
|
||||
.iter()
|
||||
.any(|elem| elem.to_packed::<Self>().unwrap().sources.derived.has(key))
|
||||
}
|
||||
@ -183,7 +183,7 @@ impl BibliographyElem {
|
||||
/// Find all bibliography keys.
|
||||
pub fn keys(introspector: Tracked<Introspector>) -> Vec<(Label, Option<EcoString>)> {
|
||||
let mut vec = vec![];
|
||||
for elem in introspector.query(&Self::elem().select()).iter() {
|
||||
for elem in introspector.query(&Self::ELEM.select()).iter() {
|
||||
let this = elem.to_packed::<Self>().unwrap();
|
||||
for (key, entry) in this.sources.derived.iter() {
|
||||
let detail = entry.title().map(|title| title.value.to_str().into());
|
||||
@ -197,8 +197,8 @@ impl BibliographyElem {
|
||||
impl Synthesize for Packed<BibliographyElem> {
|
||||
fn synthesize(&mut self, _: &mut Engine, styles: StyleChain) -> SourceResult<()> {
|
||||
let elem = self.as_mut();
|
||||
elem.push_lang(TextElem::lang_in(styles));
|
||||
elem.push_region(TextElem::region_in(styles));
|
||||
elem.lang = Some(styles.get(TextElem::lang));
|
||||
elem.region = Some(styles.get(TextElem::region));
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
@ -212,7 +212,7 @@ impl Show for Packed<BibliographyElem> {
|
||||
let span = self.span();
|
||||
|
||||
let mut seq = vec![];
|
||||
if let Some(title) = self.title(styles).unwrap_or_else(|| {
|
||||
if let Some(title) = self.title.get_ref(styles).clone().unwrap_or_else(|| {
|
||||
Some(TextElem::packed(Self::local_name_in(styles)).spanned(span))
|
||||
}) {
|
||||
seq.push(
|
||||
@ -227,7 +227,7 @@ impl Show for Packed<BibliographyElem> {
|
||||
let references = works
|
||||
.references
|
||||
.as_ref()
|
||||
.ok_or_else(|| match self.style(styles).source {
|
||||
.ok_or_else(|| match self.style.get_ref(styles).source {
|
||||
CslSource::Named(style) => eco_format!(
|
||||
"CSL style \"{}\" is not suitable for bibliographies",
|
||||
style.display_name()
|
||||
@ -239,7 +239,7 @@ impl Show for Packed<BibliographyElem> {
|
||||
.at(span)?;
|
||||
|
||||
if references.iter().any(|(prefix, _)| prefix.is_some()) {
|
||||
let row_gutter = ParElem::spacing_in(styles);
|
||||
let row_gutter = styles.get(ParElem::spacing);
|
||||
|
||||
let mut cells = vec![];
|
||||
for (prefix, reference) in references {
|
||||
@ -265,7 +265,7 @@ impl Show for Packed<BibliographyElem> {
|
||||
let block = if works.hanging_indent {
|
||||
let body = HElem::new((-INDENT).into()).pack() + realized;
|
||||
let inset = Sides::default()
|
||||
.with(TextElem::dir_in(styles).start(), Some(INDENT.into()));
|
||||
.with(styles.resolve(TextElem::dir).start(), Some(INDENT.into()));
|
||||
BlockElem::new()
|
||||
.with_body(Some(BlockBody::Content(body)))
|
||||
.with_inset(inset)
|
||||
@ -285,8 +285,8 @@ impl ShowSet for Packed<BibliographyElem> {
|
||||
fn show_set(&self, _: StyleChain) -> Styles {
|
||||
const INDENT: Em = Em::new(1.0);
|
||||
let mut out = Styles::new();
|
||||
out.set(HeadingElem::set_numbering(None));
|
||||
out.set(PadElem::set_left(INDENT.into()));
|
||||
out.set(HeadingElem::numbering, None);
|
||||
out.set(PadElem::left, INDENT.into());
|
||||
out
|
||||
}
|
||||
}
|
||||
@ -643,7 +643,7 @@ impl<'a> Generator<'a> {
|
||||
introspector: Tracked<Introspector>,
|
||||
) -> StrResult<Self> {
|
||||
let bibliography = BibliographyElem::find(introspector)?;
|
||||
let groups = introspector.query(&CiteGroup::elem().select());
|
||||
let groups = introspector.query(&CiteGroup::ELEM.select());
|
||||
let infos = Vec::with_capacity(groups.len());
|
||||
Ok(Self {
|
||||
routines,
|
||||
@ -661,7 +661,8 @@ impl<'a> Generator<'a> {
|
||||
LazyLock::new(hayagriva::archive::locales);
|
||||
|
||||
let database = &self.bibliography.sources.derived;
|
||||
let bibliography_style = &self.bibliography.style(StyleChain::default()).derived;
|
||||
let bibliography_style =
|
||||
&self.bibliography.style.get_ref(StyleChain::default()).derived;
|
||||
|
||||
// Process all citation groups.
|
||||
let mut driver = BibliographyDriver::new();
|
||||
@ -689,7 +690,7 @@ impl<'a> Generator<'a> {
|
||||
continue;
|
||||
};
|
||||
|
||||
let supplement = child.supplement(StyleChain::default());
|
||||
let supplement = child.supplement.get_cloned(StyleChain::default());
|
||||
let locator = supplement.as_ref().map(|_| {
|
||||
SpecificLocator(
|
||||
citationberg::taxonomy::Locator::Custom,
|
||||
@ -698,7 +699,7 @@ impl<'a> Generator<'a> {
|
||||
});
|
||||
|
||||
let mut hidden = false;
|
||||
let special_form = match child.form(StyleChain::default()) {
|
||||
let special_form = match child.form.get(StyleChain::default()) {
|
||||
None => {
|
||||
hidden = true;
|
||||
None
|
||||
@ -720,7 +721,7 @@ impl<'a> Generator<'a> {
|
||||
continue;
|
||||
}
|
||||
|
||||
let style = match first.style(StyleChain::default()) {
|
||||
let style = match first.style.get_ref(StyleChain::default()) {
|
||||
Smart::Auto => bibliography_style.get(),
|
||||
Smart::Custom(style) => style.derived.get(),
|
||||
};
|
||||
@ -736,23 +737,20 @@ impl<'a> Generator<'a> {
|
||||
driver.citation(CitationRequest::new(
|
||||
items,
|
||||
style,
|
||||
Some(locale(
|
||||
first.lang().copied().unwrap_or(Lang::ENGLISH),
|
||||
first.region().copied().flatten(),
|
||||
)),
|
||||
Some(locale(first.lang.unwrap_or(Lang::ENGLISH), first.region.flatten())),
|
||||
&LOCALES,
|
||||
None,
|
||||
));
|
||||
}
|
||||
|
||||
let locale = locale(
|
||||
self.bibliography.lang().copied().unwrap_or(Lang::ENGLISH),
|
||||
self.bibliography.region().copied().flatten(),
|
||||
self.bibliography.lang.unwrap_or(Lang::ENGLISH),
|
||||
self.bibliography.region.flatten(),
|
||||
);
|
||||
|
||||
// Add hidden items for everything if we should print the whole
|
||||
// bibliography.
|
||||
if self.bibliography.full(StyleChain::default()) {
|
||||
if self.bibliography.full.get(StyleChain::default()) {
|
||||
for (_, entry) in database.iter() {
|
||||
driver.citation(CitationRequest::new(
|
||||
vec![CitationItem::new(entry, None, None, true, None)],
|
||||
@ -1071,25 +1069,24 @@ fn apply_formatting(mut content: Content, format: &hayagriva::Formatting) -> Con
|
||||
match format.font_style {
|
||||
citationberg::FontStyle::Normal => {}
|
||||
citationberg::FontStyle::Italic => {
|
||||
content = content.styled(TextElem::set_style(FontStyle::Italic));
|
||||
content = content.set(TextElem::style, FontStyle::Italic);
|
||||
}
|
||||
}
|
||||
|
||||
match format.font_variant {
|
||||
citationberg::FontVariant::Normal => {}
|
||||
citationberg::FontVariant::SmallCaps => {
|
||||
content =
|
||||
content.styled(TextElem::set_smallcaps(Some(Smallcaps::Minuscules)));
|
||||
content = content.set(TextElem::smallcaps, Some(Smallcaps::Minuscules));
|
||||
}
|
||||
}
|
||||
|
||||
match format.font_weight {
|
||||
citationberg::FontWeight::Normal => {}
|
||||
citationberg::FontWeight::Bold => {
|
||||
content = content.styled(TextElem::set_delta(WeightDelta(300)));
|
||||
content = content.set(TextElem::delta, WeightDelta(300));
|
||||
}
|
||||
citationberg::FontWeight::Light => {
|
||||
content = content.styled(TextElem::set_delta(WeightDelta(-100)));
|
||||
content = content.set(TextElem::delta, WeightDelta(-100));
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -106,7 +106,6 @@ pub struct CiteElem {
|
||||
Some(Spanned { v: Smart::Auto, .. }) => Some(Smart::Auto),
|
||||
None => None,
|
||||
})]
|
||||
#[borrowed]
|
||||
pub style: Smart<Derived<CslSource, CslStyle>>,
|
||||
|
||||
/// The text language setting where the citation is.
|
||||
@ -123,8 +122,8 @@ pub struct CiteElem {
|
||||
impl Synthesize for Packed<CiteElem> {
|
||||
fn synthesize(&mut self, _: &mut Engine, styles: StyleChain) -> SourceResult<()> {
|
||||
let elem = self.as_mut();
|
||||
elem.push_lang(TextElem::lang_in(styles));
|
||||
elem.push_region(TextElem::region_in(styles));
|
||||
elem.lang = Some(styles.get(TextElem::lang));
|
||||
elem.region = Some(styles.get(TextElem::region));
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
@ -3,7 +3,7 @@ use ecow::EcoString;
|
||||
use crate::diag::{bail, HintedStrResult, SourceResult};
|
||||
use crate::engine::Engine;
|
||||
use crate::foundations::{
|
||||
cast, elem, Args, Array, Construct, Content, Datetime, Fields, OneOrMultiple, Smart,
|
||||
cast, elem, Args, Array, Construct, Content, Datetime, OneOrMultiple, Smart,
|
||||
StyleChain, Styles, Value,
|
||||
};
|
||||
|
||||
@ -109,23 +109,26 @@ impl DocumentInfo {
|
||||
/// Document set rules are a bit special, so we need to do this manually.
|
||||
pub fn populate(&mut self, styles: &Styles) {
|
||||
let chain = StyleChain::new(styles);
|
||||
let has = |field| styles.has::<DocumentElem>(field as _);
|
||||
if has(<DocumentElem as Fields>::Enum::Title) {
|
||||
self.title =
|
||||
DocumentElem::title_in(chain).map(|content| content.plain_text());
|
||||
if styles.has(DocumentElem::title) {
|
||||
self.title = chain
|
||||
.get_ref(DocumentElem::title)
|
||||
.as_ref()
|
||||
.map(|content| content.plain_text());
|
||||
}
|
||||
if has(<DocumentElem as Fields>::Enum::Author) {
|
||||
self.author = DocumentElem::author_in(chain).0;
|
||||
if styles.has(DocumentElem::author) {
|
||||
self.author = chain.get_cloned(DocumentElem::author).0;
|
||||
}
|
||||
if has(<DocumentElem as Fields>::Enum::Description) {
|
||||
self.description =
|
||||
DocumentElem::description_in(chain).map(|content| content.plain_text());
|
||||
if styles.has(DocumentElem::description) {
|
||||
self.description = chain
|
||||
.get_ref(DocumentElem::description)
|
||||
.as_ref()
|
||||
.map(|content| content.plain_text());
|
||||
}
|
||||
if has(<DocumentElem as Fields>::Enum::Keywords) {
|
||||
self.keywords = DocumentElem::keywords_in(chain).0;
|
||||
if styles.has(DocumentElem::keywords) {
|
||||
self.keywords = chain.get_cloned(DocumentElem::keywords).0;
|
||||
}
|
||||
if has(<DocumentElem as Fields>::Enum::Date) {
|
||||
self.date = DocumentElem::date_in(chain);
|
||||
if styles.has(DocumentElem::date) {
|
||||
self.date = chain.get(DocumentElem::date);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -40,13 +40,13 @@ impl Show for Packed<EmphElem> {
|
||||
#[typst_macros::time(name = "emph", span = self.span())]
|
||||
fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
|
||||
let body = self.body.clone();
|
||||
Ok(if TargetElem::target_in(styles).is_html() {
|
||||
Ok(if styles.get(TargetElem::target).is_html() {
|
||||
HtmlElem::new(tag::em)
|
||||
.with_body(Some(body))
|
||||
.pack()
|
||||
.spanned(self.span())
|
||||
} else {
|
||||
body.styled(TextElem::set_emph(ItalicToggle(true)))
|
||||
body.set(TextElem::emph, ItalicToggle(true))
|
||||
})
|
||||
}
|
||||
}
|
||||
|
@ -117,7 +117,6 @@ pub struct EnumElem {
|
||||
/// + Numbering!
|
||||
/// ```
|
||||
#[default(Numbering::Pattern(NumberingPattern::from_str("1.").unwrap()))]
|
||||
#[borrowed]
|
||||
pub numbering: Numbering,
|
||||
|
||||
/// Which number to start the enumeration with.
|
||||
@ -157,11 +156,9 @@ pub struct EnumElem {
|
||||
pub reversed: bool,
|
||||
|
||||
/// The indentation of each item.
|
||||
#[resolve]
|
||||
pub indent: Length,
|
||||
|
||||
/// The space between the numbering and the body of each item.
|
||||
#[resolve]
|
||||
#[default(Em::new(0.5).into())]
|
||||
pub body_indent: Length,
|
||||
|
||||
@ -228,19 +225,19 @@ impl EnumElem {
|
||||
|
||||
impl Show for Packed<EnumElem> {
|
||||
fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
|
||||
let tight = self.tight(styles);
|
||||
let tight = self.tight.get(styles);
|
||||
|
||||
if TargetElem::target_in(styles).is_html() {
|
||||
if styles.get(TargetElem::target).is_html() {
|
||||
let mut elem = HtmlElem::new(tag::ol);
|
||||
if self.reversed(styles) {
|
||||
if self.reversed.get(styles) {
|
||||
elem = elem.with_attr(attr::reversed, "reversed");
|
||||
}
|
||||
if let Some(n) = self.start(styles).custom() {
|
||||
if let Some(n) = self.start.get(styles).custom() {
|
||||
elem = elem.with_attr(attr::start, eco_format!("{n}"));
|
||||
}
|
||||
let body = Content::sequence(self.children.iter().map(|item| {
|
||||
let mut li = HtmlElem::new(tag::li);
|
||||
if let Some(nr) = item.number(styles) {
|
||||
if let Some(nr) = item.number.get(styles) {
|
||||
li = li.with_attr(attr::value, eco_format!("{nr}"));
|
||||
}
|
||||
// Text in wide enums shall always turn into paragraphs.
|
||||
@ -260,8 +257,9 @@ impl Show for Packed<EnumElem> {
|
||||
|
||||
if tight {
|
||||
let spacing = self
|
||||
.spacing(styles)
|
||||
.unwrap_or_else(|| ParElem::leading_in(styles).into());
|
||||
.spacing
|
||||
.get(styles)
|
||||
.unwrap_or_else(|| styles.get(ParElem::leading));
|
||||
let v = VElem::new(spacing.into()).with_weak(true).with_attach(true).pack();
|
||||
realized = v + realized;
|
||||
}
|
||||
|
@ -161,7 +161,6 @@ pub struct FigureElem {
|
||||
pub scope: PlacementScope,
|
||||
|
||||
/// The figure's caption.
|
||||
#[borrowed]
|
||||
pub caption: Option<Packed<FigureCaption>>,
|
||||
|
||||
/// The kind of figure this is.
|
||||
@ -214,13 +213,11 @@ pub struct FigureElem {
|
||||
/// kind: "foo",
|
||||
/// )
|
||||
/// ```
|
||||
#[borrowed]
|
||||
pub supplement: Smart<Option<Supplement>>,
|
||||
|
||||
/// How to number the figure. Accepts a
|
||||
/// [numbering pattern or function]($numbering).
|
||||
#[default(Some(NumberingPattern::from_str("1").unwrap().into()))]
|
||||
#[borrowed]
|
||||
pub numbering: Option<Numbering>,
|
||||
|
||||
/// The vertical gap between the body and caption.
|
||||
@ -259,25 +256,25 @@ impl Synthesize for Packed<FigureElem> {
|
||||
let span = self.span();
|
||||
let location = self.location();
|
||||
let elem = self.as_mut();
|
||||
let numbering = elem.numbering(styles);
|
||||
let numbering = elem.numbering.get_ref(styles);
|
||||
|
||||
// Determine the figure's kind.
|
||||
let kind = elem.kind(styles).unwrap_or_else(|| {
|
||||
let kind = elem.kind.get_cloned(styles).unwrap_or_else(|| {
|
||||
elem.body
|
||||
.query_first(&Selector::can::<dyn Figurable>())
|
||||
.map(|elem| FigureKind::Elem(elem.func()))
|
||||
.unwrap_or_else(|| FigureKind::Elem(ImageElem::elem()))
|
||||
.unwrap_or_else(|| FigureKind::Elem(ImageElem::ELEM))
|
||||
});
|
||||
|
||||
// Resolve the supplement.
|
||||
let supplement = match elem.supplement(styles).as_ref() {
|
||||
let supplement = match elem.supplement.get_ref(styles).as_ref() {
|
||||
Smart::Auto => {
|
||||
// Default to the local name for the kind, if available.
|
||||
let name = match &kind {
|
||||
FigureKind::Elem(func) => func
|
||||
.local_name(
|
||||
TextElem::lang_in(styles),
|
||||
TextElem::region_in(styles),
|
||||
styles.get(TextElem::lang),
|
||||
styles.get(TextElem::region),
|
||||
)
|
||||
.map(TextElem::packed),
|
||||
FigureKind::Name(_) => None,
|
||||
@ -307,24 +304,25 @@ impl Synthesize for Packed<FigureElem> {
|
||||
|
||||
// Construct the figure's counter.
|
||||
let counter = Counter::new(CounterKey::Selector(
|
||||
select_where!(FigureElem, Kind => kind.clone()),
|
||||
select_where!(FigureElem, kind => kind.clone()),
|
||||
));
|
||||
|
||||
// Fill the figure's caption.
|
||||
let mut caption = elem.caption(styles).clone();
|
||||
let mut caption = elem.caption.get_cloned(styles);
|
||||
if let Some(caption) = &mut caption {
|
||||
caption.synthesize(engine, styles)?;
|
||||
caption.push_kind(kind.clone());
|
||||
caption.push_supplement(supplement.clone());
|
||||
caption.push_numbering(numbering.clone());
|
||||
caption.push_counter(Some(counter.clone()));
|
||||
caption.push_figure_location(location);
|
||||
caption.kind = Some(kind.clone());
|
||||
caption.supplement = Some(supplement.clone());
|
||||
caption.numbering = Some(numbering.clone());
|
||||
caption.counter = Some(Some(counter.clone()));
|
||||
caption.figure_location = Some(location);
|
||||
}
|
||||
|
||||
elem.push_kind(Smart::Custom(kind));
|
||||
elem.push_supplement(Smart::Custom(supplement.map(Supplement::Content)));
|
||||
elem.push_counter(Some(counter));
|
||||
elem.push_caption(caption);
|
||||
elem.kind.set(Smart::Custom(kind));
|
||||
elem.supplement
|
||||
.set(Smart::Custom(supplement.map(Supplement::Content)));
|
||||
elem.counter = Some(Some(counter));
|
||||
elem.caption.set(caption);
|
||||
|
||||
Ok(())
|
||||
}
|
||||
@ -334,19 +332,19 @@ impl Show for Packed<FigureElem> {
|
||||
#[typst_macros::time(name = "figure", span = self.span())]
|
||||
fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
|
||||
let span = self.span();
|
||||
let target = TargetElem::target_in(styles);
|
||||
let target = styles.get(TargetElem::target);
|
||||
let mut realized = self.body.clone();
|
||||
|
||||
// Build the caption, if any.
|
||||
if let Some(caption) = self.caption(styles).clone() {
|
||||
let (first, second) = match caption.position(styles) {
|
||||
if let Some(caption) = self.caption.get_cloned(styles) {
|
||||
let (first, second) = match caption.position.get(styles) {
|
||||
OuterVAlignment::Top => (caption.pack(), realized),
|
||||
OuterVAlignment::Bottom => (realized, caption.pack()),
|
||||
};
|
||||
let mut seq = Vec::with_capacity(3);
|
||||
seq.push(first);
|
||||
if !target.is_html() {
|
||||
let v = VElem::new(self.gap(styles).into()).with_weak(true);
|
||||
let v = VElem::new(self.gap.get(styles).into()).with_weak(true);
|
||||
seq.push(v.pack().spanned(span))
|
||||
}
|
||||
seq.push(second);
|
||||
@ -370,14 +368,14 @@ impl Show for Packed<FigureElem> {
|
||||
.spanned(span);
|
||||
|
||||
// Wrap in a float.
|
||||
if let Some(align) = self.placement(styles) {
|
||||
if let Some(align) = self.placement.get(styles) {
|
||||
realized = PlaceElem::new(realized)
|
||||
.with_alignment(align.map(|align| HAlignment::Center + align))
|
||||
.with_scope(self.scope(styles))
|
||||
.with_scope(self.scope.get(styles))
|
||||
.with_float(true)
|
||||
.pack()
|
||||
.spanned(span);
|
||||
} else if self.scope(styles) == PlacementScope::Parent {
|
||||
} else if self.scope.get(styles) == PlacementScope::Parent {
|
||||
bail!(
|
||||
span,
|
||||
"parent-scoped placement is only available for floating figures";
|
||||
@ -394,8 +392,8 @@ impl ShowSet for Packed<FigureElem> {
|
||||
// Still allows breakable figures with
|
||||
// `show figure: set block(breakable: true)`.
|
||||
let mut map = Styles::new();
|
||||
map.set(BlockElem::set_breakable(false));
|
||||
map.set(AlignElem::set_alignment(Alignment::CENTER));
|
||||
map.set(BlockElem::breakable, false);
|
||||
map.set(AlignElem::alignment, Alignment::CENTER);
|
||||
map
|
||||
}
|
||||
}
|
||||
@ -413,29 +411,28 @@ impl Count for Packed<FigureElem> {
|
||||
impl Refable for Packed<FigureElem> {
|
||||
fn supplement(&self) -> Content {
|
||||
// After synthesis, this should always be custom content.
|
||||
match (**self).supplement(StyleChain::default()).as_ref() {
|
||||
Smart::Custom(Some(Supplement::Content(content))) => content.clone(),
|
||||
match self.supplement.get_cloned(StyleChain::default()) {
|
||||
Smart::Custom(Some(Supplement::Content(content))) => content,
|
||||
_ => Content::empty(),
|
||||
}
|
||||
}
|
||||
|
||||
fn counter(&self) -> Counter {
|
||||
(**self)
|
||||
.counter()
|
||||
.cloned()
|
||||
self.counter
|
||||
.clone()
|
||||
.flatten()
|
||||
.unwrap_or_else(|| Counter::of(FigureElem::elem()))
|
||||
.unwrap_or_else(|| Counter::of(FigureElem::ELEM))
|
||||
}
|
||||
|
||||
fn numbering(&self) -> Option<&Numbering> {
|
||||
(**self).numbering(StyleChain::default()).as_ref()
|
||||
self.numbering.get_ref(StyleChain::default()).as_ref()
|
||||
}
|
||||
}
|
||||
|
||||
impl Outlinable for Packed<FigureElem> {
|
||||
fn outlined(&self) -> bool {
|
||||
(**self).outlined(StyleChain::default())
|
||||
&& (self.caption(StyleChain::default()).is_some()
|
||||
self.outlined.get(StyleChain::default())
|
||||
&& (self.caption.get_ref(StyleChain::default()).is_some()
|
||||
|| self.numbering().is_some())
|
||||
}
|
||||
|
||||
@ -449,7 +446,8 @@ impl Outlinable for Packed<FigureElem> {
|
||||
}
|
||||
|
||||
fn body(&self) -> Content {
|
||||
self.caption(StyleChain::default())
|
||||
self.caption
|
||||
.get_ref(StyleChain::default())
|
||||
.as_ref()
|
||||
.map(|caption| caption.body.clone())
|
||||
.unwrap_or_default()
|
||||
@ -573,10 +571,10 @@ impl FigureCaption {
|
||||
}
|
||||
|
||||
fn get_separator(&self, styles: StyleChain) -> Content {
|
||||
self.separator(styles).unwrap_or_else(|| {
|
||||
self.separator.get_cloned(styles).unwrap_or_else(|| {
|
||||
TextElem::packed(Self::local_separator(
|
||||
TextElem::lang_in(styles),
|
||||
TextElem::region_in(styles),
|
||||
styles.get(TextElem::lang),
|
||||
styles.get(TextElem::region),
|
||||
))
|
||||
})
|
||||
}
|
||||
@ -585,7 +583,7 @@ impl FigureCaption {
|
||||
impl Synthesize for Packed<FigureCaption> {
|
||||
fn synthesize(&mut self, _: &mut Engine, styles: StyleChain) -> SourceResult<()> {
|
||||
let elem = self.as_mut();
|
||||
elem.push_separator(Smart::Custom(elem.get_separator(styles)));
|
||||
elem.separator.set(Smart::Custom(elem.get_separator(styles)));
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
@ -601,10 +599,10 @@ impl Show for Packed<FigureCaption> {
|
||||
Some(Some(counter)),
|
||||
Some(Some(location)),
|
||||
) = (
|
||||
self.supplement().cloned(),
|
||||
self.numbering(),
|
||||
self.counter(),
|
||||
self.figure_location(),
|
||||
self.supplement.clone(),
|
||||
&self.numbering,
|
||||
&self.counter,
|
||||
&self.figure_location,
|
||||
) {
|
||||
let numbers = counter.display_at_loc(engine, *location, styles, numbering)?;
|
||||
if !supplement.is_empty() {
|
||||
@ -613,7 +611,7 @@ impl Show for Packed<FigureCaption> {
|
||||
realized = supplement + numbers + self.get_separator(styles) + realized;
|
||||
}
|
||||
|
||||
Ok(if TargetElem::target_in(styles).is_html() {
|
||||
Ok(if styles.get(TargetElem::target).is_html() {
|
||||
HtmlElem::new(tag::figcaption)
|
||||
.with_body(Some(realized))
|
||||
.pack()
|
||||
|
@ -67,7 +67,6 @@ pub struct FootnoteElem {
|
||||
/// #footnote[Star],
|
||||
/// #footnote[Dagger]
|
||||
/// ```
|
||||
#[borrowed]
|
||||
#[default(Numbering::Pattern(NumberingPattern::from_str("1").unwrap()))]
|
||||
pub numbering: Numbering,
|
||||
|
||||
@ -141,8 +140,8 @@ impl Show for Packed<FootnoteElem> {
|
||||
fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
|
||||
let span = self.span();
|
||||
let loc = self.declaration_location(engine).at(span)?;
|
||||
let numbering = self.numbering(styles);
|
||||
let counter = Counter::of(FootnoteElem::elem());
|
||||
let numbering = self.numbering.get_ref(styles);
|
||||
let counter = Counter::of(FootnoteElem::ELEM);
|
||||
let num = counter.display_at_loc(engine, loc, styles, numbering)?;
|
||||
let sup = SuperElem::new(num).pack().spanned(span);
|
||||
let loc = loc.variant(1);
|
||||
@ -248,7 +247,6 @@ pub struct FootnoteEntry {
|
||||
/// ]
|
||||
/// ```
|
||||
#[default(Em::new(1.0).into())]
|
||||
#[resolve]
|
||||
pub clearance: Length,
|
||||
|
||||
/// The gap between footnote entries.
|
||||
@ -261,7 +259,6 @@ pub struct FootnoteEntry {
|
||||
/// #footnote[Apart]
|
||||
/// ```
|
||||
#[default(Em::new(0.5).into())]
|
||||
#[resolve]
|
||||
pub gap: Length,
|
||||
|
||||
/// The indent of each footnote entry.
|
||||
@ -283,8 +280,8 @@ impl Show for Packed<FootnoteEntry> {
|
||||
let span = self.span();
|
||||
let number_gap = Em::new(0.05);
|
||||
let default = StyleChain::default();
|
||||
let numbering = self.note.numbering(default);
|
||||
let counter = Counter::of(FootnoteElem::elem());
|
||||
let numbering = self.note.numbering.get_ref(default);
|
||||
let counter = Counter::of(FootnoteElem::ELEM);
|
||||
let Some(loc) = self.note.location() else {
|
||||
bail!(
|
||||
span, "footnote entry must have a location";
|
||||
@ -300,7 +297,7 @@ impl Show for Packed<FootnoteEntry> {
|
||||
.located(loc.variant(1));
|
||||
|
||||
Ok(Content::sequence([
|
||||
HElem::new(self.indent(styles).into()).pack(),
|
||||
HElem::new(self.indent.get(styles).into()).pack(),
|
||||
sup,
|
||||
HElem::new(number_gap.into()).with_weak(true).pack(),
|
||||
self.note.body_content().unwrap().clone(),
|
||||
@ -311,8 +308,8 @@ impl Show for Packed<FootnoteEntry> {
|
||||
impl ShowSet for Packed<FootnoteEntry> {
|
||||
fn show_set(&self, _: StyleChain) -> Styles {
|
||||
let mut out = Styles::new();
|
||||
out.set(ParElem::set_leading(Em::new(0.5).into()));
|
||||
out.set(TextElem::set_size(TextSize(Em::new(0.85).into())));
|
||||
out.set(ParElem::leading, Em::new(0.5).into());
|
||||
out.set(TextElem::size, TextSize(Em::new(0.85).into()));
|
||||
out
|
||||
}
|
||||
}
|
||||
|
@ -106,7 +106,6 @@ pub struct HeadingElem {
|
||||
/// == A subsection
|
||||
/// === A sub-subsection
|
||||
/// ```
|
||||
#[borrowed]
|
||||
pub numbering: Option<Numbering>,
|
||||
|
||||
/// A supplement for the heading.
|
||||
@ -187,8 +186,8 @@ pub struct HeadingElem {
|
||||
|
||||
impl HeadingElem {
|
||||
pub fn resolve_level(&self, styles: StyleChain) -> NonZeroUsize {
|
||||
self.level(styles).unwrap_or_else(|| {
|
||||
NonZeroUsize::new(self.offset(styles) + self.depth(styles).get())
|
||||
self.level.get(styles).unwrap_or_else(|| {
|
||||
NonZeroUsize::new(self.offset.get(styles) + self.depth.get(styles).get())
|
||||
.expect("overflow to 0 on NoneZeroUsize + usize")
|
||||
})
|
||||
}
|
||||
@ -200,7 +199,7 @@ impl Synthesize for Packed<HeadingElem> {
|
||||
engine: &mut Engine,
|
||||
styles: StyleChain,
|
||||
) -> SourceResult<()> {
|
||||
let supplement = match (**self).supplement(styles) {
|
||||
let supplement = match self.supplement.get_ref(styles) {
|
||||
Smart::Auto => TextElem::packed(Self::local_name_in(styles)),
|
||||
Smart::Custom(None) => Content::empty(),
|
||||
Smart::Custom(Some(supplement)) => {
|
||||
@ -209,8 +208,9 @@ impl Synthesize for Packed<HeadingElem> {
|
||||
};
|
||||
|
||||
let elem = self.as_mut();
|
||||
elem.push_level(Smart::Custom(elem.resolve_level(styles)));
|
||||
elem.push_supplement(Smart::Custom(Some(Supplement::Content(supplement))));
|
||||
elem.level.set(Smart::Custom(elem.resolve_level(styles)));
|
||||
elem.supplement
|
||||
.set(Smart::Custom(Some(Supplement::Content(supplement))));
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
@ -218,22 +218,22 @@ impl Synthesize for Packed<HeadingElem> {
|
||||
impl Show for Packed<HeadingElem> {
|
||||
#[typst_macros::time(name = "heading", span = self.span())]
|
||||
fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
|
||||
let html = TargetElem::target_in(styles).is_html();
|
||||
let html = styles.get(TargetElem::target).is_html();
|
||||
|
||||
const SPACING_TO_NUMBERING: Em = Em::new(0.3);
|
||||
|
||||
let span = self.span();
|
||||
let mut realized = self.body.clone();
|
||||
|
||||
let hanging_indent = self.hanging_indent(styles);
|
||||
let hanging_indent = self.hanging_indent.get(styles);
|
||||
let mut indent = match hanging_indent {
|
||||
Smart::Custom(length) => length.resolve(styles),
|
||||
Smart::Auto => Abs::zero(),
|
||||
};
|
||||
|
||||
if let Some(numbering) = (**self).numbering(styles).as_ref() {
|
||||
if let Some(numbering) = self.numbering.get_ref(styles).as_ref() {
|
||||
let location = self.location().unwrap();
|
||||
let numbering = Counter::of(HeadingElem::elem())
|
||||
let numbering = Counter::of(HeadingElem::ELEM)
|
||||
.display_at_loc(engine, location, styles, numbering)?
|
||||
.spanned(span);
|
||||
|
||||
@ -293,7 +293,7 @@ impl Show for Packed<HeadingElem> {
|
||||
let block = if indent != Abs::zero() {
|
||||
let body = HElem::new((-indent).into()).pack() + realized;
|
||||
let inset = Sides::default()
|
||||
.with(TextElem::dir_in(styles).start(), Some(indent.into()));
|
||||
.with(styles.resolve(TextElem::dir).start(), Some(indent.into()));
|
||||
BlockElem::new()
|
||||
.with_body(Some(BlockBody::Content(body)))
|
||||
.with_inset(inset)
|
||||
@ -307,7 +307,7 @@ impl Show for Packed<HeadingElem> {
|
||||
|
||||
impl ShowSet for Packed<HeadingElem> {
|
||||
fn show_set(&self, styles: StyleChain) -> Styles {
|
||||
let level = (**self).resolve_level(styles).get();
|
||||
let level = self.resolve_level(styles).get();
|
||||
let scale = match level {
|
||||
1 => 1.4,
|
||||
2 => 1.2,
|
||||
@ -319,49 +319,49 @@ impl ShowSet for Packed<HeadingElem> {
|
||||
let below = Em::new(0.75) / scale;
|
||||
|
||||
let mut out = Styles::new();
|
||||
out.set(TextElem::set_size(TextSize(size.into())));
|
||||
out.set(TextElem::set_weight(FontWeight::BOLD));
|
||||
out.set(BlockElem::set_above(Smart::Custom(above.into())));
|
||||
out.set(BlockElem::set_below(Smart::Custom(below.into())));
|
||||
out.set(BlockElem::set_sticky(true));
|
||||
out.set(TextElem::size, TextSize(size.into()));
|
||||
out.set(TextElem::weight, FontWeight::BOLD);
|
||||
out.set(BlockElem::above, Smart::Custom(above.into()));
|
||||
out.set(BlockElem::below, Smart::Custom(below.into()));
|
||||
out.set(BlockElem::sticky, true);
|
||||
out
|
||||
}
|
||||
}
|
||||
|
||||
impl Count for Packed<HeadingElem> {
|
||||
fn update(&self) -> Option<CounterUpdate> {
|
||||
(**self)
|
||||
.numbering(StyleChain::default())
|
||||
self.numbering
|
||||
.get_ref(StyleChain::default())
|
||||
.is_some()
|
||||
.then(|| CounterUpdate::Step((**self).resolve_level(StyleChain::default())))
|
||||
.then(|| CounterUpdate::Step(self.resolve_level(StyleChain::default())))
|
||||
}
|
||||
}
|
||||
|
||||
impl Refable for Packed<HeadingElem> {
|
||||
fn supplement(&self) -> Content {
|
||||
// After synthesis, this should always be custom content.
|
||||
match (**self).supplement(StyleChain::default()) {
|
||||
match self.supplement.get_cloned(StyleChain::default()) {
|
||||
Smart::Custom(Some(Supplement::Content(content))) => content,
|
||||
_ => Content::empty(),
|
||||
}
|
||||
}
|
||||
|
||||
fn counter(&self) -> Counter {
|
||||
Counter::of(HeadingElem::elem())
|
||||
Counter::of(HeadingElem::ELEM)
|
||||
}
|
||||
|
||||
fn numbering(&self) -> Option<&Numbering> {
|
||||
(**self).numbering(StyleChain::default()).as_ref()
|
||||
self.numbering.get_ref(StyleChain::default()).as_ref()
|
||||
}
|
||||
}
|
||||
|
||||
impl Outlinable for Packed<HeadingElem> {
|
||||
fn outlined(&self) -> bool {
|
||||
(**self).outlined(StyleChain::default())
|
||||
self.outlined.get(StyleChain::default())
|
||||
}
|
||||
|
||||
fn level(&self) -> NonZeroUsize {
|
||||
(**self).resolve_level(StyleChain::default())
|
||||
self.resolve_level(StyleChain::default())
|
||||
}
|
||||
|
||||
fn prefix(&self, numbers: Content) -> Content {
|
||||
|
@ -108,7 +108,7 @@ impl Show for Packed<LinkElem> {
|
||||
fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
|
||||
let body = self.body.clone();
|
||||
|
||||
Ok(if TargetElem::target_in(styles).is_html() {
|
||||
Ok(if styles.get(TargetElem::target).is_html() {
|
||||
if let LinkTarget::Dest(Destination::Url(url)) = &self.dest {
|
||||
HtmlElem::new(tag::a)
|
||||
.with_attr(attr::href, url.clone().into_inner())
|
||||
@ -138,7 +138,7 @@ impl Show for Packed<LinkElem> {
|
||||
impl ShowSet for Packed<LinkElem> {
|
||||
fn show_set(&self, _: StyleChain) -> Styles {
|
||||
let mut out = Styles::new();
|
||||
out.set(TextElem::set_hyphenate(Smart::Custom(false)));
|
||||
out.set(TextElem::hyphenate, Smart::Custom(false));
|
||||
out
|
||||
}
|
||||
}
|
||||
|
@ -86,7 +86,6 @@ pub struct ListElem {
|
||||
/// - Items
|
||||
/// - Items
|
||||
/// ```
|
||||
#[borrowed]
|
||||
#[default(ListMarker::Content(vec![
|
||||
// These are all available in the default font, vertically centered, and
|
||||
// roughly of the same size (with the last one having slightly lower
|
||||
@ -98,11 +97,9 @@ pub struct ListElem {
|
||||
pub marker: ListMarker,
|
||||
|
||||
/// The indent of each item.
|
||||
#[resolve]
|
||||
pub indent: Length,
|
||||
|
||||
/// The spacing between the marker and the body of each item.
|
||||
#[resolve]
|
||||
#[default(Em::new(0.5).into())]
|
||||
pub body_indent: Length,
|
||||
|
||||
@ -141,9 +138,9 @@ impl ListElem {
|
||||
|
||||
impl Show for Packed<ListElem> {
|
||||
fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
|
||||
let tight = self.tight(styles);
|
||||
let tight = self.tight.get(styles);
|
||||
|
||||
if TargetElem::target_in(styles).is_html() {
|
||||
if styles.get(TargetElem::target).is_html() {
|
||||
return Ok(HtmlElem::new(tag::ul)
|
||||
.with_body(Some(Content::sequence(self.children.iter().map(|item| {
|
||||
// Text in wide lists shall always turn into paragraphs.
|
||||
@ -167,8 +164,9 @@ impl Show for Packed<ListElem> {
|
||||
|
||||
if tight {
|
||||
let spacing = self
|
||||
.spacing(styles)
|
||||
.unwrap_or_else(|| ParElem::leading_in(styles).into());
|
||||
.spacing
|
||||
.get(styles)
|
||||
.unwrap_or_else(|| styles.get(ParElem::leading));
|
||||
let v = VElem::new(spacing.into()).with_weak(true).with_attach(true).pack();
|
||||
realized = v + realized;
|
||||
}
|
||||
|
@ -183,8 +183,7 @@ pub struct OutlineElem {
|
||||
/// caption: [Experiment results],
|
||||
/// )
|
||||
/// ```
|
||||
#[default(LocatableSelector(HeadingElem::elem().select()))]
|
||||
#[borrowed]
|
||||
#[default(LocatableSelector(HeadingElem::ELEM.select()))]
|
||||
pub target: LocatableSelector,
|
||||
|
||||
/// The maximum level up to which elements are included in the outline. When
|
||||
@ -257,7 +256,7 @@ impl Show for Packed<OutlineElem> {
|
||||
|
||||
// Build the outline title.
|
||||
let mut seq = vec![];
|
||||
if let Some(title) = self.title(styles).unwrap_or_else(|| {
|
||||
if let Some(title) = self.title.get_cloned(styles).unwrap_or_else(|| {
|
||||
Some(TextElem::packed(Self::local_name_in(styles)).spanned(span))
|
||||
}) {
|
||||
seq.push(
|
||||
@ -268,8 +267,8 @@ impl Show for Packed<OutlineElem> {
|
||||
);
|
||||
}
|
||||
|
||||
let elems = engine.introspector.query(&self.target(styles).0);
|
||||
let depth = self.depth(styles).unwrap_or(NonZeroUsize::MAX);
|
||||
let elems = engine.introspector.query(&self.target.get_ref(styles).0);
|
||||
let depth = self.depth.get(styles).unwrap_or(NonZeroUsize::MAX);
|
||||
|
||||
// Build the outline entries.
|
||||
for elem in elems {
|
||||
@ -291,13 +290,13 @@ impl Show for Packed<OutlineElem> {
|
||||
impl ShowSet for Packed<OutlineElem> {
|
||||
fn show_set(&self, styles: StyleChain) -> Styles {
|
||||
let mut out = Styles::new();
|
||||
out.set(HeadingElem::set_outlined(false));
|
||||
out.set(HeadingElem::set_numbering(None));
|
||||
out.set(ParElem::set_justify(false));
|
||||
out.set(BlockElem::set_above(Smart::Custom(ParElem::leading_in(styles).into())));
|
||||
out.set(HeadingElem::outlined, false);
|
||||
out.set(HeadingElem::numbering, None);
|
||||
out.set(ParElem::justify, false);
|
||||
out.set(BlockElem::above, Smart::Custom(styles.get(ParElem::leading).into()));
|
||||
// Makes the outline itself available to its entries. Should be
|
||||
// superseded by a proper ancestry mechanism in the future.
|
||||
out.set(OutlineEntry::set_parent(Some(self.clone())));
|
||||
out.set(OutlineEntry::parent, Some(self.clone()));
|
||||
out
|
||||
}
|
||||
}
|
||||
@ -395,7 +394,6 @@ pub struct OutlineEntry {
|
||||
///
|
||||
/// = A New Beginning
|
||||
/// ```
|
||||
#[borrowed]
|
||||
#[default(Some(
|
||||
RepeatElem::new(TextElem::packed("."))
|
||||
.with_gap(Em::new(0.15).into())
|
||||
@ -472,7 +470,9 @@ impl OutlineEntry {
|
||||
gap: Length,
|
||||
) -> SourceResult<Content> {
|
||||
let styles = context.styles().at(span)?;
|
||||
let outline = Self::parent_in(styles)
|
||||
let outline = styles
|
||||
.get_ref(Self::parent)
|
||||
.as_ref()
|
||||
.ok_or("must be called within the context of an outline")
|
||||
.at(span)?;
|
||||
let outline_loc = outline.location().unwrap();
|
||||
@ -483,7 +483,7 @@ impl OutlineEntry {
|
||||
.transpose()?;
|
||||
let prefix_inset = prefix_width.map(|w| w + gap.resolve(styles));
|
||||
|
||||
let indent = outline.indent(styles);
|
||||
let indent = outline.indent.get_ref(styles);
|
||||
let (base_indent, hanging_indent) = match &indent {
|
||||
Smart::Auto => compute_auto_indents(
|
||||
engine.introspector,
|
||||
@ -527,7 +527,7 @@ impl OutlineEntry {
|
||||
};
|
||||
|
||||
let inset = Sides::default().with(
|
||||
TextElem::dir_in(styles).start(),
|
||||
styles.resolve(TextElem::dir).start(),
|
||||
Some(base_indent + Rel::from(hanging_indent.unwrap_or_default())),
|
||||
);
|
||||
|
||||
@ -582,7 +582,7 @@ impl OutlineEntry {
|
||||
// See also:
|
||||
// - https://github.com/typst/typst/issues/4476
|
||||
// - https://github.com/typst/typst/issues/5176
|
||||
let rtl = TextElem::dir_in(styles) == Dir::RTL;
|
||||
let rtl = styles.resolve(TextElem::dir) == Dir::RTL;
|
||||
if rtl {
|
||||
// "Right-to-Left Embedding"
|
||||
seq.push(TextElem::packed("\u{202B}"));
|
||||
@ -596,11 +596,11 @@ impl OutlineEntry {
|
||||
}
|
||||
|
||||
// Add the filler between the section name and page number.
|
||||
if let Some(filler) = self.fill(styles) {
|
||||
if let Some(filler) = self.fill.get_cloned(styles) {
|
||||
seq.push(SpaceElem::shared().clone());
|
||||
seq.push(
|
||||
BoxElem::new()
|
||||
.with_body(Some(filler.clone()))
|
||||
.with_body(Some(filler))
|
||||
.with_width(Fr::one().into())
|
||||
.pack()
|
||||
.spanned(span),
|
||||
@ -717,7 +717,7 @@ fn query_prefix_widths(
|
||||
outline_loc: Location,
|
||||
) -> SmallVec<[Option<Abs>; 4]> {
|
||||
let mut widths = SmallVec::<[Option<Abs>; 4]>::new();
|
||||
let elems = introspector.query(&select_where!(PrefixInfo, Key => outline_loc));
|
||||
let elems = introspector.query(&select_where!(PrefixInfo, key => outline_loc));
|
||||
for elem in &elems {
|
||||
let info = elem.to_packed::<PrefixInfo>().unwrap();
|
||||
let level = info.level.get();
|
||||
|
@ -108,7 +108,6 @@ pub struct ParElem {
|
||||
/// to `{-0.2em}` to get a baseline gap of exactly `{2em}`. The exact
|
||||
/// distribution of the top- and bottom-edge values affects the bounds of
|
||||
/// the first and last line.
|
||||
#[resolve]
|
||||
#[default(Em::new(0.65).into())]
|
||||
pub leading: Length,
|
||||
|
||||
@ -122,7 +121,6 @@ pub struct ParElem {
|
||||
/// that block's [`above`]($block.above) or [`below`]($block.below) property
|
||||
/// takes precedence over the paragraph spacing. Headings, for instance,
|
||||
/// reduce the spacing below them by default for a better look.
|
||||
#[resolve]
|
||||
#[default(Em::new(1.2).into())]
|
||||
pub spacing: Length,
|
||||
|
||||
@ -213,7 +211,6 @@ pub struct ParElem {
|
||||
///
|
||||
/// #lorem(15)
|
||||
/// ```
|
||||
#[resolve]
|
||||
pub hanging_indent: Length,
|
||||
|
||||
/// The contents of the paragraph.
|
||||
|
@ -123,7 +123,6 @@ pub struct QuoteElem {
|
||||
///
|
||||
/// #bibliography("works.bib", style: "apa")
|
||||
/// ```
|
||||
#[borrowed]
|
||||
attribution: Option<Attribution>,
|
||||
|
||||
/// The quote.
|
||||
@ -158,19 +157,19 @@ impl Show for Packed<QuoteElem> {
|
||||
#[typst_macros::time(name = "quote", span = self.span())]
|
||||
fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
|
||||
let mut realized = self.body.clone();
|
||||
let block = self.block(styles);
|
||||
let html = TargetElem::target_in(styles).is_html();
|
||||
let block = self.block.get(styles);
|
||||
let html = styles.get(TargetElem::target).is_html();
|
||||
|
||||
if self.quotes(styles).unwrap_or(!block) {
|
||||
if self.quotes.get(styles).unwrap_or(!block) {
|
||||
let quotes = SmartQuotes::get(
|
||||
SmartQuoteElem::quotes_in(styles),
|
||||
TextElem::lang_in(styles),
|
||||
TextElem::region_in(styles),
|
||||
SmartQuoteElem::alternative_in(styles),
|
||||
styles.get_ref(SmartQuoteElem::quotes),
|
||||
styles.get(TextElem::lang),
|
||||
styles.get(TextElem::region),
|
||||
styles.get(SmartQuoteElem::alternative),
|
||||
);
|
||||
|
||||
// Alternate between single and double quotes.
|
||||
let Depth(depth) = QuoteElem::depth_in(styles);
|
||||
let Depth(depth) = styles.get(QuoteElem::depth);
|
||||
let double = depth % 2 == 0;
|
||||
|
||||
if !html {
|
||||
@ -183,10 +182,10 @@ impl Show for Packed<QuoteElem> {
|
||||
realized,
|
||||
TextElem::packed(quotes.close(double)),
|
||||
])
|
||||
.styled(QuoteElem::set_depth(Depth(1)));
|
||||
.set(QuoteElem::depth, Depth(1));
|
||||
}
|
||||
|
||||
let attribution = self.attribution(styles);
|
||||
let attribution = self.attribution.get_ref(styles);
|
||||
|
||||
if block {
|
||||
realized = if html {
|
||||
@ -204,7 +203,7 @@ impl Show for Packed<QuoteElem> {
|
||||
}
|
||||
.spanned(self.span());
|
||||
|
||||
if let Some(attribution) = attribution.as_ref() {
|
||||
if let Some(attribution) = attribution {
|
||||
let attribution = match attribution {
|
||||
Attribution::Content(content) => content.clone(),
|
||||
Attribution::Label(label) => CiteElem::new(*label)
|
||||
@ -247,11 +246,11 @@ impl Show for Packed<QuoteElem> {
|
||||
impl ShowSet for Packed<QuoteElem> {
|
||||
fn show_set(&self, styles: StyleChain) -> Styles {
|
||||
let mut out = Styles::new();
|
||||
if self.block(styles) {
|
||||
out.set(PadElem::set_left(Em::new(1.0).into()));
|
||||
out.set(PadElem::set_right(Em::new(1.0).into()));
|
||||
out.set(BlockElem::set_above(Smart::Custom(Em::new(2.4).into())));
|
||||
out.set(BlockElem::set_below(Smart::Custom(Em::new(1.8).into())));
|
||||
if self.block.get(styles) {
|
||||
out.set(PadElem::left, Em::new(1.0).into());
|
||||
out.set(PadElem::right, Em::new(1.0).into());
|
||||
out.set(BlockElem::above, Smart::Custom(Em::new(2.4).into()));
|
||||
out.set(BlockElem::below, Smart::Custom(Em::new(1.8).into()));
|
||||
}
|
||||
out
|
||||
}
|
||||
|
@ -175,7 +175,6 @@ pub struct RefElem {
|
||||
/// in @intro[Part], it is done
|
||||
/// manually.
|
||||
/// ```
|
||||
#[borrowed]
|
||||
pub supplement: Smart<Option<Supplement>>,
|
||||
|
||||
/// The kind of reference to produce.
|
||||
@ -207,12 +206,12 @@ impl Synthesize for Packed<RefElem> {
|
||||
let citation = to_citation(self, engine, styles)?;
|
||||
|
||||
let elem = self.as_mut();
|
||||
elem.push_citation(Some(citation));
|
||||
elem.push_element(None);
|
||||
elem.citation = Some(Some(citation));
|
||||
elem.element = Some(None);
|
||||
|
||||
if !BibliographyElem::has(engine, elem.target) {
|
||||
if let Ok(found) = engine.introspector.query_label(elem.target).cloned() {
|
||||
elem.push_element(Some(found));
|
||||
elem.element = Some(Some(found));
|
||||
return Ok(());
|
||||
}
|
||||
}
|
||||
@ -227,7 +226,7 @@ impl Show for Packed<RefElem> {
|
||||
let elem = engine.introspector.query_label(self.target);
|
||||
let span = self.span();
|
||||
|
||||
let form = self.form(styles);
|
||||
let form = self.form.get(styles);
|
||||
if form == RefForm::Page {
|
||||
let elem = elem.at(span)?;
|
||||
let elem = elem.clone();
|
||||
@ -299,7 +298,7 @@ impl Show for Packed<RefElem> {
|
||||
.hint(eco_format!(
|
||||
"you can enable {} numbering with `#set {}(numbering: \"1.\")`",
|
||||
elem.func().name(),
|
||||
if elem.func() == EquationElem::elem() {
|
||||
if elem.func() == EquationElem::ELEM {
|
||||
"math.equation"
|
||||
} else {
|
||||
elem.func().name()
|
||||
@ -332,7 +331,7 @@ fn show_reference(
|
||||
let loc = elem.location().unwrap();
|
||||
let numbers = counter.display_at_loc(engine, loc, styles, &numbering.trimmed())?;
|
||||
|
||||
let supplement = match reference.supplement(styles).as_ref() {
|
||||
let supplement = match reference.supplement.get_ref(styles) {
|
||||
Smart::Auto => supplement,
|
||||
Smart::Custom(None) => Content::empty(),
|
||||
Smart::Custom(Some(supplement)) => supplement.resolve(engine, styles, [elem])?,
|
||||
@ -353,7 +352,7 @@ fn to_citation(
|
||||
styles: StyleChain,
|
||||
) -> SourceResult<Packed<CiteElem>> {
|
||||
let mut elem = Packed::new(CiteElem::new(reference.target).with_supplement(
|
||||
match reference.supplement(styles).clone() {
|
||||
match reference.supplement.get_cloned(styles) {
|
||||
Smart::Custom(Some(Supplement::Content(content))) => Some(content),
|
||||
_ => None,
|
||||
},
|
||||
|
@ -44,13 +44,13 @@ impl Show for Packed<StrongElem> {
|
||||
#[typst_macros::time(name = "strong", span = self.span())]
|
||||
fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
|
||||
let body = self.body.clone();
|
||||
Ok(if TargetElem::target_in(styles).is_html() {
|
||||
Ok(if styles.get(TargetElem::target).is_html() {
|
||||
HtmlElem::new(tag::strong)
|
||||
.with_body(Some(body))
|
||||
.pack()
|
||||
.spanned(self.span())
|
||||
} else {
|
||||
body.styled(TextElem::set_delta(WeightDelta(self.delta(styles))))
|
||||
body.set(TextElem::delta, WeightDelta(self.delta.get(styles)))
|
||||
})
|
||||
}
|
||||
}
|
||||
|
@ -125,12 +125,10 @@ use crate::visualize::{Paint, Stroke};
|
||||
pub struct TableElem {
|
||||
/// The column sizes. See the [grid documentation]($grid) for more
|
||||
/// information on track sizing.
|
||||
#[borrowed]
|
||||
pub columns: TrackSizings,
|
||||
|
||||
/// The row sizes. See the [grid documentation]($grid) for more information
|
||||
/// on track sizing.
|
||||
#[borrowed]
|
||||
pub rows: TrackSizings,
|
||||
|
||||
/// The gaps between rows and columns. This is a shorthand for setting
|
||||
@ -141,7 +139,6 @@ pub struct TableElem {
|
||||
|
||||
/// The gaps between columns. Takes precedence over `gutter`. See the
|
||||
/// [grid documentation]($grid) for more information on gutters.
|
||||
#[borrowed]
|
||||
#[parse(
|
||||
let gutter = args.named("gutter")?;
|
||||
args.named("column-gutter")?.or_else(|| gutter.clone())
|
||||
@ -151,7 +148,6 @@ pub struct TableElem {
|
||||
/// The gaps between rows. Takes precedence over `gutter`. See the
|
||||
/// [grid documentation]($grid) for more information on gutters.
|
||||
#[parse(args.named("row-gutter")?.or_else(|| gutter.clone()))]
|
||||
#[borrowed]
|
||||
pub row_gutter: TrackSizings,
|
||||
|
||||
/// How to fill the cells.
|
||||
@ -176,7 +172,6 @@ pub struct TableElem {
|
||||
/// [Profit:], [500 €], [1000 €], [1500 €],
|
||||
/// )
|
||||
/// ```
|
||||
#[borrowed]
|
||||
pub fill: Celled<Option<Paint>>,
|
||||
|
||||
/// How to align the cells' content.
|
||||
@ -194,7 +189,6 @@ pub struct TableElem {
|
||||
/// [A], [B], [C],
|
||||
/// )
|
||||
/// ```
|
||||
#[borrowed]
|
||||
pub align: Celled<Smart<Alignment>>,
|
||||
|
||||
/// How to [stroke] the cells.
|
||||
@ -209,7 +203,6 @@ pub struct TableElem {
|
||||
///
|
||||
/// See the [grid documentation]($grid.stroke) for more information on
|
||||
/// strokes.
|
||||
#[resolve]
|
||||
#[fold]
|
||||
#[default(Celled::Value(Sides::splat(Some(Some(Arc::new(Stroke::default()))))))]
|
||||
pub stroke: Celled<Sides<Option<Option<Arc<Stroke>>>>>,
|
||||
@ -267,10 +260,10 @@ fn show_cell_html(tag: HtmlTag, cell: &Cell, styles: StyleChain) -> Content {
|
||||
let Some(cell) = cell.to_packed::<TableCell>() else { return cell };
|
||||
let mut attrs = HtmlAttrs::default();
|
||||
let span = |n: NonZeroUsize| (n != NonZeroUsize::MIN).then(|| n.to_string());
|
||||
if let Some(colspan) = span(cell.colspan(styles)) {
|
||||
if let Some(colspan) = span(cell.colspan.get(styles)) {
|
||||
attrs.push(attr::colspan, colspan);
|
||||
}
|
||||
if let Some(rowspan) = span(cell.rowspan(styles)) {
|
||||
if let Some(rowspan) = span(cell.rowspan.get(styles)) {
|
||||
attrs.push(attr::rowspan, rowspan);
|
||||
}
|
||||
HtmlElem::new(tag)
|
||||
@ -357,7 +350,7 @@ fn show_cellgrid_html(grid: CellGrid, styles: StyleChain) -> Content {
|
||||
|
||||
impl Show for Packed<TableElem> {
|
||||
fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
|
||||
Ok(if TargetElem::target_in(styles).is_html() {
|
||||
Ok(if styles.get(TargetElem::target).is_html() {
|
||||
// TODO: This is a hack, it is not clear whether the locator is actually used by HTML.
|
||||
// How can we find out whether locator is actually used?
|
||||
let locator = Locator::root();
|
||||
@ -621,7 +614,6 @@ pub struct TableHLine {
|
||||
///
|
||||
/// Specifying `{none}` removes any lines previously placed across this
|
||||
/// line's range, including hlines or per-cell stroke below it.
|
||||
#[resolve]
|
||||
#[fold]
|
||||
#[default(Some(Arc::new(Stroke::default())))]
|
||||
pub stroke: Option<Arc<Stroke>>,
|
||||
@ -666,7 +658,6 @@ pub struct TableVLine {
|
||||
///
|
||||
/// Specifying `{none}` removes any lines previously placed across this
|
||||
/// line's range, including vlines or per-cell stroke below it.
|
||||
#[resolve]
|
||||
#[fold]
|
||||
#[default(Some(Arc::new(Stroke::default())))]
|
||||
pub stroke: Option<Arc<Stroke>>,
|
||||
@ -802,7 +793,6 @@ pub struct TableCell {
|
||||
pub inset: Smart<Sides<Option<Rel<Length>>>>,
|
||||
|
||||
/// The cell's [stroke]($table.stroke) override.
|
||||
#[resolve]
|
||||
#[fold]
|
||||
pub stroke: Sides<Option<Option<Arc<Stroke>>>>,
|
||||
|
||||
@ -820,7 +810,7 @@ cast! {
|
||||
|
||||
impl Show for Packed<TableCell> {
|
||||
fn show(&self, _engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
|
||||
show_grid_cell(self.body.clone(), self.inset(styles), self.align(styles))
|
||||
show_grid_cell(self.body.clone(), self.inset.get(styles), self.align.get(styles))
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -66,7 +66,6 @@ pub struct TermsElem {
|
||||
/// / Colon: A nice separator symbol.
|
||||
/// ```
|
||||
#[default(HElem::new(Em::new(0.6).into()).with_weak(true).pack())]
|
||||
#[borrowed]
|
||||
pub separator: Content,
|
||||
|
||||
/// The indentation of each item.
|
||||
@ -121,9 +120,9 @@ impl TermsElem {
|
||||
impl Show for Packed<TermsElem> {
|
||||
fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
|
||||
let span = self.span();
|
||||
let tight = self.tight(styles);
|
||||
let tight = self.tight.get(styles);
|
||||
|
||||
if TargetElem::target_in(styles).is_html() {
|
||||
if styles.get(TargetElem::target).is_html() {
|
||||
return Ok(HtmlElem::new(tag::dl)
|
||||
.with_body(Some(Content::sequence(self.children.iter().flat_map(
|
||||
|item| {
|
||||
@ -148,14 +147,14 @@ impl Show for Packed<TermsElem> {
|
||||
.pack());
|
||||
}
|
||||
|
||||
let separator = self.separator(styles);
|
||||
let indent = self.indent(styles);
|
||||
let hanging_indent = self.hanging_indent(styles);
|
||||
let gutter = self.spacing(styles).unwrap_or_else(|| {
|
||||
let separator = self.separator.get_ref(styles);
|
||||
let indent = self.indent.get(styles);
|
||||
let hanging_indent = self.hanging_indent.get(styles);
|
||||
let gutter = self.spacing.get(styles).unwrap_or_else(|| {
|
||||
if tight {
|
||||
ParElem::leading_in(styles).into()
|
||||
styles.get(ParElem::leading)
|
||||
} else {
|
||||
ParElem::spacing_in(styles).into()
|
||||
styles.get(ParElem::spacing)
|
||||
}
|
||||
});
|
||||
|
||||
@ -179,19 +178,21 @@ impl Show for Packed<TermsElem> {
|
||||
children.push(StackChild::Block(Content::sequence(seq)));
|
||||
}
|
||||
|
||||
let padding = Sides::default().with(TextElem::dir_in(styles).start(), pad.into());
|
||||
let padding =
|
||||
Sides::default().with(styles.resolve(TextElem::dir).start(), pad.into());
|
||||
|
||||
let mut realized = StackElem::new(children)
|
||||
.with_spacing(Some(gutter.into()))
|
||||
.pack()
|
||||
.spanned(span)
|
||||
.padded(padding)
|
||||
.styled(TermsElem::set_within(true));
|
||||
.set(TermsElem::within, true);
|
||||
|
||||
if tight {
|
||||
let spacing = self
|
||||
.spacing(styles)
|
||||
.unwrap_or_else(|| ParElem::leading_in(styles).into());
|
||||
.spacing
|
||||
.get(styles)
|
||||
.unwrap_or_else(|| styles.get(ParElem::leading));
|
||||
let v = VElem::new(spacing.into())
|
||||
.with_weak(true)
|
||||
.with_attach(true)
|
||||
|
@ -48,7 +48,6 @@ pub struct EmbedElem {
|
||||
let resolved = id.vpath().as_rootless_path().to_string_lossy().replace("\\", "/").into();
|
||||
Derived::new(path.clone(), resolved)
|
||||
)]
|
||||
#[borrowed]
|
||||
pub path: Derived<EcoString, EcoString>,
|
||||
|
||||
/// Raw file data, optionally.
|
||||
@ -72,17 +71,15 @@ pub struct EmbedElem {
|
||||
pub relationship: Option<EmbeddedFileRelationship>,
|
||||
|
||||
/// The MIME type of the embedded file.
|
||||
#[borrowed]
|
||||
pub mime_type: Option<EcoString>,
|
||||
|
||||
/// A description for the embedded file.
|
||||
#[borrowed]
|
||||
pub description: Option<EcoString>,
|
||||
}
|
||||
|
||||
impl Show for Packed<EmbedElem> {
|
||||
fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
|
||||
if TargetElem::target_in(styles) == Target::Html {
|
||||
if styles.get(TargetElem::target) == Target::Html {
|
||||
engine
|
||||
.sink
|
||||
.warn(warning!(self.span(), "embed was ignored during HTML export"));
|
||||
|
@ -37,9 +37,7 @@ pub fn upper(
|
||||
fn case(text: Caseable, case: Case) -> Caseable {
|
||||
match text {
|
||||
Caseable::Str(v) => Caseable::Str(case.apply(&v).into()),
|
||||
Caseable::Content(v) => {
|
||||
Caseable::Content(v.styled(TextElem::set_case(Some(case))))
|
||||
}
|
||||
Caseable::Content(v) => Caseable::Content(v.set(TextElem::case, Some(case))),
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -30,7 +30,6 @@ pub struct UnderlineElem {
|
||||
/// [care],
|
||||
/// )
|
||||
/// ```
|
||||
#[resolve]
|
||||
#[fold]
|
||||
pub stroke: Smart<Stroke>,
|
||||
|
||||
@ -42,7 +41,6 @@ pub struct UnderlineElem {
|
||||
/// The Tale Of A Faraway Line I
|
||||
/// ]
|
||||
/// ```
|
||||
#[resolve]
|
||||
pub offset: Smart<Length>,
|
||||
|
||||
/// The amount by which to extend the line beyond (or within if negative)
|
||||
@ -53,7 +51,6 @@ pub struct UnderlineElem {
|
||||
/// underline(extent: 2pt)[Chapter 1]
|
||||
/// )
|
||||
/// ```
|
||||
#[resolve]
|
||||
pub extent: Length,
|
||||
|
||||
/// Whether the line skips sections in which it would collide with the
|
||||
@ -84,7 +81,7 @@ pub struct UnderlineElem {
|
||||
impl Show for Packed<UnderlineElem> {
|
||||
#[typst_macros::time(name = "underline", span = self.span())]
|
||||
fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
|
||||
if TargetElem::target_in(styles).is_html() {
|
||||
if styles.get(TargetElem::target).is_html() {
|
||||
// Note: In modern HTML, `<u>` is not the underline element, but
|
||||
// rather an "Unarticulated Annotation" element (see HTML spec
|
||||
// 4.5.22). Using `text-decoration` instead is recommended by MDN.
|
||||
@ -94,15 +91,18 @@ impl Show for Packed<UnderlineElem> {
|
||||
.pack());
|
||||
}
|
||||
|
||||
Ok(self.body.clone().styled(TextElem::set_deco(smallvec![Decoration {
|
||||
Ok(self.body.clone().set(
|
||||
TextElem::deco,
|
||||
smallvec![Decoration {
|
||||
line: DecoLine::Underline {
|
||||
stroke: self.stroke(styles).unwrap_or_default(),
|
||||
offset: self.offset(styles),
|
||||
evade: self.evade(styles),
|
||||
background: self.background(styles),
|
||||
stroke: self.stroke.resolve(styles).unwrap_or_default(),
|
||||
offset: self.offset.resolve(styles),
|
||||
evade: self.evade.get(styles),
|
||||
background: self.background.get(styles),
|
||||
},
|
||||
extent: self.extent(styles),
|
||||
}])))
|
||||
extent: self.extent.resolve(styles),
|
||||
}],
|
||||
))
|
||||
}
|
||||
}
|
||||
|
||||
@ -127,7 +127,6 @@ pub struct OverlineElem {
|
||||
/// [The Forest Theme],
|
||||
/// )
|
||||
/// ```
|
||||
#[resolve]
|
||||
#[fold]
|
||||
pub stroke: Smart<Stroke>,
|
||||
|
||||
@ -139,7 +138,6 @@ pub struct OverlineElem {
|
||||
/// The Tale Of A Faraway Line II
|
||||
/// ]
|
||||
/// ```
|
||||
#[resolve]
|
||||
pub offset: Smart<Length>,
|
||||
|
||||
/// The amount by which to extend the line beyond (or within if negative)
|
||||
@ -150,7 +148,6 @@ pub struct OverlineElem {
|
||||
/// #set underline(extent: 4pt)
|
||||
/// #overline(underline[Typography Today])
|
||||
/// ```
|
||||
#[resolve]
|
||||
pub extent: Length,
|
||||
|
||||
/// Whether the line skips sections in which it would collide with the
|
||||
@ -186,22 +183,25 @@ pub struct OverlineElem {
|
||||
impl Show for Packed<OverlineElem> {
|
||||
#[typst_macros::time(name = "overline", span = self.span())]
|
||||
fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
|
||||
if TargetElem::target_in(styles).is_html() {
|
||||
if styles.get(TargetElem::target).is_html() {
|
||||
return Ok(HtmlElem::new(tag::span)
|
||||
.with_attr(attr::style, "text-decoration: overline")
|
||||
.with_body(Some(self.body.clone()))
|
||||
.pack());
|
||||
}
|
||||
|
||||
Ok(self.body.clone().styled(TextElem::set_deco(smallvec![Decoration {
|
||||
Ok(self.body.clone().set(
|
||||
TextElem::deco,
|
||||
smallvec![Decoration {
|
||||
line: DecoLine::Overline {
|
||||
stroke: self.stroke(styles).unwrap_or_default(),
|
||||
offset: self.offset(styles),
|
||||
evade: self.evade(styles),
|
||||
background: self.background(styles),
|
||||
stroke: self.stroke.resolve(styles).unwrap_or_default(),
|
||||
offset: self.offset.resolve(styles),
|
||||
evade: self.evade.get(styles),
|
||||
background: self.background.get(styles),
|
||||
},
|
||||
extent: self.extent(styles),
|
||||
}])))
|
||||
extent: self.extent.resolve(styles),
|
||||
}],
|
||||
))
|
||||
}
|
||||
}
|
||||
|
||||
@ -225,7 +225,6 @@ pub struct StrikeElem {
|
||||
/// This is #strike(stroke: 1.5pt + red)[very stricken through]. \
|
||||
/// This is #strike(stroke: 10pt)[redacted].
|
||||
/// ```
|
||||
#[resolve]
|
||||
#[fold]
|
||||
pub stroke: Smart<Stroke>,
|
||||
|
||||
@ -239,7 +238,6 @@ pub struct StrikeElem {
|
||||
/// This is #strike(offset: auto)[low-ish]. \
|
||||
/// This is #strike(offset: -3.5pt)[on-top].
|
||||
/// ```
|
||||
#[resolve]
|
||||
pub offset: Smart<Length>,
|
||||
|
||||
/// The amount by which to extend the line beyond (or within if negative)
|
||||
@ -249,7 +247,6 @@ pub struct StrikeElem {
|
||||
/// This #strike(extent: -2pt)[skips] parts of the word.
|
||||
/// This #strike(extent: 2pt)[extends] beyond the word.
|
||||
/// ```
|
||||
#[resolve]
|
||||
pub extent: Length,
|
||||
|
||||
/// Whether the line is placed behind the content.
|
||||
@ -270,19 +267,22 @@ pub struct StrikeElem {
|
||||
impl Show for Packed<StrikeElem> {
|
||||
#[typst_macros::time(name = "strike", span = self.span())]
|
||||
fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
|
||||
if TargetElem::target_in(styles).is_html() {
|
||||
if styles.get(TargetElem::target).is_html() {
|
||||
return Ok(HtmlElem::new(tag::s).with_body(Some(self.body.clone())).pack());
|
||||
}
|
||||
|
||||
Ok(self.body.clone().styled(TextElem::set_deco(smallvec![Decoration {
|
||||
Ok(self.body.clone().set(
|
||||
TextElem::deco,
|
||||
smallvec![Decoration {
|
||||
// Note that we do not support evade option for strikethrough.
|
||||
line: DecoLine::Strikethrough {
|
||||
stroke: self.stroke(styles).unwrap_or_default(),
|
||||
offset: self.offset(styles),
|
||||
background: self.background(styles),
|
||||
stroke: self.stroke.resolve(styles).unwrap_or_default(),
|
||||
offset: self.offset.resolve(styles),
|
||||
background: self.background.get(styles),
|
||||
},
|
||||
extent: self.extent(styles),
|
||||
}])))
|
||||
extent: self.extent.resolve(styles),
|
||||
}],
|
||||
))
|
||||
}
|
||||
}
|
||||
|
||||
@ -312,7 +312,6 @@ pub struct HighlightElem {
|
||||
/// stroke: fuchsia
|
||||
/// )[stroked highlighting].
|
||||
/// ```
|
||||
#[resolve]
|
||||
#[fold]
|
||||
pub stroke: Sides<Option<Option<Stroke>>>,
|
||||
|
||||
@ -346,7 +345,6 @@ pub struct HighlightElem {
|
||||
/// ```example
|
||||
/// A long #highlight(extent: 4pt)[background].
|
||||
/// ```
|
||||
#[resolve]
|
||||
pub extent: Length,
|
||||
|
||||
/// How much to round the highlight's corners. See the
|
||||
@ -357,7 +355,6 @@ pub struct HighlightElem {
|
||||
/// radius: 5pt, extent: 2pt
|
||||
/// )[carefully], it will be on the test.
|
||||
/// ```
|
||||
#[resolve]
|
||||
#[fold]
|
||||
pub radius: Corners<Option<Rel<Length>>>,
|
||||
|
||||
@ -369,25 +366,29 @@ pub struct HighlightElem {
|
||||
impl Show for Packed<HighlightElem> {
|
||||
#[typst_macros::time(name = "highlight", span = self.span())]
|
||||
fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
|
||||
if TargetElem::target_in(styles).is_html() {
|
||||
if styles.get(TargetElem::target).is_html() {
|
||||
return Ok(HtmlElem::new(tag::mark)
|
||||
.with_body(Some(self.body.clone()))
|
||||
.pack());
|
||||
}
|
||||
|
||||
Ok(self.body.clone().styled(TextElem::set_deco(smallvec![Decoration {
|
||||
Ok(self.body.clone().set(
|
||||
TextElem::deco,
|
||||
smallvec![Decoration {
|
||||
line: DecoLine::Highlight {
|
||||
fill: self.fill(styles),
|
||||
fill: self.fill.get_cloned(styles),
|
||||
stroke: self
|
||||
.stroke(styles)
|
||||
.stroke
|
||||
.resolve(styles)
|
||||
.unwrap_or_default()
|
||||
.map(|stroke| stroke.map(Stroke::unwrap_or_default)),
|
||||
top_edge: self.top_edge(styles),
|
||||
bottom_edge: self.bottom_edge(styles),
|
||||
radius: self.radius(styles).unwrap_or_default(),
|
||||
top_edge: self.top_edge.get(styles),
|
||||
bottom_edge: self.bottom_edge.get(styles),
|
||||
radius: self.radius.resolve(styles).unwrap_or_default(),
|
||||
},
|
||||
extent: self.extent(styles),
|
||||
}])))
|
||||
extent: self.extent.resolve(styles),
|
||||
}],
|
||||
))
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -250,7 +250,7 @@ pub trait LocalName {
|
||||
where
|
||||
Self: Sized,
|
||||
{
|
||||
Self::local_name(TextElem::lang_in(styles), TextElem::region_in(styles))
|
||||
Self::local_name(styles.get(TextElem::lang), styles.get(TextElem::region))
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -165,7 +165,6 @@ pub struct TextElem {
|
||||
font_list.map(|font_list| font_list.v)
|
||||
})]
|
||||
#[default(FontList(vec![FontFamily::new("Libertinus Serif")]))]
|
||||
#[borrowed]
|
||||
#[ghost]
|
||||
pub font: FontList,
|
||||
|
||||
@ -260,7 +259,6 @@ pub struct TextElem {
|
||||
#[parse(args.named_or_find("size")?)]
|
||||
#[fold]
|
||||
#[default(TextSize(Abs::pt(11.0).into()))]
|
||||
#[resolve]
|
||||
#[ghost]
|
||||
pub size: TextSize,
|
||||
|
||||
@ -292,7 +290,6 @@ pub struct TextElem {
|
||||
/// ```example
|
||||
/// #text(stroke: 0.5pt + red)[Stroked]
|
||||
/// ```
|
||||
#[resolve]
|
||||
#[ghost]
|
||||
pub stroke: Option<Stroke>,
|
||||
|
||||
@ -302,7 +299,6 @@ pub struct TextElem {
|
||||
/// #set text(tracking: 1.5pt)
|
||||
/// Distant text.
|
||||
/// ```
|
||||
#[resolve]
|
||||
#[ghost]
|
||||
pub tracking: Length,
|
||||
|
||||
@ -318,7 +314,6 @@ pub struct TextElem {
|
||||
/// #set text(spacing: 200%)
|
||||
/// Text with distant words.
|
||||
/// ```
|
||||
#[resolve]
|
||||
#[default(Rel::one())]
|
||||
#[ghost]
|
||||
pub spacing: Rel<Length>,
|
||||
@ -341,7 +336,6 @@ pub struct TextElem {
|
||||
/// A #text(baseline: 3pt)[lowered]
|
||||
/// word.
|
||||
/// ```
|
||||
#[resolve]
|
||||
#[ghost]
|
||||
pub baseline: Length,
|
||||
|
||||
@ -483,7 +477,6 @@ pub struct TextElem {
|
||||
/// #set text(dir: rtl)
|
||||
/// هذا عربي.
|
||||
/// ```
|
||||
#[resolve]
|
||||
#[ghost]
|
||||
pub dir: TextDir,
|
||||
|
||||
@ -950,24 +943,24 @@ pub fn families(styles: StyleChain<'_>) -> impl Iterator<Item = &'_ FontFamily>
|
||||
.collect()
|
||||
});
|
||||
|
||||
let tail = if TextElem::fallback_in(styles) { fallbacks.as_slice() } else { &[] };
|
||||
TextElem::font_in(styles).into_iter().chain(tail.iter())
|
||||
let tail = if styles.get(TextElem::fallback) { fallbacks.as_slice() } else { &[] };
|
||||
styles.get_ref(TextElem::font).into_iter().chain(tail.iter())
|
||||
}
|
||||
|
||||
/// Resolve the font variant.
|
||||
pub fn variant(styles: StyleChain) -> FontVariant {
|
||||
let mut variant = FontVariant::new(
|
||||
TextElem::style_in(styles),
|
||||
TextElem::weight_in(styles),
|
||||
TextElem::stretch_in(styles),
|
||||
styles.get(TextElem::style),
|
||||
styles.get(TextElem::weight),
|
||||
styles.get(TextElem::stretch),
|
||||
);
|
||||
|
||||
let WeightDelta(delta) = TextElem::delta_in(styles);
|
||||
let WeightDelta(delta) = styles.get(TextElem::delta);
|
||||
variant.weight = variant
|
||||
.weight
|
||||
.thicken(delta.clamp(i16::MIN as i64, i16::MAX as i64) as i16);
|
||||
|
||||
if TextElem::emph_in(styles).0 {
|
||||
if styles.get(TextElem::emph).0 {
|
||||
variant.style = match variant.style {
|
||||
FontStyle::Normal => FontStyle::Italic,
|
||||
FontStyle::Italic => FontStyle::Normal,
|
||||
@ -996,11 +989,11 @@ impl Resolve for TextSize {
|
||||
type Output = Abs;
|
||||
|
||||
fn resolve(self, styles: StyleChain) -> Self::Output {
|
||||
let factor = match EquationElem::size_in(styles) {
|
||||
let factor = match styles.get(EquationElem::size) {
|
||||
MathSize::Display | MathSize::Text => 1.0,
|
||||
MathSize::Script => EquationElem::script_scale_in(styles).0 as f64 / 100.0,
|
||||
MathSize::Script => styles.get(EquationElem::script_scale).0 as f64 / 100.0,
|
||||
MathSize::ScriptScript => {
|
||||
EquationElem::script_scale_in(styles).1 as f64 / 100.0
|
||||
styles.get(EquationElem::script_scale).1 as f64 / 100.0
|
||||
}
|
||||
};
|
||||
factor * self.0.resolve(styles)
|
||||
@ -1123,7 +1116,7 @@ impl Resolve for TextDir {
|
||||
|
||||
fn resolve(self, styles: StyleChain) -> Self::Output {
|
||||
match self.0 {
|
||||
Smart::Auto => TextElem::lang_in(styles).dir(),
|
||||
Smart::Auto => styles.get(TextElem::lang).dir(),
|
||||
Smart::Custom(dir) => dir,
|
||||
}
|
||||
}
|
||||
@ -1236,67 +1229,67 @@ pub fn features(styles: StyleChain) -> Vec<Feature> {
|
||||
};
|
||||
|
||||
// Features that are on by default in Harfbuzz are only added if disabled.
|
||||
if !TextElem::kerning_in(styles) {
|
||||
if !styles.get(TextElem::kerning) {
|
||||
feat(b"kern", 0);
|
||||
}
|
||||
|
||||
// Features that are off by default in Harfbuzz are only added if enabled.
|
||||
if let Some(sc) = TextElem::smallcaps_in(styles) {
|
||||
if let Some(sc) = styles.get(TextElem::smallcaps) {
|
||||
feat(b"smcp", 1);
|
||||
if sc == Smallcaps::All {
|
||||
feat(b"c2sc", 1);
|
||||
}
|
||||
}
|
||||
|
||||
if TextElem::alternates_in(styles) {
|
||||
if styles.get(TextElem::alternates) {
|
||||
feat(b"salt", 1);
|
||||
}
|
||||
|
||||
for set in TextElem::stylistic_set_in(styles).sets() {
|
||||
for set in styles.get(TextElem::stylistic_set).sets() {
|
||||
let storage = [b's', b's', b'0' + set / 10, b'0' + set % 10];
|
||||
feat(&storage, 1);
|
||||
}
|
||||
|
||||
if !TextElem::ligatures_in(styles) {
|
||||
if !styles.get(TextElem::ligatures) {
|
||||
feat(b"liga", 0);
|
||||
feat(b"clig", 0);
|
||||
}
|
||||
|
||||
if TextElem::discretionary_ligatures_in(styles) {
|
||||
if styles.get(TextElem::discretionary_ligatures) {
|
||||
feat(b"dlig", 1);
|
||||
}
|
||||
|
||||
if TextElem::historical_ligatures_in(styles) {
|
||||
if styles.get(TextElem::historical_ligatures) {
|
||||
feat(b"hlig", 1);
|
||||
}
|
||||
|
||||
match TextElem::number_type_in(styles) {
|
||||
match styles.get(TextElem::number_type) {
|
||||
Smart::Auto => {}
|
||||
Smart::Custom(NumberType::Lining) => feat(b"lnum", 1),
|
||||
Smart::Custom(NumberType::OldStyle) => feat(b"onum", 1),
|
||||
}
|
||||
|
||||
match TextElem::number_width_in(styles) {
|
||||
match styles.get(TextElem::number_width) {
|
||||
Smart::Auto => {}
|
||||
Smart::Custom(NumberWidth::Proportional) => feat(b"pnum", 1),
|
||||
Smart::Custom(NumberWidth::Tabular) => feat(b"tnum", 1),
|
||||
}
|
||||
|
||||
if TextElem::slashed_zero_in(styles) {
|
||||
if styles.get(TextElem::slashed_zero) {
|
||||
feat(b"zero", 1);
|
||||
}
|
||||
|
||||
if TextElem::fractions_in(styles) {
|
||||
if styles.get(TextElem::fractions) {
|
||||
feat(b"frac", 1);
|
||||
}
|
||||
|
||||
match EquationElem::size_in(styles) {
|
||||
match styles.get(EquationElem::size) {
|
||||
MathSize::Script => feat(b"ssty", 1),
|
||||
MathSize::ScriptScript => feat(b"ssty", 2),
|
||||
_ => {}
|
||||
}
|
||||
|
||||
for (tag, value) in TextElem::features_in(styles).0 {
|
||||
for (tag, value) in styles.get_cloned(TextElem::features).0 {
|
||||
tags.push(Feature::new(tag, value, ..))
|
||||
}
|
||||
|
||||
@ -1306,8 +1299,8 @@ pub fn features(styles: StyleChain) -> Vec<Feature> {
|
||||
/// Process the language and region of a style chain into a
|
||||
/// rustybuzz-compatible BCP 47 language.
|
||||
pub fn language(styles: StyleChain) -> rustybuzz::Language {
|
||||
let mut bcp: EcoString = TextElem::lang_in(styles).as_str().into();
|
||||
if let Some(region) = TextElem::region_in(styles) {
|
||||
let mut bcp: EcoString = styles.get(TextElem::lang).as_str().into();
|
||||
if let Some(region) = styles.get(TextElem::region) {
|
||||
bcp.push('-');
|
||||
bcp.push_str(region.as_str());
|
||||
}
|
||||
|
@ -158,7 +158,6 @@ pub struct RawElem {
|
||||
///
|
||||
/// This is ```typ also *Typst*```, but inline!
|
||||
/// ````
|
||||
#[borrowed]
|
||||
pub lang: Option<EcoString>,
|
||||
|
||||
/// The horizontal alignment that each line in a raw block should have.
|
||||
@ -250,7 +249,6 @@ pub struct RawElem {
|
||||
Some(Spanned { v: Smart::Auto, .. }) => Some(Smart::Auto),
|
||||
None => None,
|
||||
})]
|
||||
#[borrowed]
|
||||
pub theme: Smart<Option<Derived<DataSource, RawTheme>>>,
|
||||
|
||||
/// The size for a tab stop in spaces. A tab is replaced with enough spaces to
|
||||
@ -306,7 +304,7 @@ impl RawElem {
|
||||
impl Synthesize for Packed<RawElem> {
|
||||
fn synthesize(&mut self, _: &mut Engine, styles: StyleChain) -> SourceResult<()> {
|
||||
let seq = self.highlight(styles);
|
||||
self.push_lines(seq);
|
||||
self.lines = Some(seq);
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
@ -319,8 +317,8 @@ impl Packed<RawElem> {
|
||||
|
||||
let count = lines.len() as i64;
|
||||
let lang = elem
|
||||
.lang(styles)
|
||||
.as_ref()
|
||||
.lang
|
||||
.get_ref(styles)
|
||||
.as_ref()
|
||||
.map(|s| s.to_lowercase())
|
||||
.or(Some("txt".into()));
|
||||
@ -337,8 +335,8 @@ impl Packed<RawElem> {
|
||||
})
|
||||
};
|
||||
|
||||
let syntaxes = LazyCell::new(|| elem.syntaxes(styles));
|
||||
let theme: &synt::Theme = match elem.theme(styles) {
|
||||
let syntaxes = LazyCell::new(|| elem.syntaxes.get_cloned(styles));
|
||||
let theme: &synt::Theme = match elem.theme.get_ref(styles) {
|
||||
Smart::Auto => &RAW_THEME,
|
||||
Smart::Custom(Some(theme)) => theme.derived.get(),
|
||||
Smart::Custom(None) => return non_highlighted_result(lines).collect(),
|
||||
@ -434,7 +432,7 @@ impl Packed<RawElem> {
|
||||
impl Show for Packed<RawElem> {
|
||||
#[typst_macros::time(name = "raw", span = self.span())]
|
||||
fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
|
||||
let lines = self.lines().map(|v| v.as_slice()).unwrap_or_default();
|
||||
let lines = self.lines.as_deref().unwrap_or_default();
|
||||
|
||||
let mut seq = EcoVec::with_capacity((2 * lines.len()).saturating_sub(1));
|
||||
for (i, line) in lines.iter().enumerate() {
|
||||
@ -447,8 +445,8 @@ impl Show for Packed<RawElem> {
|
||||
|
||||
let mut realized = Content::sequence(seq);
|
||||
|
||||
if TargetElem::target_in(styles).is_html() {
|
||||
return Ok(HtmlElem::new(if self.block(styles) {
|
||||
if styles.get(TargetElem::target).is_html() {
|
||||
return Ok(HtmlElem::new(if self.block.get(styles) {
|
||||
tag::pre
|
||||
} else {
|
||||
tag::code
|
||||
@ -458,9 +456,9 @@ impl Show for Packed<RawElem> {
|
||||
.spanned(self.span()));
|
||||
}
|
||||
|
||||
if self.block(styles) {
|
||||
if self.block.get(styles) {
|
||||
// Align the text before inserting it into the block.
|
||||
realized = realized.aligned(self.align(styles).into());
|
||||
realized = realized.aligned(self.align.get(styles).into());
|
||||
realized = BlockElem::new()
|
||||
.with_body(Some(BlockBody::Content(realized)))
|
||||
.pack()
|
||||
@ -474,14 +472,14 @@ impl Show for Packed<RawElem> {
|
||||
impl ShowSet for Packed<RawElem> {
|
||||
fn show_set(&self, styles: StyleChain) -> Styles {
|
||||
let mut out = Styles::new();
|
||||
out.set(TextElem::set_overhang(false));
|
||||
out.set(TextElem::set_lang(Lang::ENGLISH));
|
||||
out.set(TextElem::set_hyphenate(Smart::Custom(false)));
|
||||
out.set(TextElem::set_size(TextSize(Em::new(0.8).into())));
|
||||
out.set(TextElem::set_font(FontList(vec![FontFamily::new("DejaVu Sans Mono")])));
|
||||
out.set(TextElem::set_cjk_latin_spacing(Smart::Custom(None)));
|
||||
if self.block(styles) {
|
||||
out.set(ParElem::set_justify(false));
|
||||
out.set(TextElem::overhang, false);
|
||||
out.set(TextElem::lang, Lang::ENGLISH);
|
||||
out.set(TextElem::hyphenate, Smart::Custom(false));
|
||||
out.set(TextElem::size, TextSize(Em::new(0.8).into()));
|
||||
out.set(TextElem::font, FontList(vec![FontFamily::new("DejaVu Sans Mono")]));
|
||||
out.set(TextElem::cjk_latin_spacing, Smart::Custom(None));
|
||||
if self.block.get(styles) {
|
||||
out.set(ParElem::justify, false);
|
||||
}
|
||||
out
|
||||
}
|
||||
@ -789,7 +787,7 @@ fn preprocess(
|
||||
|
||||
let mut text = text.get();
|
||||
if text.contains('\t') {
|
||||
let tab_size = RawElem::tab_size_in(styles);
|
||||
let tab_size = styles.get(RawElem::tab_size);
|
||||
text = align_tabs(&text, tab_size);
|
||||
}
|
||||
split_newlines(&text)
|
||||
@ -809,11 +807,11 @@ fn styled(
|
||||
let mut body = TextElem::packed(piece).spanned(span);
|
||||
|
||||
if span_offset > 0 {
|
||||
body = body.styled(TextElem::set_span_offset(span_offset));
|
||||
body = body.set(TextElem::span_offset, span_offset);
|
||||
}
|
||||
|
||||
if style.foreground != foreground {
|
||||
body = body.styled(TextElem::set_fill(to_typst(style.foreground).into()));
|
||||
body = body.set(TextElem::fill, to_typst(style.foreground).into());
|
||||
}
|
||||
|
||||
if style.font_style.contains(synt::FontStyle::BOLD) {
|
||||
|
@ -69,7 +69,7 @@ impl Show for Packed<SubElem> {
|
||||
fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
|
||||
let body = self.body.clone();
|
||||
|
||||
if TargetElem::target_in(styles).is_html() {
|
||||
if styles.get(TargetElem::target).is_html() {
|
||||
return Ok(HtmlElem::new(tag::sub)
|
||||
.with_body(Some(body))
|
||||
.pack()
|
||||
@ -79,9 +79,9 @@ impl Show for Packed<SubElem> {
|
||||
show_script(
|
||||
styles,
|
||||
body,
|
||||
self.typographic(styles),
|
||||
self.baseline(styles),
|
||||
self.size(styles),
|
||||
self.typographic.get(styles),
|
||||
self.baseline.get(styles),
|
||||
self.size.get(styles),
|
||||
ScriptKind::Sub,
|
||||
)
|
||||
}
|
||||
@ -151,7 +151,7 @@ impl Show for Packed<SuperElem> {
|
||||
fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
|
||||
let body = self.body.clone();
|
||||
|
||||
if TargetElem::target_in(styles).is_html() {
|
||||
if styles.get(TargetElem::target).is_html() {
|
||||
return Ok(HtmlElem::new(tag::sup)
|
||||
.with_body(Some(body))
|
||||
.pack()
|
||||
@ -161,9 +161,9 @@ impl Show for Packed<SuperElem> {
|
||||
show_script(
|
||||
styles,
|
||||
body,
|
||||
self.typographic(styles),
|
||||
self.baseline(styles),
|
||||
self.size(styles),
|
||||
self.typographic.get(styles),
|
||||
self.baseline.get(styles),
|
||||
self.size.get(styles),
|
||||
ScriptKind::Super,
|
||||
)
|
||||
}
|
||||
@ -177,13 +177,16 @@ fn show_script(
|
||||
size: Smart<TextSize>,
|
||||
kind: ScriptKind,
|
||||
) -> SourceResult<Content> {
|
||||
let font_size = TextElem::size_in(styles);
|
||||
Ok(body.styled(TextElem::set_shift_settings(Some(ShiftSettings {
|
||||
let font_size = styles.resolve(TextElem::size);
|
||||
Ok(body.set(
|
||||
TextElem::shift_settings,
|
||||
Some(ShiftSettings {
|
||||
typographic,
|
||||
shift: baseline.map(|l| -Em::from_length(l, font_size)),
|
||||
size: size.map(|t| Em::from_length(t.0, font_size)),
|
||||
kind,
|
||||
}))))
|
||||
}),
|
||||
))
|
||||
}
|
||||
|
||||
/// Configuration values for sub- or superscript text.
|
||||
|
@ -64,8 +64,9 @@ pub struct SmallcapsElem {
|
||||
impl Show for Packed<SmallcapsElem> {
|
||||
#[typst_macros::time(name = "smallcaps", span = self.span())]
|
||||
fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
|
||||
let sc = if self.all(styles) { Smallcaps::All } else { Smallcaps::Minuscules };
|
||||
Ok(self.body.clone().styled(TextElem::set_smallcaps(Some(sc))))
|
||||
let sc =
|
||||
if self.all.get(styles) { Smallcaps::All } else { Smallcaps::Minuscules };
|
||||
Ok(self.body.clone().set(TextElem::smallcaps, Some(sc)))
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -83,13 +83,12 @@ pub struct SmartQuoteElem {
|
||||
/// #set smartquote(quotes: (single: ("[[", "]]"), double: auto))
|
||||
/// 'Das sind eigene Anführungszeichen.'
|
||||
/// ```
|
||||
#[borrowed]
|
||||
pub quotes: Smart<SmartQuoteDict>,
|
||||
}
|
||||
|
||||
impl PlainText for Packed<SmartQuoteElem> {
|
||||
fn plain_text(&self, text: &mut EcoString) {
|
||||
if self.double.unwrap_or(true) {
|
||||
if self.double.as_option().unwrap_or(true) {
|
||||
text.push_str("\"");
|
||||
} else {
|
||||
text.push_str("'");
|
||||
|
@ -86,7 +86,6 @@ pub struct CurveElem {
|
||||
/// down, up, down, up, down,
|
||||
/// )
|
||||
/// ```
|
||||
#[resolve]
|
||||
#[fold]
|
||||
pub stroke: Smart<Option<Stroke>>,
|
||||
|
||||
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
x
Reference in New Issue
Block a user