diff --git a/crates/typst-layout/src/inline/collect.rs b/crates/typst-layout/src/inline/collect.rs index 5a1b7b4fc..829f64b66 100644 --- a/crates/typst-layout/src/inline/collect.rs +++ b/crates/typst-layout/src/inline/collect.rs @@ -206,7 +206,7 @@ pub fn collect<'a>( } InlineItem::Frame(mut frame) => { frame.modify(&FrameModifiers::get_in(styles)); - apply_baseline_shift(&mut frame, styles); + apply_shift(&engine.world, &mut frame, styles); collector.push_item(Item::Frame(frame)); } } @@ -221,7 +221,7 @@ pub fn collect<'a>( let mut frame = layout_and_modify(styles, |styles| { layout_box(elem, engine, loc, styles, region) })?; - apply_baseline_shift(&mut frame, styles); + apply_shift(&engine.world, &mut frame, styles); collector.push_item(Item::Frame(frame)); } } else if let Some(elem) = child.to_packed::() { diff --git a/crates/typst-layout/src/inline/line.rs b/crates/typst-layout/src/inline/line.rs index 659d33f4a..3782f7034 100644 --- a/crates/typst-layout/src/inline/line.rs +++ b/crates/typst-layout/src/inline/line.rs @@ -5,7 +5,7 @@ use typst_library::engine::Engine; use typst_library::introspection::{SplitLocator, Tag}; use typst_library::layout::{Abs, Dir, Em, Fr, Frame, FrameItem, Point}; use typst_library::model::ParLineMarker; -use typst_library::text::{Lang, TextElem}; +use typst_library::text::{variant, Lang, TextElem}; use typst_utils::Numeric; use super::*; @@ -412,9 +412,30 @@ fn should_repeat_hyphen(pred_line: &Line, text: &str) -> bool { } } -/// Apply the current baseline shift to a frame. -pub fn apply_baseline_shift(frame: &mut Frame, styles: StyleChain) { - frame.translate(Point::with_y(TextElem::baseline_in(styles))); +/// Apply the current baseline shift and italic compensation to a frame. +pub fn apply_shift<'a>( + world: &Tracked<'a, dyn World + 'a>, + frame: &mut Frame, + styles: StyleChain, +) { + let mut baseline = TextElem::baseline_in(styles); + let mut compensation = Abs::zero(); + if let Some(scripts) = TextElem::subperscript_in(styles) { + let font_metrics = TextElem::font_in(styles) + .into_iter() + .find_map(|family| { + world + .book() + .select(family.as_str(), variant(styles)) + .and_then(|id| world.font(id)) + }) + .map_or(scripts.kind.default_metrics(), |f| { + scripts.kind.read_metrics(f.metrics()) + }); + baseline -= scripts.shift.unwrap_or(font_metrics.vertical_offset).resolve(styles); + compensation += font_metrics.horizontal_offset.resolve(styles); + } + frame.translate(Point::new(compensation, baseline)); } /// Commit to a line and build its frame. @@ -519,7 +540,7 @@ pub fn commit( let mut frame = layout_and_modify(*styles, |styles| { layout_box(elem, engine, loc.relayout(), styles, region) })?; - apply_baseline_shift(&mut frame, *styles); + apply_shift(&engine.world, &mut frame, *styles); push(&mut offset, frame); } else { offset += amount; diff --git a/crates/typst-layout/src/inline/mod.rs b/crates/typst-layout/src/inline/mod.rs index 5ef820d07..f5033b170 100644 --- a/crates/typst-layout/src/inline/mod.rs +++ b/crates/typst-layout/src/inline/mod.rs @@ -28,7 +28,7 @@ use typst_utils::{Numeric, SliceExt}; use self::collect::{collect, Item, Segment, SpanMapper}; use self::deco::decorate; use self::finalize::finalize; -use self::line::{apply_baseline_shift, commit, line, Line}; +use self::line::{apply_shift, commit, line, Line}; use self::linebreak::{linebreak, Breakpoint}; use self::prepare::{prepare, Preparation}; use self::shaping::{ diff --git a/crates/typst-layout/src/inline/shaping.rs b/crates/typst-layout/src/inline/shaping.rs index 8236d1e36..7f16bbd0d 100644 --- a/crates/typst-layout/src/inline/shaping.rs +++ b/crates/typst-layout/src/inline/shaping.rs @@ -5,14 +5,15 @@ use std::sync::Arc; use az::SaturatingAs; use ecow::EcoString; -use rustybuzz::{BufferFlags, ShapePlan, UnicodeBuffer}; +use rustybuzz::{BufferFlags, Feature, ShapePlan, UnicodeBuffer}; +use ttf_parser::gsub::SubstitutionSubtable; use ttf_parser::Tag; use typst_library::engine::Engine; use typst_library::foundations::{Smart, StyleChain}; use typst_library::layout::{Abs, Dir, Em, Frame, FrameItem, Point, Size}; use typst_library::text::{ families, features, is_default_ignorable, variant, Font, FontFamily, FontVariant, - Glyph, Lang, Region, TextEdgeBounds, TextElem, TextItem, + Glyph, Lang, Region, ScriptSettings, TextEdgeBounds, TextElem, TextItem, }; use typst_library::World; use typst_utils::SliceExt; @@ -64,6 +65,8 @@ pub struct ShapedGlyph { pub x_offset: Em, /// The vertical offset of the glyph. pub y_offset: Em, + /// How much to scale the glyph compared to its normal size. + pub scale: Em, /// The adjustability of the glyph. pub adjustability: Adjustability, /// The byte range of this glyph's cluster in the full inline layout. A @@ -230,8 +233,10 @@ impl<'a> ShapedText<'a> { let stroke = TextElem::stroke_in(self.styles); let span_offset = TextElem::span_offset_in(self.styles); - for ((font, y_offset), group) in - self.glyphs.as_ref().group_by_key(|g| (g.font.clone(), g.y_offset)) + for ((font, y_offset, scale), group) in self + .glyphs + .as_ref() + .group_by_key(|g| (g.font.clone(), g.y_offset, g.scale)) { let mut range = group[0].range.clone(); for glyph in group { @@ -304,7 +309,7 @@ impl<'a> ShapedText<'a> { let item = TextItem { font, - size: self.size, + size: scale.at(self.size), lang: self.lang, region: self.region, fill: fill.clone(), @@ -420,7 +425,7 @@ impl<'a> ShapedText<'a> { styles: self.styles, size: self.size, variant: self.variant, - width: glyphs.iter().map(|g| g.x_advance).sum::().at(self.size), + width: glyphs_width(glyphs).at(self.size), glyphs: Cow::Borrowed(glyphs), } } else { @@ -491,6 +496,7 @@ impl<'a> ShapedText<'a> { x_advance, x_offset: Em::zero(), y_offset: Em::zero(), + scale: Em::one(), adjustability: Adjustability::default(), range, safe_to_break: true, @@ -666,6 +672,7 @@ fn shape<'a>( region: Option, ) -> ShapedText<'a> { let size = TextElem::size_in(styles); + let script_settings = TextElem::subperscript_in(styles); let mut ctx = ShapingContext { engine, size, @@ -679,7 +686,7 @@ fn shape<'a>( }; if !text.is_empty() { - shape_segment(&mut ctx, base, text, families(styles)); + shape_segment(&mut ctx, base, text, families(styles), script_settings); } track_and_space(&mut ctx); @@ -699,11 +706,17 @@ fn shape<'a>( styles, variant: ctx.variant, size, - width: ctx.glyphs.iter().map(|g| g.x_advance).sum::().at(size), + width: glyphs_width(&ctx.glyphs).at(size), glyphs: Cow::Owned(ctx.glyphs), } } +/// Computes the width of a run of glyphs relative to the font size, accounting +/// for their individual scaling factors and other font metrics. +fn glyphs_width(glyphs: &[ShapedGlyph]) -> Em { + glyphs.iter().map(|g| g.x_advance * g.scale.get()).sum() +} + /// Holds shaping results and metadata common to all shaped segments. struct ShapingContext<'a, 'v> { engine: &'a Engine<'v>, @@ -723,6 +736,7 @@ fn shape_segment<'a>( base: usize, text: &str, mut families: impl Iterator + Clone, + script_settings: Option, ) { // Don't try shaping newlines, tabs, or default ignorables. if text @@ -789,6 +803,52 @@ fn shape_segment<'a>( // text extraction. buffer.set_flags(BufferFlags::REMOVE_DEFAULT_IGNORABLES); + // Those values determine how the rendered text should be transformed to + // display sub-/super-scripts properly. If the text is not scripted, or if + // the OpenType feature can be used, the rendered text should not be + // transformed in any way, and so those values are neutral (`(0, 0, 1)`). If + // scripts should be synthesized, those values determine how to transform + // the rendered text to display scripts as expected. + let (script_shift, script_compensation, scale) = match script_settings { + None => (Em::zero(), Em::zero(), Em::one()), + Some(settings) => settings + .typographic + .then(|| { + // If typographic scripts are enabled (i.e., we want to use the + // OpenType feature instead of synthesizing if possible), we add + // "subs"/"sups" to the feature list if supported by the font. + // In case of a problem, we just early exit + let gsub = font.rusty().tables().gsub?; + let subtable_index = + gsub.features.find(settings.kind.feature())?.lookup_indices.get(0)?; + let coverage = gsub + .lookups + .get(subtable_index)? + .subtables + .get::(0)? + .coverage(); + text.chars() + .all(|c| { + font.rusty().glyph_index(c).is_some_and(|i| coverage.contains(i)) + }) + .then(|| { + ctx.features.push(Feature::new(settings.kind.feature(), 1, ..)); + (Em::zero(), Em::zero(), Em::one()) + }) + }) + // Reunite the cases where `typographic` is `false` or where using + // the OpenType feature would not work. + .flatten() + .unwrap_or_else(|| { + let script_metrics = settings.kind.read_metrics(font.metrics()); + ( + settings.shift.unwrap_or(script_metrics.vertical_offset), + script_metrics.horizontal_offset, + settings.size.unwrap_or(script_metrics.height), + ) + }), + }; + // Prepare the shape plan. This plan depends on direction, script, language, // and features, but is independent from the text and can thus be memoized. let plan = create_shape_plan( @@ -869,8 +929,9 @@ fn shape_segment<'a>( glyph_id: info.glyph_id as u16, // TODO: Don't ignore y_advance. x_advance, - x_offset: font.to_em(pos[i].x_offset), - y_offset: font.to_em(pos[i].y_offset), + x_offset: font.to_em(pos[i].x_offset) + script_compensation, + y_offset: font.to_em(pos[i].y_offset) + script_shift, + scale, adjustability: Adjustability::default(), range: start..end, safe_to_break: !info.unsafe_to_break(), @@ -923,7 +984,13 @@ fn shape_segment<'a>( } // Recursively shape the tofu sequence with the next family. - shape_segment(ctx, base + start, &text[start..end], families.clone()); + shape_segment( + ctx, + base + start, + &text[start..end], + families.clone(), + script_settings, + ); } i += 1; @@ -963,6 +1030,7 @@ fn shape_tofus(ctx: &mut ShapingContext, base: usize, text: &str, font: Font) { x_advance, x_offset: Em::zero(), y_offset: Em::zero(), + scale: Em::one(), adjustability: Adjustability::default(), range: start..end, safe_to_break: true, diff --git a/crates/typst-library/src/layout/length.rs b/crates/typst-library/src/layout/length.rs index 800140c47..15a5e7b55 100644 --- a/crates/typst-library/src/layout/length.rs +++ b/crates/typst-library/src/layout/length.rs @@ -91,6 +91,10 @@ impl Length { hint: "or use `length.abs.{unit}()` instead to ignore its em component" ) } + + pub fn to_em(&self, text_size: Abs) -> Em { + self.em + Em::new(self.abs / text_size) + } } #[scope] diff --git a/crates/typst-library/src/text/font/mod.rs b/crates/typst-library/src/text/font/mod.rs index afa92e778..84ddc3fc7 100644 --- a/crates/typst-library/src/text/font/mod.rs +++ b/crates/typst-library/src/text/font/mod.rs @@ -215,6 +215,10 @@ pub struct FontMetrics { pub underline: LineMetrics, /// Recommended metrics for an overline. pub overline: LineMetrics, + /// Metrics for subscripts. + pub subscript: ScriptMetrics, + /// Metrics for superscripts. + pub superscript: ScriptMetrics, } impl FontMetrics { @@ -227,6 +231,7 @@ impl FontMetrics { let cap_height = ttf.capital_height().filter(|&h| h > 0).map_or(ascender, to_em); let x_height = ttf.x_height().filter(|&h| h > 0).map_or(ascender, to_em); let descender = to_em(ttf.typographic_descender().unwrap_or(ttf.descender())); + let strikeout = ttf.strikeout_metrics(); let underline = ttf.underline_metrics(); @@ -249,6 +254,26 @@ impl FontMetrics { thickness: underline.thickness, }; + let subscript = match ttf.subscript_metrics() { + None => ScriptMetrics::default_subscript(), + Some(metrics) => ScriptMetrics { + width: to_em(metrics.x_size), + height: to_em(metrics.y_size), + horizontal_offset: to_em(metrics.x_offset), + vertical_offset: -to_em(metrics.y_offset), + }, + }; + + let superscript = match ttf.superscript_metrics() { + None => ScriptMetrics::default_superscript(), + Some(metrics) => ScriptMetrics { + width: to_em(metrics.x_size), + height: to_em(metrics.y_size), + horizontal_offset: to_em(metrics.x_offset), + vertical_offset: to_em(metrics.y_offset), + }, + }; + Self { units_per_em, ascender, @@ -258,6 +283,8 @@ impl FontMetrics { strikethrough, underline, overline, + superscript, + subscript, } } @@ -283,6 +310,34 @@ pub struct LineMetrics { pub thickness: Em, } +/// Metrics for subscripts or superscripts. +#[derive(Debug, Copy, Clone)] +pub struct ScriptMetrics { + pub width: Em, + pub height: Em, + pub horizontal_offset: Em, + pub vertical_offset: Em, +} + +impl ScriptMetrics { + pub const fn default_with_vertical_offset(offset: Em) -> Self { + Self { + width: Em::new(0.6), + height: Em::new(0.6), + horizontal_offset: Em::zero(), + vertical_offset: offset, + } + } + + pub const fn default_subscript() -> Self { + Self::default_with_vertical_offset(Em::new(-0.2)) + } + + pub const fn default_superscript() -> Self { + Self::default_with_vertical_offset(Em::new(0.5)) + } +} + /// Identifies a vertical metric of a font. #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash, Cast)] pub enum VerticalFontMetric { diff --git a/crates/typst-library/src/text/mod.rs b/crates/typst-library/src/text/mod.rs index 462d16060..3eada5a76 100644 --- a/crates/typst-library/src/text/mod.rs +++ b/crates/typst-library/src/text/mod.rs @@ -752,6 +752,11 @@ pub struct TextElem { #[internal] #[ghost] pub smallcaps: Option, + + /// Whether subscripts or superscripts are enabled. + #[internal] + #[ghost] + pub subperscript: Option, } impl TextElem { diff --git a/crates/typst-library/src/text/shift.rs b/crates/typst-library/src/text/shift.rs index dbf1be8a1..fc85777d8 100644 --- a/crates/typst-library/src/text/shift.rs +++ b/crates/typst-library/src/text/shift.rs @@ -1,11 +1,10 @@ -use ecow::EcoString; - use crate::diag::SourceResult; use crate::engine::Engine; -use crate::foundations::{elem, Content, Packed, SequenceElem, Show, StyleChain}; +use crate::foundations::{elem, Content, Packed, Show, Smart, StyleChain}; use crate::layout::{Em, Length}; -use crate::text::{variant, SpaceElem, TextElem, TextSize}; -use crate::World; +use crate::text::{FontMetrics, TextElem, TextSize}; +use ttf_parser::Tag; +use typst_library::text::ScriptMetrics; /// Renders text in subscript. /// @@ -17,11 +16,17 @@ use crate::World; /// ``` #[elem(title = "Subscript", Show)] pub struct SubElem { - /// Whether to prefer the dedicated subscript characters of the font. + /// Whether to create artificial subscripts by shifting and scaling down + /// regular glyphs. /// - /// If this is enabled, Typst first tries to transform the text to subscript - /// codepoints. If that fails, it falls back to rendering lowered and shrunk - /// normal letters. + /// Ideally, subscripts glyphs should be provided by the font (using the + /// `subs` OpenType feature). Otherwise, Typst is able to synthesize + /// subscripts as explained above. + /// + /// When this is set to `{false}`, synthesized glyphs will be used + /// regardless of whether the font provides dedicated subscript glyphs. When + /// `{true}`, synthesized glyphs may still be used in case the font does not + /// provide the necessary subscript glyphs. /// /// ```example /// N#sub(typographic: true)[1] @@ -30,17 +35,19 @@ pub struct SubElem { #[default(true)] pub typographic: bool, - /// The baseline shift for synthetic subscripts. Does not apply if - /// `typographic` is true and the font has subscript codepoints for the - /// given `body`. - #[default(Em::new(0.2).into())] - pub baseline: Length, + /// The baseline shift for synthesized subscripts. + /// + /// This only applies to synthesized subscripts. In other words, this has no + /// effect if `typographic` is `{true}` and the font provides the necessary + /// subscript glyphs. + pub baseline: Smart, - /// The font size for synthetic subscripts. Does not apply if - /// `typographic` is true and the font has subscript codepoints for the - /// given `body`. - #[default(TextSize(Em::new(0.6).into()))] - pub size: TextSize, + /// The font size for synthesized subscripts. + /// + /// This only applies to synthesized subscripts. In other words, this has no + /// effect if `typographic` is `{true}` and the font provides the necessary + /// subscript glyphs. + pub size: Smart, /// The text to display in subscript. #[required] @@ -49,20 +56,17 @@ pub struct SubElem { impl Show for Packed { #[typst_macros::time(name = "sub", span = self.span())] - fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult { - let body = self.body.clone(); - - if self.typographic(styles) { - if let Some(text) = convert_script(&body, true) { - if is_shapable(engine, &text, styles) { - return Ok(TextElem::packed(text)); - } - } - }; - - Ok(body - .styled(TextElem::set_baseline(self.baseline(styles))) - .styled(TextElem::set_size(self.size(styles)))) + fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult { + let outer_text_size = TextElem::size_in(styles); + Ok(self + .body + .clone() + .styled(TextElem::set_subperscript(Some(ScriptSettings { + typographic: self.typographic(styles), + shift: self.baseline(styles).map(|l| -l.to_em(outer_text_size)), + size: self.size(styles).map(|t| t.0.to_em(outer_text_size)), + kind: ScriptKind::Sub, + })))) } } @@ -76,11 +80,17 @@ impl Show for Packed { /// ``` #[elem(title = "Superscript", Show)] pub struct SuperElem { - /// Whether to prefer the dedicated superscript characters of the font. + /// Whether to create artificial superscripts by shifting and scaling down + /// regular glyphs. /// - /// If this is enabled, Typst first tries to transform the text to - /// superscript codepoints. If that fails, it falls back to rendering - /// raised and shrunk normal letters. + /// Ideally, superscripts glyphs should be provided by the font (using the + /// `subs` OpenType feature). Otherwise, Typst is able to synthesize + /// superscripts as explained above. + /// + /// When this is set to `{false}`, synthesized glyphs will be used + /// regardless of whether the font provides dedicated superscript glyphs. + /// When `{true}`, synthesized glyphs may still be used in case the font + /// does not provide the necessary superscript glyphs. /// /// ```example /// N#super(typographic: true)[1] @@ -89,17 +99,19 @@ pub struct SuperElem { #[default(true)] pub typographic: bool, - /// The baseline shift for synthetic superscripts. Does not apply if - /// `typographic` is true and the font has superscript codepoints for the - /// given `body`. - #[default(Em::new(-0.5).into())] - pub baseline: Length, + /// The baseline shift for synthesized superscripts. + /// + /// This only applies to synthesized superscripts. In other words, this has + /// no effect if `typographic` is `{true}` and the font provides the + /// necessary superscript glyphs. + pub baseline: Smart, - /// The font size for synthetic superscripts. Does not apply if - /// `typographic` is true and the font has superscript codepoints for the - /// given `body`. - #[default(TextSize(Em::new(0.6).into()))] - pub size: TextSize, + /// The font size for synthesized superscripts. + /// + /// This only applies to synthesized superscripts. In other words, this has + /// no effect if `typographic` is `{true}` and the font provides the + /// necessary superscript glyphs. + pub size: Smart, /// The text to display in superscript. #[required] @@ -108,107 +120,55 @@ pub struct SuperElem { impl Show for Packed { #[typst_macros::time(name = "super", span = self.span())] - fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult { - let body = self.body.clone(); - - if self.typographic(styles) { - if let Some(text) = convert_script(&body, false) { - if is_shapable(engine, &text, styles) { - return Ok(TextElem::packed(text)); - } - } - }; - - Ok(body - .styled(TextElem::set_baseline(self.baseline(styles))) - .styled(TextElem::set_size(self.size(styles)))) + fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult { + let outer_text_size = TextElem::size_in(styles); + Ok(self + .body + .clone() + .styled(TextElem::set_subperscript(Some(ScriptSettings { + typographic: self.typographic(styles), + shift: self.baseline(styles).map(|l| -l.to_em(outer_text_size)), + size: self.size(styles).map(|t| t.0.to_em(outer_text_size)), + kind: ScriptKind::Super, + })))) } } -/// Find and transform the text contained in `content` to the given script kind -/// if and only if it only consists of `Text`, `Space`, and `Empty` leaves. -fn convert_script(content: &Content, sub: bool) -> Option { - if content.is::() { - Some(' '.into()) - } else if let Some(elem) = content.to_packed::() { - if sub { - elem.text.chars().map(to_subscript_codepoint).collect() - } else { - elem.text.chars().map(to_superscript_codepoint).collect() - } - } else if let Some(sequence) = content.to_packed::() { - sequence - .children - .iter() - .map(|item| convert_script(item, sub)) - .collect() - } else { - None - } +#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] +pub enum ScriptKind { + Sub, + Super, } -/// Checks whether the first retrievable family contains all code points of the -/// given string. -fn is_shapable(engine: &Engine, text: &str, styles: StyleChain) -> bool { - let world = engine.world; - for family in TextElem::font_in(styles) { - if let Some(font) = world - .book() - .select(family.as_str(), variant(styles)) - .and_then(|id| world.font(id)) - { - let covers = family.covers(); - return text.chars().all(|c| { - covers.is_none_or(|cov| cov.is_match(c.encode_utf8(&mut [0; 4]))) - && font.ttf().glyph_index(c).is_some() - }); +impl ScriptKind { + pub const fn default_metrics(self) -> ScriptMetrics { + match self { + Self::Sub => ScriptMetrics::default_subscript(), + Self::Super => ScriptMetrics::default_superscript(), } } - false -} + pub const fn read_metrics(self, font_metrics: &FontMetrics) -> ScriptMetrics { + match self { + Self::Sub => font_metrics.subscript, + Self::Super => font_metrics.superscript, + } + } -/// Convert a character to its corresponding Unicode superscript. -fn to_superscript_codepoint(c: char) -> Option { - match c { - '1' => Some('¹'), - '2' => Some('²'), - '3' => Some('³'), - '0' | '4'..='9' => char::from_u32(c as u32 - '0' as u32 + '⁰' as u32), - '+' => Some('⁺'), - '−' => Some('⁻'), - '=' => Some('⁼'), - '(' => Some('⁽'), - ')' => Some('⁾'), - 'n' => Some('ⁿ'), - 'i' => Some('ⁱ'), - ' ' => Some(' '), - _ => None, + /// The corresponding OpenType feature. + pub const fn feature(self) -> Tag { + match self { + Self::Sub => Tag::from_bytes(b"subs"), + Self::Super => Tag::from_bytes(b"sups"), + } } } -/// Convert a character to its corresponding Unicode subscript. -fn to_subscript_codepoint(c: char) -> Option { - match c { - '0'..='9' => char::from_u32(c as u32 - '0' as u32 + '₀' as u32), - '+' => Some('₊'), - '−' => Some('₋'), - '=' => Some('₌'), - '(' => Some('₍'), - ')' => Some('₎'), - 'a' => Some('ₐ'), - 'e' => Some('ₑ'), - 'o' => Some('ₒ'), - 'x' => Some('ₓ'), - 'h' => Some('ₕ'), - 'k' => Some('ₖ'), - 'l' => Some('ₗ'), - 'm' => Some('ₘ'), - 'n' => Some('ₙ'), - 'p' => Some('ₚ'), - 's' => Some('ₛ'), - 't' => Some('ₜ'), - ' ' => Some(' '), - _ => None, - } +#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] +pub struct ScriptSettings { + /// Whether the OpenType feature should be used if possible. + pub typographic: bool, + pub shift: Smart, + pub size: Smart, + pub kind: ScriptKind, } diff --git a/tests/ref/issue-4454-footnote-ref-numbering.png b/tests/ref/issue-4454-footnote-ref-numbering.png index a517d5fb4..c561426f6 100644 Binary files a/tests/ref/issue-4454-footnote-ref-numbering.png and b/tests/ref/issue-4454-footnote-ref-numbering.png differ diff --git a/tests/ref/long-scripts.png b/tests/ref/long-scripts.png new file mode 100644 index 000000000..84758d087 Binary files /dev/null and b/tests/ref/long-scripts.png differ diff --git a/tests/ref/scripts-with-bundeled-fonts.png b/tests/ref/scripts-with-bundeled-fonts.png new file mode 100644 index 000000000..fb99b1bd6 Binary files /dev/null and b/tests/ref/scripts-with-bundeled-fonts.png differ diff --git a/tests/ref/sub-super-italic-compensation.png b/tests/ref/sub-super-italic-compensation.png new file mode 100644 index 000000000..b6c8ad06a Binary files /dev/null and b/tests/ref/sub-super-italic-compensation.png differ diff --git a/tests/ref/sub-super-non-typographic.png b/tests/ref/sub-super-non-typographic.png index b905e7d32..68e748c54 100644 Binary files a/tests/ref/sub-super-non-typographic.png and b/tests/ref/sub-super-non-typographic.png differ diff --git a/tests/ref/sub-super-typographic.png b/tests/ref/sub-super-typographic.png new file mode 100644 index 000000000..a0c53d500 Binary files /dev/null and b/tests/ref/sub-super-typographic.png differ diff --git a/tests/ref/sub-super.png b/tests/ref/sub-super.png index 10fe77b07..803e128f8 100644 Binary files a/tests/ref/sub-super.png and b/tests/ref/sub-super.png differ diff --git a/tests/ref/super-1em.png b/tests/ref/super-1em.png new file mode 100644 index 000000000..da222a294 Binary files /dev/null and b/tests/ref/super-1em.png differ diff --git a/tests/ref/super-highlight.png b/tests/ref/super-highlight.png new file mode 100644 index 000000000..2b148f827 Binary files /dev/null and b/tests/ref/super-highlight.png differ diff --git a/tests/ref/super-underline.png b/tests/ref/super-underline.png index 4608d1a83..8564d7205 100644 Binary files a/tests/ref/super-underline.png and b/tests/ref/super-underline.png differ diff --git a/tests/suite/text/shift.typ b/tests/suite/text/shift.typ index 3b8d2ccbd..71461bdfe 100644 --- a/tests/suite/text/shift.typ +++ b/tests/suite/text/shift.typ @@ -1,19 +1,78 @@ // Test sub- and superscript shifts. --- sub-super --- +#let sq = box(square(size: 4pt)) #table( columns: 3, - [Typo.], [Fallb.], [Synth], - [x#super[1]], [x#super[5n]], [x#super[2 #box(square(size: 6pt))]], - [x#sub[1]], [x#sub[5n]], [x#sub[2 #box(square(size: 6pt))]], + [Typo.], [Fallb.], [Synth.], + [x#super[1 #sq]], [x#super[5: #sq]], [x#super(typographic: false)[2 #sq]], + [x#sub[1 #sq]], [x#sub[5: #sq]], [x#sub(typographic: false)[2 #sq]], ) +--- sub-super-typographic --- +#set text(size: 20pt) +// Libertinus Serif supports "subs" and "sups" for `typo`, but not for `synth`. +#let synth = [1,2,3] +#let typo = [123] +#let sq = [1#box(square(size: 4pt))2] +x#super(synth) x#super(typo) x#super(sq) \ +x#sub(synth) x#sub(typo) x#sub(sq) + +--- sub-super-italic-compensation --- +#set text(size: 20pt, style: "italic") +// Libertinus Serif supports "subs" and "sups" for `typo`, but not for `synth`. +#let synth = [1,2,3] +#let typo = [123] +#let sq = [1#box(square(size: 4pt))2] +x#super(synth) x#super(typo) x#super(sq) \ +x#sub(synth) x#sub(typo) x#sub(sq) + --- sub-super-non-typographic --- #set super(typographic: false, baseline: -0.25em, size: 0.7em) n#super[1], n#sub[2], ... n#super[N] --- super-underline --- #set underline(stroke: 0.5pt, offset: 0.15em) -#underline[The claim#super[\[4\]]] has been disputed. \ -The claim#super[#underline[\[4\]]] has been disputed. \ -It really has been#super(box(text(baseline: 0pt, underline[\[4\]]))) \ +#set super(typographic: false) +#underline[The claim#super[4]] has been disputed. \ +The claim#super[#underline[4]] has been disputed. \ +The claim #underline(super[4]) has been disputed. \ +#set super(typographic: true) +#underline[The claim#super[4]] has been disputed. \ +The claim#super[#underline[4]] has been disputed. \ +The claim #underline(super[4]) has been disputed. + +--- super-highlight --- +#set super(typographic: false) +#highlight[The claim#super[4]] has been disputed. \ +The claim#super[#highlight[4]] has been disputed. \ +It really has been#super(highlight[4]) \ +#set super(typographic: true) +#highlight[The claim#super[4]] has been disputed. \ +The claim#super[#highlight[4]] has been disputed. \ +It really has been#super(highlight[4]) + +--- super-1em --- +Test#super[#box(rect(height: 1em))]#box(rect(height: 1em)) + +--- long-scripts --- +|longscript| \ +|#super(typographic: true)[longscript]| \ +|#super(typographic: false)[longscript]| \ +|#sub(typographic: true)[longscript]| \ +|#sub(typographic: false)[longscript]| + +--- scripts-with-bundeled-fonts --- +#let test(font, weights, styles) = { + for weight in weights { + for style in styles { + text(font: font, weight: weight, style: style)[Xx#super[Xx]#sub[Xx]] + linebreak() + } + } +} + +#test("DejaVu Sans Mono", ("regular", "bold"), ("normal", "oblique")) +#test("Libertinus Serif", ("regular", "semibold", "bold"), ("normal", "italic")) +#test("New Computer Modern", ("regular", "bold"), ("normal", "italic")) +#test("New Computer Modern Math", (400, 450, "bold"), ("normal",))