diff --git a/crates/typst-layout/src/math/accent.rs b/crates/typst-layout/src/math/accent.rs index e7f051ace..32937c52b 100644 --- a/crates/typst-layout/src/math/accent.rs +++ b/crates/typst-layout/src/math/accent.rs @@ -1,6 +1,6 @@ use typst_library::diag::SourceResult; use typst_library::foundations::{Packed, StyleChain}; -use typst_library::layout::{Em, Frame, Point, Size}; +use typst_library::layout::{Frame, Point, Size}; use typst_library::math::AccentElem; use super::{ @@ -8,9 +8,6 @@ use super::{ MathFragment, }; -/// How much the accent can be shorter than the base. -const ACCENT_SHORT_FALL: Em = Em::new(0.5); - /// Lays out an [`AccentElem`]. #[typst_macros::time(name = "math.accent", span = elem.span())] pub fn layout_accent( @@ -45,11 +42,8 @@ pub fn layout_accent( let mut glyph = GlyphFragment::new_char(ctx.font, accent_styles, accent.0, elem.span())?; - // Forcing the accent to be at least as large as the base makes it too wide - // in many cases. - 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 width = elem.size.get_ref(styles).resolve(ctx.engine, styles, base.width())?; + glyph.stretch_horizontal(ctx, width); let accent_attach = glyph.accent_attach.0; let accent = glyph.into_frame(); diff --git a/crates/typst-layout/src/math/attach.rs b/crates/typst-layout/src/math/attach.rs index 78b6f5515..7bb4cf319 100644 --- a/crates/typst-layout/src/math/attach.rs +++ b/crates/typst-layout/src/math/attach.rs @@ -1,8 +1,9 @@ use typst_library::diag::SourceResult; use typst_library::foundations::{Packed, StyleChain, SymbolElem}; -use typst_library::layout::{Abs, Axis, Corner, Frame, Point, Rel, Size}; +use typst_library::layout::{Abs, Axis, Corner, Frame, Point, Size}; use typst_library::math::{ AttachElem, EquationElem, LimitsElem, PrimesElem, ScriptsElem, StretchElem, + StretchSize, }; use typst_utils::OptionExt; @@ -66,12 +67,12 @@ pub fn layout_attach( let relative_to_width = measure!(t, width).max(measure!(b, width)); stretch_fragment( ctx, + styles, &mut base, Some(Axis::X), Some(relative_to_width), - stretch, - Abs::zero(), - ); + &stretch, + )?; } let fragments = [ @@ -154,7 +155,7 @@ pub fn layout_limits( } /// Get the size to stretch the base to. -fn stretch_size(styles: StyleChain, elem: &Packed) -> Option> { +fn stretch_size(styles: StyleChain, elem: &Packed) -> Option { // Extract from an EquationElem. let mut base = &elem.base; while let Some(equation) = base.to_packed::() { @@ -162,7 +163,7 @@ fn stretch_size(styles: StyleChain, elem: &Packed) -> Option() - .map(|stretch| stretch.size.resolve(styles)) + .map(|stretch| stretch.size.get_cloned(styles)) } /// Lay out the attachments. diff --git a/crates/typst-layout/src/math/frac.rs b/crates/typst-layout/src/math/frac.rs index 12a2c6fd1..beb811b03 100644 --- a/crates/typst-layout/src/math/frac.rs +++ b/crates/typst-layout/src/math/frac.rs @@ -1,14 +1,13 @@ use typst_library::diag::SourceResult; use typst_library::foundations::{Content, Packed, Resolve, StyleChain, SymbolElem}; use typst_library::layout::{Em, Frame, FrameItem, Point, Size}; -use typst_library::math::{BinomElem, FracElem}; +use typst_library::math::{BinomElem, FracElem, DELIM_SHORT_FALL}; use typst_library::text::TextElem; use typst_library::visualize::{FixedStroke, Geometry}; use typst_syntax::Span; use super::{ - style_for_denominator, style_for_numerator, FrameFragment, GlyphFragment, - MathContext, DELIM_SHORT_FALL, + style_for_denominator, style_for_numerator, FrameFragment, GlyphFragment, MathContext, }; const FRAC_AROUND: Em = Em::new(0.1); @@ -49,7 +48,7 @@ fn layout_frac_like( binom: bool, span: Span, ) -> SourceResult<()> { - let short_fall = DELIM_SHORT_FALL.resolve(styles); + let short_fall = DELIM_SHORT_FALL.abs().resolve(styles); let axis = scaled!(ctx, styles, axis_height); let thickness = scaled!(ctx, styles, fraction_rule_thickness); let shift_up = scaled!( diff --git a/crates/typst-layout/src/math/lr.rs b/crates/typst-layout/src/math/lr.rs index 2348025e8..cdb44899f 100644 --- a/crates/typst-layout/src/math/lr.rs +++ b/crates/typst-layout/src/math/lr.rs @@ -1,11 +1,11 @@ use typst_library::diag::SourceResult; use typst_library::foundations::{Packed, StyleChain}; -use typst_library::layout::{Abs, Axis, Rel}; -use typst_library::math::{EquationElem, LrElem, MidElem}; +use typst_library::layout::{Abs, Axis}; +use typst_library::math::{EquationElem, LrElem, MidElem, StretchSize}; use typst_utils::SliceExt; use unicode_math_class::MathClass; -use super::{stretch_fragment, MathContext, MathFragment, DELIM_SHORT_FALL}; +use super::{stretch_fragment, MathContext, MathFragment}; /// Lays out an [`LrElem`]. #[typst_macros::time(name = "math.lr", span = elem.span())] @@ -22,7 +22,7 @@ pub fn layout_lr( // Extract implicit LrElem. if let Some(lr) = body.to_packed::() { - if lr.size.get(styles).is_one() { + if lr.size.get_ref(styles).is_lr_default() { body = &lr.body; } } @@ -41,14 +41,28 @@ pub fn layout_lr( .unwrap_or_default(); let relative_to = 2.0 * max_extent; - let height = elem.size.resolve(styles); + let height = elem.size.get_ref(styles); // Scale up fragments at both ends. match inner_fragments { - [one] => scale_if_delimiter(ctx, one, relative_to, height, None), + [one] => scale_if_delimiter(ctx, styles, one, relative_to, height, None)?, [first, .., last] => { - scale_if_delimiter(ctx, first, relative_to, height, Some(MathClass::Opening)); - scale_if_delimiter(ctx, last, relative_to, height, Some(MathClass::Closing)); + scale_if_delimiter( + ctx, + styles, + first, + relative_to, + height, + Some(MathClass::Opening), + )?; + scale_if_delimiter( + ctx, + styles, + last, + relative_to, + height, + Some(MathClass::Closing), + )?; } [] => {} } @@ -58,7 +72,7 @@ pub fn layout_lr( if let MathFragment::Glyph(ref mut glyph) = fragment { if glyph.mid_stretched == Some(false) { glyph.mid_stretched = Some(true); - scale(ctx, fragment, relative_to, height); + scale(ctx, styles, fragment, relative_to, height)?; } } } @@ -112,32 +126,32 @@ pub fn layout_mid( /// it is a delimiter, in a way that cannot be overridden by the user. fn scale_if_delimiter( ctx: &mut MathContext, + styles: StyleChain, fragment: &mut MathFragment, relative_to: Abs, - height: Rel, + height: &StretchSize, apply: Option, -) { +) -> SourceResult<()> { if matches!( fragment.class(), MathClass::Opening | MathClass::Closing | MathClass::Fence ) { - scale(ctx, fragment, relative_to, height); + scale(ctx, styles, fragment, relative_to, height)?; if let Some(class) = apply { fragment.set_class(class); } } + Ok(()) } /// Scales a math fragment to a height. fn scale( ctx: &mut MathContext, + styles: StyleChain, fragment: &mut MathFragment, relative_to: Abs, - height: Rel, -) { - // This unwrap doesn't really matter. If it is None, then the fragment - // won't be stretchable anyways. - let short_fall = DELIM_SHORT_FALL.at(fragment.font_size().unwrap_or_default()); - stretch_fragment(ctx, fragment, Some(Axis::Y), Some(relative_to), height, short_fall); + height: &StretchSize, +) -> SourceResult<()> { + stretch_fragment(ctx, styles, fragment, Some(Axis::Y), Some(relative_to), height) } diff --git a/crates/typst-layout/src/math/mat.rs b/crates/typst-layout/src/math/mat.rs index 4a897a03e..249913999 100644 --- a/crates/typst-layout/src/math/mat.rs +++ b/crates/typst-layout/src/math/mat.rs @@ -1,19 +1,20 @@ use typst_library::diag::{bail, warning, SourceResult}; use typst_library::foundations::{Content, Packed, Resolve, StyleChain}; use typst_library::layout::{ - Abs, Axes, Em, FixedAlignment, Frame, FrameItem, Point, Ratio, Rel, Size, + Abs, Axes, Em, FixedAlignment, Frame, FrameItem, Point, Rel, Size, +}; +use typst_library::math::{ + Augment, AugmentOffsets, CasesElem, MatElem, StretchSize, VecElem, }; -use typst_library::math::{Augment, AugmentOffsets, CasesElem, MatElem, VecElem}; use typst_library::text::TextElem; use typst_library::visualize::{FillRule, FixedStroke, Geometry, LineCap, Shape}; use typst_syntax::Span; use super::{ alignments, style_for_denominator, AlignmentResult, FrameFragment, GlyphFragment, - LeftRightAlternator, MathContext, DELIM_SHORT_FALL, + LeftRightAlternator, MathContext, }; -const VERTICAL_PADDING: Ratio = Ratio::new(0.1); const DEFAULT_STROKE_THICKNESS: Em = Em::new(0.05); /// Lays out a [`VecElem`]. @@ -39,7 +40,15 @@ pub fn layout_vec( )?; let delim = elem.delim.get(styles); - layout_delimiters(ctx, styles, frame, delim.open(), delim.close(), span) + layout_delimiters( + ctx, + styles, + frame, + elem.delim_size.get_ref(styles), + delim.open(), + delim.close(), + span, + ) } /// Lays out a [`CasesElem`]. @@ -70,7 +79,15 @@ pub fn layout_cases( } else { (delim.open(), None) }; - layout_delimiters(ctx, styles, frame, open, close, span) + layout_delimiters( + ctx, + styles, + frame, + elem.delim_size.get_ref(styles), + open, + close, + span, + ) } /// Lays out a [`MatElem`]. @@ -128,7 +145,15 @@ pub fn layout_mat( )?; let delim = elem.delim.get(styles); - layout_delimiters(ctx, styles, frame, delim.open(), delim.close(), span) + layout_delimiters( + ctx, + styles, + frame, + elem.delim_size.get_ref(styles), + delim.open(), + delim.close(), + span, + ) } /// Layout the inner contents of a matrix, vector, or cases. @@ -309,19 +334,20 @@ fn layout_delimiters( ctx: &mut MathContext, styles: StyleChain, mut frame: Frame, + size: &StretchSize, left: Option, right: Option, span: Span, ) -> SourceResult<()> { - let short_fall = DELIM_SHORT_FALL.resolve(styles); let axis = scaled!(ctx, styles, axis_height); let height = frame.height(); - let target = height + VERTICAL_PADDING.of(height); frame.set_baseline(height / 2.0 + axis); + let target = size.resolve(ctx.engine, styles, height)?; + if let Some(left_c) = left { let mut left = GlyphFragment::new_char(ctx.font, styles, left_c, span)?; - left.stretch_vertical(ctx, target - short_fall); + left.stretch_vertical(ctx, target); left.center_on_axis(); ctx.push(left); } @@ -330,7 +356,7 @@ fn layout_delimiters( if let Some(right_c) = right { let mut right = GlyphFragment::new_char(ctx.font, styles, right_c, span)?; - right.stretch_vertical(ctx, target - short_fall); + right.stretch_vertical(ctx, target); right.center_on_axis(); ctx.push(right); } diff --git a/crates/typst-layout/src/math/shared.rs b/crates/typst-layout/src/math/shared.rs index c9d20aa68..bd088f7df 100644 --- a/crates/typst-layout/src/math/shared.rs +++ b/crates/typst-layout/src/math/shared.rs @@ -1,7 +1,7 @@ use ttf_parser::math::MathValue; use ttf_parser::Tag; use typst_library::foundations::{Style, StyleChain}; -use typst_library::layout::{Abs, Em, FixedAlignment, Frame, Point, Size}; +use typst_library::layout::{Abs, FixedAlignment, Frame, Point, Size}; use typst_library::math::{EquationElem, MathSize}; use typst_library::text::{FontFeatures, TextElem}; use typst_utils::LazyHash; @@ -30,9 +30,6 @@ macro_rules! percent { }; } -/// How much less high scaled delimiters can be than what they wrap. -pub const DELIM_SHORT_FALL: Em = Em::new(0.1); - /// Converts some unit to an absolute length with the current font & font size. pub trait Scaled { fn scaled(self, ctx: &MathContext, font_size: Abs) -> Abs; diff --git a/crates/typst-layout/src/math/stretch.rs b/crates/typst-layout/src/math/stretch.rs index f1a22a814..2af491812 100644 --- a/crates/typst-layout/src/math/stretch.rs +++ b/crates/typst-layout/src/math/stretch.rs @@ -1,7 +1,7 @@ use typst_library::diag::{warning, SourceResult}; use typst_library::foundations::{Packed, StyleChain}; -use typst_library::layout::{Abs, Axis, Rel}; -use typst_library::math::StretchElem; +use typst_library::layout::{Abs, Axis}; +use typst_library::math::{StretchElem, StretchSize}; use typst_utils::Get; use super::{stretch_axes, MathContext, MathFragment}; @@ -14,14 +14,7 @@ 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.resolve(styles), - Abs::zero(), - ); + stretch_fragment(ctx, styles, &mut fragment, None, None, elem.size.get_ref(styles))?; ctx.push(fragment); Ok(()) } @@ -29,29 +22,29 @@ pub fn layout_stretch( /// Attempts to stretch the given fragment by/to the amount given in stretch. pub fn stretch_fragment( ctx: &mut MathContext, + styles: StyleChain, fragment: &mut MathFragment, axis: Option, relative_to: Option, - stretch: Rel, - short_fall: Abs, -) { + stretch: &StretchSize, +) -> SourceResult<()> { let size = fragment.size(); - let MathFragment::Glyph(ref mut glyph) = fragment else { return }; + let MathFragment::Glyph(ref mut glyph) = fragment else { return Ok(()) }; // Return if we attempt to stretch along an axis which isn't stretchable, // so that the original fragment isn't modified. let axes = stretch_axes(&glyph.item.font, glyph.base_glyph.id); let stretch_axis = if let Some(axis) = axis { if !axes.get(axis) { - return; + return Ok(()); } axis } else { match (axes.x, axes.y) { (true, false) => Axis::X, (false, true) => Axis::Y, - (false, false) => return, + (false, false) => return Ok(()), (true, true) => { // As far as we know, there aren't any glyphs that have both // vertical and horizontal constructions. So for the time being, we @@ -62,16 +55,19 @@ pub fn stretch_fragment( hint: "this is probably a font bug"; hint: "please file an issue at https://github.com/typst/typst/issues" )); - return; + return Ok(()); } } }; let relative_to_size = relative_to.unwrap_or_else(|| size.get(stretch_axis)); + let target = stretch.resolve(ctx.engine, styles, relative_to_size)?; - glyph.stretch(ctx, stretch.relative_to(relative_to_size) - short_fall, stretch_axis); + glyph.stretch(ctx, target, stretch_axis); if stretch_axis == Axis::Y { glyph.center_on_axis(); } + + Ok(()) } diff --git a/crates/typst-library/src/math/accent.rs b/crates/typst-library/src/math/accent.rs index 5a9c47aea..2921c95ac 100644 --- a/crates/typst-library/src/math/accent.rs +++ b/crates/typst-library/src/math/accent.rs @@ -6,9 +6,21 @@ use icu_provider::AsDeserializingBufferProvider; use icu_provider_blob::BlobDataProvider; use crate::diag::bail; -use crate::foundations::{cast, elem, func, Content, NativeElement, SymbolElem}; -use crate::layout::{Length, Rel}; -use crate::math::Mathy; +use crate::foundations::{ + cast, elem, func, Content, NativeElement, NativeFunc, SymbolElem, +}; +use crate::layout::{Em, Length, Ratio, Rel}; +use crate::math::{Mathy, StretchSize}; + +const ACCENT_SHORT_FALL: Em = Em::new(-0.5); + +#[func(name = "x => x - 0.5em")] +const fn default_accent_size(base: Length) -> Rel { + Rel { + rel: Ratio::zero(), + abs: Length { abs: base.abs, em: ACCENT_SHORT_FALL }, + } +} /// Attaches an accent to a base. /// @@ -59,11 +71,14 @@ pub struct AccentElem { /// The size of the accent, relative to the width of the base. /// + /// See the [stretch documentation]($math.stretch.size) for more + /// information on sizes. + /// /// ```example /// $dash(A, size: #150%)$ /// ``` - #[default(Rel::one())] - pub size: Rel, + #[default(::data().into())] + pub size: StretchSize, /// Whether to remove the dot on top of lowercase i and j when adding a top /// accent. @@ -140,8 +155,11 @@ macro_rules! accents { /// The base to which the accent is applied. base: Content, /// The size of the accent, relative to the width of the base. + /// + /// See the [stretch documentation]($math.stretch.size) for + /// more information on sizes. #[named] - size: Option>, + size: Option, /// Whether to remove the dot on top of lowercase i and j when /// adding a top accent. #[named] diff --git a/crates/typst-library/src/math/attach.rs b/crates/typst-library/src/math/attach.rs index 0dda1d33d..95b8ecbcf 100644 --- a/crates/typst-library/src/math/attach.rs +++ b/crates/typst-library/src/math/attach.rs @@ -1,5 +1,4 @@ use crate::foundations::{elem, Content, Packed}; -use crate::layout::{Length, Rel}; use crate::math::{EquationElem, Mathy}; /// A base with optional attachments. @@ -128,30 +127,3 @@ pub struct LimitsElem { #[default(true)] pub inline: bool, } - -/// Stretches a glyph. -/// -/// This function can also be used to automatically stretch the base of an -/// attachment, so that it fits the top and bottom attachments. -/// -/// Note that only some glyphs can be stretched, and which ones can depend on -/// the math font being used. However, most math fonts are the same in this -/// regard. -/// -/// ```example -/// $ H stretch(=)^"define" U + p V $ -/// $ f : X stretch(->>, size: #150%)_"surjective" Y $ -/// $ x stretch(harpoons.ltrb, size: #3em) y -/// stretch(\[, size: #150%) z $ -/// ``` -#[elem(Mathy)] -pub struct StretchElem { - /// The glyph to stretch. - #[required] - pub body: Content, - - /// The size to stretch to, relative to the maximum size of the glyph and - /// its attachments. - #[default(Rel::one())] - pub size: Rel, -} diff --git a/crates/typst-library/src/math/lr.rs b/crates/typst-library/src/math/lr.rs index 5f5cb8616..d9f7c80ee 100644 --- a/crates/typst-library/src/math/lr.rs +++ b/crates/typst-library/src/math/lr.rs @@ -1,6 +1,16 @@ -use crate::foundations::{elem, func, Content, NativeElement, SymbolElem}; -use crate::layout::{Length, Rel}; -use crate::math::Mathy; +use crate::foundations::{elem, func, Content, NativeElement, NativeFunc, SymbolElem}; +use crate::layout::{Em, Length, Ratio, Rel}; +use crate::math::{Mathy, StretchSize}; + +pub const DELIM_SHORT_FALL: Em = Em::new(-0.1); + +#[func(name = "x => x - 0.1em")] +pub const fn default_lr_size(base: Length) -> Rel { + Rel { + rel: Ratio::zero(), + abs: Length { abs: base.abs, em: DELIM_SHORT_FALL }, + } +} /// Scales delimiters. /// @@ -8,9 +18,13 @@ use crate::math::Mathy; /// unmatched delimiters and to control the delimiter scaling more precisely. #[elem(title = "Left/Right", Mathy)] pub struct LrElem { - /// The size of the brackets, relative to the height of the wrapped content. - #[default(Rel::one())] - pub size: Rel, + /// The size of the delimiters, relative to the height of the wrapped + /// content. + /// + /// See the [stretch documentation]($math.stretch.size) for more + /// information on sizes. + #[default(::data().into())] + pub size: StretchSize, /// The delimited content, including the delimiters. #[required] @@ -42,9 +56,13 @@ pub struct MidElem { /// ``` #[func] pub fn floor( - /// The size of the brackets, relative to the height of the wrapped content. + /// The size of the delimiters, relative to the height of the wrapped + /// content. + /// + /// See the [stretch documentation]($math.stretch.size) for more + /// information on sizes. #[named] - size: Option>, + size: Option, /// The expression to floor. body: Content, ) -> Content { @@ -58,9 +76,13 @@ pub fn floor( /// ``` #[func] pub fn ceil( - /// The size of the brackets, relative to the height of the wrapped content. + /// The size of the delimiters, relative to the height of the wrapped + /// content. + /// + /// See the [stretch documentation]($math.stretch.size) for more + /// information on sizes. #[named] - size: Option>, + size: Option, /// The expression to ceil. body: Content, ) -> Content { @@ -74,9 +96,13 @@ pub fn ceil( /// ``` #[func] pub fn round( - /// The size of the brackets, relative to the height of the wrapped content. + /// The size of the delimiters, relative to the height of the wrapped + /// content. + /// + /// See the [stretch documentation]($math.stretch.size) for more + /// information on sizes. #[named] - size: Option>, + size: Option, /// The expression to round. body: Content, ) -> Content { @@ -90,9 +116,13 @@ pub fn round( /// ``` #[func] pub fn abs( - /// The size of the brackets, relative to the height of the wrapped content. + /// The size of the delimiters, relative to the height of the wrapped + /// content. + /// + /// See the [stretch documentation]($math.stretch.size) for more + /// information on sizes. #[named] - size: Option>, + size: Option, /// The expression to take the absolute value of. body: Content, ) -> Content { @@ -106,9 +136,13 @@ pub fn abs( /// ``` #[func] pub fn norm( - /// The size of the brackets, relative to the height of the wrapped content. + /// The size of the delimiters, relative to the height of the wrapped + /// content. + /// + /// See the [stretch documentation]($math.stretch.size) for more + /// information on sizes. #[named] - size: Option>, + size: Option, /// The expression to take the norm of. body: Content, ) -> Content { @@ -119,7 +153,7 @@ fn delimited( body: Content, left: char, right: char, - size: Option>, + size: Option, ) -> Content { let span = body.span(); let mut elem = LrElem::new(Content::sequence([ diff --git a/crates/typst-library/src/math/matrix.rs b/crates/typst-library/src/math/matrix.rs index 2a51caefd..3eb30a662 100644 --- a/crates/typst-library/src/math/matrix.rs +++ b/crates/typst-library/src/math/matrix.rs @@ -5,15 +5,27 @@ use unicode_math_class::MathClass; use crate::diag::{bail, At, HintedStrResult, StrResult}; use crate::foundations::{ - array, cast, dict, elem, Array, Content, Dict, Fold, NoneValue, Resolve, Smart, - StyleChain, Symbol, Value, + array, cast, dict, elem, func, Array, Content, Dict, Fold, NativeFunc, NoneValue, + Resolve, Smart, StyleChain, Symbol, Value, }; -use crate::layout::{Abs, Em, HAlignment, Length, Rel}; -use crate::math::Mathy; +use crate::layout::{Abs, Em, HAlignment, Length, Ratio, Rel}; +use crate::math::{Mathy, StretchSize, DELIM_SHORT_FALL}; use crate::visualize::Stroke; const DEFAULT_ROW_GAP: Em = Em::new(0.2); const DEFAULT_COL_GAP: Em = Em::new(0.5); +const VERTICAL_PADDING: Ratio = Ratio::new(1.1); + +#[func(name = "x => x * 1.1 - 0.1em")] +const fn default_mat_size(base: Length) -> Rel { + Rel { + rel: Ratio::zero(), + abs: Length { + abs: Abs::raw(base.abs.to_raw() * VERTICAL_PADDING.get()), + em: DELIM_SHORT_FALL, + }, + } +} /// A column vector. /// @@ -40,6 +52,13 @@ pub struct VecElem { #[default(DelimiterPair::PAREN)] pub delim: DelimiterPair, + /// The size of the delimiters, relative to the elements' total height. + /// + /// See the [stretch documentation]($math.stretch.size) for more + /// information on sizes. + #[default(::data().into())] + pub delim_size: StretchSize, + /// The horizontal alignment that each element should have. /// /// ```example @@ -99,6 +118,13 @@ pub struct MatElem { #[default(DelimiterPair::PAREN)] pub delim: DelimiterPair, + /// The size of the delimiters, relative to the cells' total height. + /// + /// See the [stretch documentation]($math.stretch.size) for more + /// information on sizes. + #[default(::data().into())] + pub delim_size: StretchSize, + /// The horizontal alignment that each cell should have. /// /// ```example @@ -238,6 +264,13 @@ pub struct CasesElem { #[default(DelimiterPair::BRACE)] pub delim: DelimiterPair, + /// The size of the delimiters, relative to the branches' total height. + /// + /// See the [stretch documentation]($math.stretch.size) for more + /// information on sizes. + #[default(::data().into())] + pub delim_size: StretchSize, + /// Whether the direction of cases should be reversed. /// /// ```example diff --git a/crates/typst-library/src/math/mod.rs b/crates/typst-library/src/math/mod.rs index 3d39e2fd2..166230556 100644 --- a/crates/typst-library/src/math/mod.rs +++ b/crates/typst-library/src/math/mod.rs @@ -9,6 +9,7 @@ mod lr; mod matrix; mod op; mod root; +mod stretch; mod style; mod underover; @@ -21,6 +22,7 @@ pub use self::lr::*; pub use self::matrix::*; pub use self::op::*; pub use self::root::*; +pub use self::stretch::*; pub use self::style::*; pub use self::underover::*; diff --git a/crates/typst-library/src/math/stretch.rs b/crates/typst-library/src/math/stretch.rs new file mode 100644 index 000000000..847127d4b --- /dev/null +++ b/crates/typst-library/src/math/stretch.rs @@ -0,0 +1,125 @@ +use comemo::Track; + +use crate::diag::{At, SourceResult}; +use crate::engine::Engine; +use crate::foundations::{ + cast, elem, Content, Context, Func, NativeFunc, NativeFuncData, Resolve, StyleChain, +}; +use crate::layout::{Abs, Rel}; +use crate::math::{default_lr_size, Mathy}; + +/// Stretches a glyph. +/// +/// This function can also be used to automatically stretch the base of an +/// attachment, so that it fits the top and bottom attachments. +/// +/// Note that only some glyphs can be stretched, and which ones can depend on +/// the math font being used. However, most math fonts are the same in this +/// regard. +/// +/// ```example +/// $ H stretch(=)^"define" U + p V $ +/// $ f : X stretch(->>, size: #150%)_"surjective" Y $ +/// $ x stretch(harpoons.ltrb, size: #3em) y +/// stretch(\[, size: #150%) z $ +/// ``` +#[elem(Mathy)] +pub struct StretchElem { + /// The glyph to stretch. + #[required] + pub body: Content, + + /// The size to stretch to, relative to the maximum size of the glyph and + /// its attachments. + /// + /// This value can be given as a [relative length]($relative), or a + /// [function]($function) that receives the size of the glyph as a + /// parameter (an absolute length) and should return a (relative) length. + /// For example, `{x => x * 80%}` would be equivalent to just specifying `{80%}`. + /// + /// Note that the sizes of glyphs in math fonts come about in two ways: + /// + /// - First, there are pre-made variants at specific sizes. This means you + /// will see discrete jumps in the stretched glyph's size as you increase + /// the size parameter. It is up to the font how many pre-made variants + /// there are and what their sizes are. + /// + /// - Then, if the pre-made variants are all too small, a glyph of the + /// desired size is assembled from parts. The stretched glyph's size will + /// now be the exact size requested. + /// + /// It could be the case that only one of the above exist for a glyph in + /// the font. + /// + /// The value given here is really a minimum (but if there is no assembly + /// for the glyph, this minimum may not be reached), so the actual size of + /// the stretched glyph may not match what you specified. + /// + /// ```example + /// #for i in range(0, 15) { + /// $stretch(\[, size: #(10pt + i * 2pt))$ + /// } + /// + /// #set math.stretch(size: x => x + 0.5em) + /// $x stretch(=)^"def" y$ + /// ``` + #[default(Rel::one().into())] + pub size: StretchSize, +} + +/// How to size a stretched glyph. +#[derive(Debug, Clone, PartialEq, Hash)] +pub enum StretchSize { + /// Sized by the specified length. + Rel(Rel), + /// Resolve the size for the given base size through the specified + /// function. + Func(Func), +} + +impl StretchSize { + /// Resolve the stretch size given the base size. + pub fn resolve( + &self, + engine: &mut Engine, + styles: StyleChain, + base: Abs, + ) -> SourceResult { + Ok(match self { + Self::Rel(rel) => *rel, + Self::Func(func) => func + .call(engine, Context::new(None, Some(styles)).track(), [base])? + .cast() + .at(func.span())?, + } + .resolve(styles) + .relative_to(base)) + } + + /// Whether the size is the default used by `LrElem`. + pub fn is_lr_default(&self) -> bool { + *self == ::data().into() + } +} + +impl From for StretchSize { + fn from(rel: Rel) -> Self { + Self::Rel(rel) + } +} + +impl From<&'static NativeFuncData> for StretchSize { + fn from(data: &'static NativeFuncData) -> Self { + Self::Func(Func::from(data)) + } +} + +cast! { + StretchSize, + self => match self { + Self::Rel(v) => v.into_value(), + Self::Func(v) => v.into_value(), + }, + v: Rel => Self::Rel(v), + v: Func => Self::Func(v), +} diff --git a/tests/ref/math-accent-sized-function.png b/tests/ref/math-accent-sized-function.png new file mode 100644 index 000000000..9bd52a6e7 Binary files /dev/null and b/tests/ref/math-accent-sized-function.png differ diff --git a/tests/ref/math-cases-delim-size.png b/tests/ref/math-cases-delim-size.png new file mode 100644 index 000000000..92231d691 Binary files /dev/null and b/tests/ref/math-cases-delim-size.png differ diff --git a/tests/ref/math-lr-size-function.png b/tests/ref/math-lr-size-function.png new file mode 100644 index 000000000..437bed046 Binary files /dev/null and b/tests/ref/math-lr-size-function.png differ diff --git a/tests/ref/math-mat-delim-size.png b/tests/ref/math-mat-delim-size.png new file mode 100644 index 000000000..0d60d86f6 Binary files /dev/null and b/tests/ref/math-mat-delim-size.png differ diff --git a/tests/ref/math-stretch-function.png b/tests/ref/math-stretch-function.png new file mode 100644 index 000000000..8e1daa46c Binary files /dev/null and b/tests/ref/math-stretch-function.png differ diff --git a/tests/ref/math-vec-delim-size.png b/tests/ref/math-vec-delim-size.png new file mode 100644 index 000000000..03b0d2a4a Binary files /dev/null and b/tests/ref/math-vec-delim-size.png differ diff --git a/tests/suite/math/accent.typ b/tests/suite/math/accent.typ index 0aef41e20..a4e1a40d9 100644 --- a/tests/suite/math/accent.typ +++ b/tests/suite/math/accent.typ @@ -30,11 +30,17 @@ $ tilde(integral), tilde(integral)_a^b, tilde(integral_a^b) $ --- math-accent-sized --- // Test accent size. -$tilde(sum), tilde(sum, size: #50%), accent(H, hat, size: #200%)$ +$tilde(sum), tilde(sum, size: #25%), accent(H, hat, size: #125%)$ --- math-accent-sized-script --- // Test accent size in script size. -$tilde(U, size: #1.1em), x^tilde(U, size: #1.1em), sscript(tilde(U, size: #1.1em))$ +$tilde(U, size: #0.6em), x^tilde(U, size: #0.6em), sscript(tilde(U, size: #0.6em))$ + +--- math-accent-sized-function --- +// Test accent size with a function. +$dash(A) arrow(I) hat(L)$ \ +#set math.accent(size: x => x - 0.1em) +$dash(A) arrow(I) hat(L)$ --- math-accent-dotless --- // Test dotless glyph variants. @@ -85,7 +91,7 @@ $ accent(integral, \u{20EC}), accent(integral, \u{20EC})_a^b, accent(integral_a^ --- math-accent-bottom-sized --- // Test bottom accent size. -$accent(sum, \u{0330}), accent(sum, \u{0330}, size: #50%), accent(H, \u{032D}, size: #200%)$ +$accent(sum, \u{0330}), accent(sum, \u{0330}, size: #25%), accent(H, \u{032D}, size: #125%)$ --- math-accent-nested --- // Test nested top and bottom accents. diff --git a/tests/suite/math/attach.typ b/tests/suite/math/attach.typ index 979018478..a058ea425 100644 --- a/tests/suite/math/attach.typ +++ b/tests/suite/math/attach.typ @@ -187,5 +187,5 @@ $ a0 + a1 + a0_2 \ --- math-attach-scripts-extended-shapes --- // Test script attachments positioning if the base is an extended shape (or a // sequence of extended shapes). -$lr(size: #130%, [x])_0^1, [x]_0^1, \]_0^1, x_0^1, A_0^1$ \ +$lr(size: #115%, [x])_0^1, [x]_0^1, \]_0^1, x_0^1, A_0^1$ \ $n^2, (n + 1)^2, sum_0^1, integral_0^1$ diff --git a/tests/suite/math/cases.typ b/tests/suite/math/cases.typ index 306c1ae80..3765561ea 100644 --- a/tests/suite/math/cases.typ +++ b/tests/suite/math/cases.typ @@ -16,6 +16,12 @@ $ x = cases(1, 2) $ #set math.cases(delim: sym.angle.l) $ cases(a, b, c) $ +--- math-cases-delim-size --- +// Test setting delimiter size. +$ cases(reverse: #true, 1, 2, 3) cases(delim-size: #100%, 1, 2, 3) $ +#set math.cases(delim-size: x => calc.max(x - 5pt, x * 0.901)) +$ cases(1, 2) cases(1, 2, 3, 4) $ + --- math-cases-linebreaks --- // Warning: 40-49 linebreaks are ignored in branches // Hint: 40-49 use commas instead to separate each line diff --git a/tests/suite/math/delimited.typ b/tests/suite/math/delimited.typ index b8656151b..9cfbf7657 100644 --- a/tests/suite/math/delimited.typ +++ b/tests/suite/math/delimited.typ @@ -31,9 +31,14 @@ $ lr(a/b\]) = a = lr(\{a/b) $ --- math-lr-size --- // Test manual scaling. -$ lr(]sum_(x=1)^n x], size: #70%) +$ lr(]sum_(x=1)^n x], size: #60%) < lr((1, 2), size: #200%) $ +--- math-lr-size-function --- +// Test using a function as an argument to size. +#set math.lr(size: x => if x > 10pt { 1em } else { 4 * x }) +$ (a) (1/2) $ + --- math-lr-shorthands --- // Test predefined delimiter pairings. $floor(x/2), ceil(x/2), abs(x), norm(x)$ @@ -57,16 +62,16 @@ $ { x mid(|) sum_(i=1)^oo phi_i (x) < 1 } \ #set page(width: auto) $ lr({ A mid(|) integral }) quad - lr(size: #1em, { A mid(|) integral }) quad - lr(size: #(1em+20%), { A mid(|) integral }) \ + lr(size: #0%, { A mid(|) integral }) quad + lr(size: #(1em+10%), { A mid(|) integral }) \ lr(] A mid(|) integral ]) quad - lr(size: #1em, ] A mid(|) integral ]) quad - lr(size: #(1em+20%), ] A mid(|) integral ]) \ + lr(size: #0%, ] A mid(|) integral ]) quad + lr(size: #(1em+10%), ] A mid(|) integral ]) \ lr(( A mid(|) integral ]) quad - lr(size: #1em, ( A mid(|) integral ]) quad - lr(size: #(1em+20%), ( A mid(|) integral ]) $ + lr(size: #0%, ( A mid(|) integral ]) quad + lr(size: #(1em+10%), ( A mid(|) integral ]) $ --- math-lr-mid-size-nested-equation --- // Test mid size when lr size is set, when nested in an equation. @@ -74,8 +79,8 @@ $ lr({ A mid(|) integral }) quad #let body = ${ A mid(|) integral }$ $ lr(body) quad - lr(size: #1em, body) quad - lr(size: #(1em+20%), body) $ + lr(size: #0%, body) quad + lr(size: #(1em+10%), body) $ --- math-lr-mid-class --- // Test that `mid` creates a Relation, but that can be overridden. diff --git a/tests/suite/math/mat.typ b/tests/suite/math/mat.typ index 80f190605..cde0eae98 100644 --- a/tests/suite/math/mat.typ +++ b/tests/suite/math/mat.typ @@ -54,6 +54,12 @@ $ a + mat(delim: #none, 1, 2; 3, 4) + b $ $ mat(1, 2; 3, 4; delim: "[") $, ) +--- math-mat-delim-size --- +// Test setting delimiter size. +$ mat(c; c; c) mat(delim-size: #100%, c; c; c) $ +#set math.mat(delim-size: x => calc.max(x - 5pt, x * 0.901)) +$ mat(delim: "[", f; f; f; f) mat(delim: ||, x; x; x; x) $ + --- math-mat-spread --- // Test argument spreading in matrix. $ mat(..#range(1, 5).chunks(2)) @@ -263,7 +269,7 @@ $ mat(a; b; c) mat(a \ b \ c) $ --- math-mat-vec-cases-unity --- // Test that matrices, vectors, and cases are all laid out the same. $ mat(z_(n_p); a^2) - vec(z_(n_p), a^2) + vec(z_(n_p), a^2) cases(reverse: #true, delim: \(, z_(n_p), a^2) cases(delim: \(, z_(n_p), a^2) $ diff --git a/tests/suite/math/stretch.typ b/tests/suite/math/stretch.typ index d145f72a1..f5ee05af6 100644 --- a/tests/suite/math/stretch.typ +++ b/tests/suite/math/stretch.typ @@ -91,3 +91,9 @@ $ body^"text" $ } $body^"long text"$ } + +--- math-stretch-function --- +// Test using a function as an argument to size. +$stretch(<-, size: #(x => x - 0.5em))_"function"$ +#set math.stretch(size: x => x + 0.5em) +$stretch(|) |$ diff --git a/tests/suite/math/vec.typ b/tests/suite/math/vec.typ index e5ee409ec..e976ca645 100644 --- a/tests/suite/math/vec.typ +++ b/tests/suite/math/vec.typ @@ -50,6 +50,12 @@ $ vec(1, 2) $ // Error: 22-33 invalid delimiter: "%" #set math.vec(delim: (none, "%")) +--- math-vec-delim-size --- +// Test setting delimiter size. +$ vec(1, 2, 3) vec(delim-size: #100%, 1, 2, 3) $ +#set math.vec(delim-size: x => calc.max(x - 5pt, x * 0.901)) +$ vec(delim: "{", 1, 2, 3) vec(delim: "[", 1, 2, 3) $ + --- math-vec-linebreaks --- // Warning: 20-29 linebreaks are ignored in elements // Hint: 20-29 use commas instead to separate each line