Use "subs" and "sups" font features for typographic scripts (#5777)
@ -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::<TagElem>() {
|
||||
|
@ -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::*;
|
||||
@ -330,7 +330,7 @@ fn adjust_cj_at_line_start(p: &Preparation, items: &mut Items) {
|
||||
let glyph = shaped.glyphs.to_mut().first_mut().unwrap();
|
||||
let shrink = glyph.shrinkability().0;
|
||||
glyph.shrink_left(shrink);
|
||||
shaped.width -= shrink.at(shaped.size);
|
||||
shaped.width -= shrink.at(glyph.size);
|
||||
} else if p.config.cjk_latin_spacing
|
||||
&& glyph.is_cj_script()
|
||||
&& glyph.x_offset > Em::zero()
|
||||
@ -342,7 +342,7 @@ fn adjust_cj_at_line_start(p: &Preparation, items: &mut Items) {
|
||||
glyph.x_advance -= shrink;
|
||||
glyph.x_offset = Em::zero();
|
||||
glyph.adjustability.shrinkability.0 = Em::zero();
|
||||
shaped.width -= shrink.at(shaped.size);
|
||||
shaped.width -= shrink.at(glyph.size);
|
||||
}
|
||||
}
|
||||
|
||||
@ -360,7 +360,7 @@ fn adjust_cj_at_line_end(p: &Preparation, items: &mut Items) {
|
||||
let shrink = glyph.shrinkability().1;
|
||||
let punct = shaped.glyphs.to_mut().last_mut().unwrap();
|
||||
punct.shrink_right(shrink);
|
||||
shaped.width -= shrink.at(shaped.size);
|
||||
shaped.width -= shrink.at(punct.size);
|
||||
} else if p.config.cjk_latin_spacing
|
||||
&& glyph.is_cj_script()
|
||||
&& (glyph.x_advance - glyph.x_offset) > Em::one()
|
||||
@ -371,7 +371,7 @@ fn adjust_cj_at_line_end(p: &Preparation, items: &mut Items) {
|
||||
let glyph = shaped.glyphs.to_mut().last_mut().unwrap();
|
||||
glyph.x_advance -= shrink;
|
||||
glyph.adjustability.shrinkability.1 = Em::zero();
|
||||
shaped.width -= shrink.at(shaped.size);
|
||||
shaped.width -= shrink.at(glyph.size);
|
||||
}
|
||||
}
|
||||
|
||||
@ -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::shift_settings_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.
|
||||
@ -444,7 +465,7 @@ pub fn commit(
|
||||
&& TextElem::overhang_in(text.styles)
|
||||
&& (line.items.len() > 1 || text.glyphs.len() > 1)
|
||||
{
|
||||
let amount = overhang(glyph.c) * glyph.x_advance.at(text.size);
|
||||
let amount = overhang(glyph.c) * glyph.x_advance.at(glyph.size);
|
||||
offset -= amount;
|
||||
remaining += amount;
|
||||
}
|
||||
@ -458,7 +479,7 @@ pub fn commit(
|
||||
&& TextElem::overhang_in(text.styles)
|
||||
&& (line.items.len() > 1 || text.glyphs.len() > 1)
|
||||
{
|
||||
let amount = overhang(glyph.c) * glyph.x_advance.at(text.size);
|
||||
let amount = overhang(glyph.c) * glyph.x_advance.at(glyph.size);
|
||||
remaining += amount;
|
||||
}
|
||||
}
|
||||
@ -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, idx);
|
||||
} else {
|
||||
offset += amount;
|
||||
|
@ -927,9 +927,9 @@ impl Estimates {
|
||||
let byte_len = g.range.len();
|
||||
let stretch = g.stretchability().0 + g.stretchability().1;
|
||||
let shrink = g.shrinkability().0 + g.shrinkability().1;
|
||||
widths.push(byte_len, g.x_advance.at(shaped.size));
|
||||
stretchability.push(byte_len, stretch.at(shaped.size));
|
||||
shrinkability.push(byte_len, shrink.at(shaped.size));
|
||||
widths.push(byte_len, g.x_advance.at(g.size));
|
||||
stretchability.push(byte_len, stretch.at(g.size));
|
||||
shrinkability.push(byte_len, shrink.at(g.size));
|
||||
justifiables.push(byte_len, g.is_justifiable() as usize);
|
||||
}
|
||||
} else {
|
||||
|
@ -29,7 +29,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::{
|
||||
|
@ -144,7 +144,7 @@ fn add_cjk_latin_spacing(items: &mut [(Range, Item)]) {
|
||||
// The spacing is default to 1/4 em, and can be shrunk to 1/8 em.
|
||||
glyph.x_advance += Em::new(0.25);
|
||||
glyph.adjustability.shrinkability.1 += Em::new(0.125);
|
||||
text.width += Em::new(0.25).at(text.size);
|
||||
text.width += Em::new(0.25).at(glyph.size);
|
||||
}
|
||||
|
||||
// Case 2: Latin followed by a CJ character
|
||||
@ -152,7 +152,7 @@ fn add_cjk_latin_spacing(items: &mut [(Range, Item)]) {
|
||||
glyph.x_advance += Em::new(0.25);
|
||||
glyph.x_offset += Em::new(0.25);
|
||||
glyph.adjustability.shrinkability.0 += Em::new(0.125);
|
||||
text.width += Em::new(0.25).at(text.size);
|
||||
text.width += Em::new(0.25).at(glyph.size);
|
||||
}
|
||||
|
||||
prev = Some(glyph);
|
||||
|
@ -3,14 +3,15 @@ use std::fmt::{self, Debug, Formatter};
|
||||
use std::sync::Arc;
|
||||
|
||||
use az::SaturatingAs;
|
||||
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, language, variant, Font, FontFamily,
|
||||
FontVariant, Glyph, Lang, Region, TextEdgeBounds, TextElem, TextItem,
|
||||
FontVariant, Glyph, Lang, Region, ShiftSettings, TextEdgeBounds, TextElem, TextItem,
|
||||
};
|
||||
use typst_library::World;
|
||||
use typst_utils::SliceExt;
|
||||
@ -41,8 +42,6 @@ pub struct ShapedText<'a> {
|
||||
pub styles: StyleChain<'a>,
|
||||
/// The font variant.
|
||||
pub variant: FontVariant,
|
||||
/// The font size.
|
||||
pub size: Abs,
|
||||
/// The width of the text's bounding box.
|
||||
pub width: Abs,
|
||||
/// The shaped glyphs.
|
||||
@ -62,6 +61,8 @@ pub struct ShapedGlyph {
|
||||
pub x_offset: Em,
|
||||
/// The vertical offset of the glyph.
|
||||
pub y_offset: Em,
|
||||
/// The font size for the glyph.
|
||||
pub size: Abs,
|
||||
/// The adjustability of the glyph.
|
||||
pub adjustability: Adjustability,
|
||||
/// The byte range of this glyph's cluster in the full inline layout. A
|
||||
@ -222,14 +223,17 @@ 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);
|
||||
|
||||
for ((font, y_offset), group) in
|
||||
self.glyphs.as_ref().group_by_key(|g| (g.font.clone(), g.y_offset))
|
||||
for ((font, y_offset, glyph_size), group) in self
|
||||
.glyphs
|
||||
.as_ref()
|
||||
.group_by_key(|g| (g.font.clone(), g.y_offset, g.size))
|
||||
{
|
||||
let mut range = group[0].range.clone();
|
||||
for glyph in group {
|
||||
@ -237,7 +241,7 @@ impl<'a> ShapedText<'a> {
|
||||
range.end = range.end.max(glyph.range.end);
|
||||
}
|
||||
|
||||
let pos = Point::new(offset, top + shift - y_offset.at(self.size));
|
||||
let pos = Point::new(offset, top + shift - y_offset.at(size));
|
||||
let glyphs: Vec<Glyph> = group
|
||||
.iter()
|
||||
.map(|shaped: &ShapedGlyph| {
|
||||
@ -257,11 +261,11 @@ impl<'a> ShapedText<'a> {
|
||||
adjustability_right * justification_ratio;
|
||||
if shaped.is_justifiable() {
|
||||
justification_right +=
|
||||
Em::from_length(extra_justification, self.size)
|
||||
Em::from_abs(extra_justification, glyph_size)
|
||||
}
|
||||
|
||||
frame.size_mut().x += justification_left.at(self.size)
|
||||
+ justification_right.at(self.size);
|
||||
frame.size_mut().x += justification_left.at(glyph_size)
|
||||
+ justification_right.at(glyph_size);
|
||||
|
||||
// We may not be able to reach the offset completely if
|
||||
// it exceeds u16, but better to have a roughly correct
|
||||
@ -304,7 +308,7 @@ impl<'a> ShapedText<'a> {
|
||||
|
||||
let item = TextItem {
|
||||
font,
|
||||
size: self.size,
|
||||
size: glyph_size,
|
||||
lang: self.lang,
|
||||
region: self.region,
|
||||
fill: fill.clone(),
|
||||
@ -336,12 +340,13 @@ 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);
|
||||
|
||||
// Expand top and bottom by reading the font's vertical metrics.
|
||||
let mut expand = |font: &Font, bounds: TextEdgeBounds| {
|
||||
let (t, b) = font.edges(top_edge, bottom_edge, self.size, bounds);
|
||||
let (t, b) = font.edges(top_edge, bottom_edge, size, bounds);
|
||||
top.set_max(t);
|
||||
bottom.set_max(b);
|
||||
};
|
||||
@ -388,18 +393,16 @@ impl<'a> ShapedText<'a> {
|
||||
pub fn stretchability(&self) -> Abs {
|
||||
self.glyphs
|
||||
.iter()
|
||||
.map(|g| g.stretchability().0 + g.stretchability().1)
|
||||
.sum::<Em>()
|
||||
.at(self.size)
|
||||
.map(|g| (g.stretchability().0 + g.stretchability().1).at(g.size))
|
||||
.sum()
|
||||
}
|
||||
|
||||
/// The shrinkability of the text
|
||||
pub fn shrinkability(&self) -> Abs {
|
||||
self.glyphs
|
||||
.iter()
|
||||
.map(|g| g.shrinkability().0 + g.shrinkability().1)
|
||||
.sum::<Em>()
|
||||
.at(self.size)
|
||||
.map(|g| (g.shrinkability().0 + g.shrinkability().1).at(g.size))
|
||||
.sum()
|
||||
}
|
||||
|
||||
/// Reshape a range of the shaped text, reusing information from this
|
||||
@ -418,9 +421,8 @@ impl<'a> ShapedText<'a> {
|
||||
lang: self.lang,
|
||||
region: self.region,
|
||||
styles: self.styles,
|
||||
size: self.size,
|
||||
variant: self.variant,
|
||||
width: glyphs.iter().map(|g| g.x_advance).sum::<Em>().at(self.size),
|
||||
width: glyphs_width(glyphs),
|
||||
glyphs: Cow::Borrowed(glyphs),
|
||||
}
|
||||
} else {
|
||||
@ -484,13 +486,15 @@ 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);
|
||||
self.width += x_advance.at(self.size);
|
||||
let size = TextElem::size_in(self.styles);
|
||||
self.width += x_advance.at(size);
|
||||
let glyph = ShapedGlyph {
|
||||
font,
|
||||
glyph_id: glyph_id.0,
|
||||
x_advance,
|
||||
x_offset: Em::zero(),
|
||||
y_offset: Em::zero(),
|
||||
size,
|
||||
adjustability: Adjustability::default(),
|
||||
range,
|
||||
safe_to_break: true,
|
||||
@ -666,6 +670,7 @@ fn shape<'a>(
|
||||
region: Option<Region>,
|
||||
) -> ShapedText<'a> {
|
||||
let size = TextElem::size_in(styles);
|
||||
let shift_settings = TextElem::shift_settings_in(styles);
|
||||
let mut ctx = ShapingContext {
|
||||
engine,
|
||||
size,
|
||||
@ -676,6 +681,7 @@ fn shape<'a>(
|
||||
features: features(styles),
|
||||
fallback: TextElem::fallback_in(styles),
|
||||
dir,
|
||||
shift_settings,
|
||||
};
|
||||
|
||||
if !text.is_empty() {
|
||||
@ -698,12 +704,17 @@ fn shape<'a>(
|
||||
region,
|
||||
styles,
|
||||
variant: ctx.variant,
|
||||
size,
|
||||
width: ctx.glyphs.iter().map(|g| g.x_advance).sum::<Em>().at(size),
|
||||
width: glyphs_width(&ctx.glyphs),
|
||||
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]) -> Abs {
|
||||
glyphs.iter().map(|g| g.x_advance.at(g.size)).sum()
|
||||
}
|
||||
|
||||
/// Holds shaping results and metadata common to all shaped segments.
|
||||
struct ShapingContext<'a, 'v> {
|
||||
engine: &'a Engine<'v>,
|
||||
@ -715,6 +726,7 @@ struct ShapingContext<'a, 'v> {
|
||||
features: Vec<rustybuzz::Feature>,
|
||||
fallback: bool,
|
||||
dir: Dir,
|
||||
shift_settings: Option<ShiftSettings>,
|
||||
}
|
||||
|
||||
/// Shape text with font fallback using the `families` iterator.
|
||||
@ -789,6 +801,18 @@ fn shape_segment<'a>(
|
||||
// text extraction.
|
||||
buffer.set_flags(BufferFlags::REMOVE_DEFAULT_IGNORABLES);
|
||||
|
||||
let (script_shift, script_compensation, scale, shift_feature) = ctx
|
||||
.shift_settings
|
||||
.map_or((Em::zero(), Em::zero(), Em::one(), None), |settings| {
|
||||
determine_shift(text, &font, settings)
|
||||
});
|
||||
|
||||
let has_shift_feature = shift_feature.is_some();
|
||||
if let Some(feat) = shift_feature {
|
||||
// Temporarily push the feature.
|
||||
ctx.features.push(feat)
|
||||
}
|
||||
|
||||
// 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(
|
||||
@ -799,6 +823,10 @@ fn shape_segment<'a>(
|
||||
&ctx.features,
|
||||
);
|
||||
|
||||
if has_shift_feature {
|
||||
ctx.features.pop();
|
||||
}
|
||||
|
||||
// Shape!
|
||||
let buffer = rustybuzz::shape_with_plan(font.rusty(), &plan, buffer);
|
||||
let infos = buffer.glyph_infos();
|
||||
@ -869,8 +897,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,
|
||||
size: scale.at(ctx.size),
|
||||
adjustability: Adjustability::default(),
|
||||
range: start..end,
|
||||
safe_to_break: !info.unsafe_to_break(),
|
||||
@ -932,6 +961,64 @@ fn shape_segment<'a>(
|
||||
ctx.used.pop();
|
||||
}
|
||||
|
||||
/// Returns a `(script_shift, script_compensation, scale, feature)` quadruplet
|
||||
/// describing how to produce scripts.
|
||||
///
|
||||
/// Those values determine how the rendered text should be transformed to
|
||||
/// display sub-/super-scripts. 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, None)`). If scripts should be synthesized, those values
|
||||
/// determine how to transform the rendered text to display scripts as expected.
|
||||
fn determine_shift(
|
||||
text: &str,
|
||||
font: &Font,
|
||||
settings: ShiftSettings,
|
||||
) -> (Em, Em, Em, Option<Feature>) {
|
||||
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::<SubstitutionSubtable>(0)?
|
||||
.coverage();
|
||||
text.chars()
|
||||
.all(|c| {
|
||||
font.rusty().glyph_index(c).is_some_and(|i| coverage.contains(i))
|
||||
})
|
||||
.then(|| {
|
||||
// If we can use the OpenType feature, we can keep the text
|
||||
// as is.
|
||||
(
|
||||
Em::zero(),
|
||||
Em::zero(),
|
||||
Em::one(),
|
||||
Some(Feature::new(settings.kind.feature(), 1, ..)),
|
||||
)
|
||||
})
|
||||
})
|
||||
// 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),
|
||||
None,
|
||||
)
|
||||
})
|
||||
}
|
||||
|
||||
/// Create a shape plan.
|
||||
#[comemo::memoize]
|
||||
pub fn create_shape_plan(
|
||||
@ -963,6 +1050,7 @@ fn shape_tofus(ctx: &mut ShapingContext, base: usize, text: &str, font: Font) {
|
||||
x_advance,
|
||||
x_offset: Em::zero(),
|
||||
y_offset: Em::zero(),
|
||||
size: ctx.size,
|
||||
adjustability: Adjustability::default(),
|
||||
range: start..end,
|
||||
safe_to_break: true,
|
||||
@ -985,9 +1073,8 @@ 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_length(TextElem::tracking_in(ctx.styles), ctx.size);
|
||||
let spacing =
|
||||
TextElem::spacing_in(ctx.styles).map(|abs| Em::from_length(abs, ctx.size));
|
||||
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 mut glyphs = ctx.glyphs.iter_mut().peekable();
|
||||
while let Some(glyph) = glyphs.next() {
|
||||
|
@ -215,7 +215,7 @@ impl MathFragment {
|
||||
&glyph.item.font,
|
||||
GlyphId(glyph.item.glyphs[glyph_index].id),
|
||||
corner,
|
||||
Em::from_length(height, glyph.item.size),
|
||||
Em::from_abs(height, glyph.item.size),
|
||||
)
|
||||
.unwrap_or_default()
|
||||
.at(glyph.item.size)
|
||||
@ -767,8 +767,8 @@ fn assemble(
|
||||
advance += ratio * (max_overlap - min_overlap);
|
||||
}
|
||||
let (x, y) = match axis {
|
||||
Axis::X => (Em::from_length(advance, base.item.size), Em::zero()),
|
||||
Axis::Y => (Em::zero(), Em::from_length(advance, base.item.size)),
|
||||
Axis::X => (Em::from_abs(advance, base.item.size), Em::zero()),
|
||||
Axis::Y => (Em::zero(), Em::from_abs(advance, base.item.size)),
|
||||
};
|
||||
glyphs.push(Glyph {
|
||||
id: part.glyph_id.0,
|
||||
|
@ -6,7 +6,7 @@ use ecow::EcoString;
|
||||
use typst_utils::{Numeric, Scalar};
|
||||
|
||||
use crate::foundations::{cast, repr, Repr, Resolve, StyleChain, Value};
|
||||
use crate::layout::Abs;
|
||||
use crate::layout::{Abs, Length};
|
||||
use crate::text::TextElem;
|
||||
|
||||
/// A length that is relative to the font size.
|
||||
@ -26,18 +26,18 @@ impl Em {
|
||||
Self(Scalar::ONE)
|
||||
}
|
||||
|
||||
/// Create a font-relative length.
|
||||
/// Creates a font-relative length.
|
||||
pub const fn new(em: f64) -> Self {
|
||||
Self(Scalar::new(em))
|
||||
}
|
||||
|
||||
/// Create an em length from font units at the given units per em.
|
||||
/// Creates an em length from font units at the given units per em.
|
||||
pub fn from_units(units: impl Into<f64>, units_per_em: f64) -> Self {
|
||||
Self(Scalar::new(units.into() / units_per_em))
|
||||
}
|
||||
|
||||
/// Create an em length from a length at the given font size.
|
||||
pub fn from_length(length: Abs, font_size: Abs) -> Self {
|
||||
/// Creates an em length from an absolute length at the given font size.
|
||||
pub fn from_abs(length: Abs, font_size: Abs) -> Self {
|
||||
let result = length / font_size;
|
||||
if result.is_finite() {
|
||||
Self(Scalar::new(result))
|
||||
@ -46,6 +46,11 @@ impl Em {
|
||||
}
|
||||
}
|
||||
|
||||
/// Creates an em length from a length at the given font size.
|
||||
pub fn from_length(length: Length, font_size: Abs) -> Em {
|
||||
length.em + Self::from_abs(length.abs, font_size)
|
||||
}
|
||||
|
||||
/// The number of em units.
|
||||
pub const fn get(self) -> f64 {
|
||||
(self.0).get()
|
||||
@ -56,7 +61,7 @@ impl Em {
|
||||
Self::new(self.get().abs())
|
||||
}
|
||||
|
||||
/// Convert to an absolute length at the given font size.
|
||||
/// Converts to an absolute length at the given font size.
|
||||
pub fn at(self, font_size: Abs) -> Abs {
|
||||
let resolved = font_size * self.get();
|
||||
if resolved.is_finite() {
|
||||
|
@ -228,6 +228,10 @@ pub struct FontMetrics {
|
||||
pub underline: LineMetrics,
|
||||
/// Recommended metrics for an overline.
|
||||
pub overline: LineMetrics,
|
||||
/// Metrics for subscripts, if provided by the font.
|
||||
pub subscript: Option<ScriptMetrics>,
|
||||
/// Metrics for superscripts, if provided by the font.
|
||||
pub superscript: Option<ScriptMetrics>,
|
||||
}
|
||||
|
||||
impl FontMetrics {
|
||||
@ -240,6 +244,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();
|
||||
|
||||
@ -262,6 +267,20 @@ impl FontMetrics {
|
||||
thickness: underline.thickness,
|
||||
};
|
||||
|
||||
let subscript = ttf.subscript_metrics().map(|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 = ttf.superscript_metrics().map(|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,
|
||||
@ -271,6 +290,8 @@ impl FontMetrics {
|
||||
strikethrough,
|
||||
underline,
|
||||
overline,
|
||||
superscript,
|
||||
subscript,
|
||||
}
|
||||
}
|
||||
|
||||
@ -296,6 +317,24 @@ pub struct LineMetrics {
|
||||
pub thickness: Em,
|
||||
}
|
||||
|
||||
/// Metrics for subscripts or superscripts.
|
||||
#[derive(Debug, Copy, Clone)]
|
||||
pub struct ScriptMetrics {
|
||||
/// The width of those scripts, relative to the outer font size.
|
||||
pub width: Em,
|
||||
/// The height of those scripts, relative to the outer font size.
|
||||
pub height: Em,
|
||||
/// The horizontal (to the right) offset of those scripts, relative to the
|
||||
/// outer font size.
|
||||
///
|
||||
/// This is used for italic correction.
|
||||
pub horizontal_offset: Em,
|
||||
/// The vertical (to the top) offset of those scripts, relative to the outer font size.
|
||||
///
|
||||
/// For superscripts, this is positive. For subscripts, this is negative.
|
||||
pub vertical_offset: Em,
|
||||
}
|
||||
|
||||
/// Identifies a vertical metric of a font.
|
||||
#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash, Cast)]
|
||||
pub enum VerticalFontMetric {
|
||||
|
@ -755,6 +755,12 @@ pub struct TextElem {
|
||||
#[internal]
|
||||
#[ghost]
|
||||
pub smallcaps: Option<Smallcaps>,
|
||||
|
||||
/// The configuration for superscripts or subscripts, if one of them is
|
||||
/// enabled.
|
||||
#[internal]
|
||||
#[ghost]
|
||||
pub shift_settings: Option<ShiftSettings>,
|
||||
}
|
||||
|
||||
impl TextElem {
|
||||
|
@ -1,14 +1,13 @@
|
||||
use ecow::EcoString;
|
||||
|
||||
use crate::diag::SourceResult;
|
||||
use crate::engine::Engine;
|
||||
use crate::foundations::{
|
||||
elem, Content, NativeElement, Packed, SequenceElem, Show, StyleChain, TargetElem,
|
||||
elem, Content, NativeElement, Packed, Show, Smart, StyleChain, TargetElem,
|
||||
};
|
||||
use crate::html::{tag, HtmlElem};
|
||||
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.
|
||||
///
|
||||
@ -20,11 +19,16 @@ 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 lowering 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 are provided by the font (using the `subs`
|
||||
/// OpenType feature). Otherwise, Typst is able to synthesize subscripts.
|
||||
///
|
||||
/// 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]
|
||||
@ -33,17 +37,27 @@ 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 downward 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.
|
||||
///
|
||||
/// If set to `{auto}`, the baseline is shifted according to the metrics
|
||||
/// provided by the font, with a fallback to `{0.2em}` in case the font does
|
||||
/// not define the necessary metrics.
|
||||
pub baseline: Smart<Length>,
|
||||
|
||||
/// 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.
|
||||
///
|
||||
/// If set to `{auto}`, the size is scaled according to the metrics provided
|
||||
/// by the font, with a fallback to `{0.6em}` in case the font does not
|
||||
/// define the necessary metrics.
|
||||
pub size: Smart<TextSize>,
|
||||
|
||||
/// The text to display in subscript.
|
||||
#[required]
|
||||
@ -52,7 +66,7 @@ pub struct SubElem {
|
||||
|
||||
impl Show for Packed<SubElem> {
|
||||
#[typst_macros::time(name = "sub", span = self.span())]
|
||||
fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
|
||||
fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
|
||||
let body = self.body.clone();
|
||||
|
||||
if TargetElem::target_in(styles).is_html() {
|
||||
@ -62,17 +76,14 @@ impl Show for Packed<SubElem> {
|
||||
.spanned(self.span()));
|
||||
}
|
||||
|
||||
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))))
|
||||
show_script(
|
||||
styles,
|
||||
body,
|
||||
self.typographic(styles),
|
||||
self.baseline(styles),
|
||||
self.size(styles),
|
||||
ScriptKind::Sub,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
@ -86,11 +97,16 @@ impl Show for Packed<SubElem> {
|
||||
/// ```
|
||||
#[elem(title = "Superscript", Show)]
|
||||
pub struct SuperElem {
|
||||
/// Whether to prefer the dedicated superscript characters of the font.
|
||||
/// Whether to create artificial superscripts by raising 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 are provided by the font (using the `sups`
|
||||
/// OpenType feature). Otherwise, Typst is able to synthesize superscripts.
|
||||
///
|
||||
/// 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]
|
||||
@ -99,17 +115,31 @@ 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 downward 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.
|
||||
///
|
||||
/// If set to `{auto}`, the baseline is shifted according to the metrics
|
||||
/// provided by the font, with a fallback to `{-0.5em}` in case the font
|
||||
/// does not define the necessary metrics.
|
||||
///
|
||||
/// Note that, since the baseline shift is applied downward, you will need
|
||||
/// to provide a negative value for the content to appear as raised above
|
||||
/// the normal baseline.
|
||||
pub baseline: Smart<Length>,
|
||||
|
||||
/// 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.
|
||||
///
|
||||
/// If set to `{auto}`, the size is scaled according to the metrics provided
|
||||
/// by the font, with a fallback to `{0.6em}` in case the font does not
|
||||
/// define the necessary metrics.
|
||||
pub size: Smart<TextSize>,
|
||||
|
||||
/// The text to display in superscript.
|
||||
#[required]
|
||||
@ -118,7 +148,7 @@ pub struct SuperElem {
|
||||
|
||||
impl Show for Packed<SuperElem> {
|
||||
#[typst_macros::time(name = "super", span = self.span())]
|
||||
fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
|
||||
fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
|
||||
let body = self.body.clone();
|
||||
|
||||
if TargetElem::target_in(styles).is_html() {
|
||||
@ -128,104 +158,102 @@ impl Show for Packed<SuperElem> {
|
||||
.spanned(self.span()));
|
||||
}
|
||||
|
||||
if self.typographic(styles) {
|
||||
if let Some(text) = convert_script(&body, false) {
|
||||
if is_shapable(engine, &text, styles) {
|
||||
return Ok(TextElem::packed(text));
|
||||
show_script(
|
||||
styles,
|
||||
body,
|
||||
self.typographic(styles),
|
||||
self.baseline(styles),
|
||||
self.size(styles),
|
||||
ScriptKind::Super,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
fn show_script(
|
||||
styles: StyleChain,
|
||||
body: Content,
|
||||
typographic: bool,
|
||||
baseline: Smart<Length>,
|
||||
size: Smart<TextSize>,
|
||||
kind: ScriptKind,
|
||||
) -> SourceResult<Content> {
|
||||
let font_size = TextElem::size_in(styles);
|
||||
Ok(body.styled(TextElem::set_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.
|
||||
#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
|
||||
pub struct ShiftSettings {
|
||||
/// Whether the OpenType feature should be used if possible.
|
||||
pub typographic: bool,
|
||||
/// The baseline shift of the script, relative to the outer text size.
|
||||
///
|
||||
/// For superscripts, this is positive. For subscripts, this is negative. A
|
||||
/// value of [`Smart::Auto`] indicates that the value should be obtained
|
||||
/// from font metrics.
|
||||
pub shift: Smart<Em>,
|
||||
/// The size of the script, relative to the outer text size.
|
||||
///
|
||||
/// A value of [`Smart::Auto`] indicates that the value should be obtained
|
||||
/// from font metrics.
|
||||
pub size: Smart<Em>,
|
||||
/// The kind of script (either a subscript, or a superscript).
|
||||
///
|
||||
/// This is used to know which OpenType table to use to resolve
|
||||
/// [`Smart::Auto`] values.
|
||||
pub kind: ScriptKind,
|
||||
}
|
||||
|
||||
#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
|
||||
pub enum ScriptKind {
|
||||
Sub,
|
||||
Super,
|
||||
}
|
||||
|
||||
impl ScriptKind {
|
||||
/// Returns the default metrics for this script kind.
|
||||
///
|
||||
/// This can be used as a last resort if neither the user nor the font
|
||||
/// provided those metrics.
|
||||
pub fn default_metrics(self) -> &'static ScriptMetrics {
|
||||
match self {
|
||||
Self::Sub => &DEFAULT_SUBSCRIPT_METRICS,
|
||||
Self::Super => &DEFAULT_SUPERSCRIPT_METRICS,
|
||||
}
|
||||
}
|
||||
|
||||
/// Reads the script metrics from the font table for to this script kind.
|
||||
pub fn read_metrics(self, font_metrics: &FontMetrics) -> &ScriptMetrics {
|
||||
match self {
|
||||
Self::Sub => font_metrics.subscript.as_ref(),
|
||||
Self::Super => font_metrics.superscript.as_ref(),
|
||||
}
|
||||
.unwrap_or(self.default_metrics())
|
||||
}
|
||||
|
||||
/// 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"),
|
||||
}
|
||||
}
|
||||
}
|
||||
static DEFAULT_SUBSCRIPT_METRICS: ScriptMetrics = ScriptMetrics {
|
||||
width: Em::new(0.6),
|
||||
height: Em::new(0.6),
|
||||
horizontal_offset: Em::zero(),
|
||||
vertical_offset: Em::new(-0.2),
|
||||
};
|
||||
|
||||
Ok(body
|
||||
.styled(TextElem::set_baseline(self.baseline(styles)))
|
||||
.styled(TextElem::set_size(self.size(styles))))
|
||||
}
|
||||
}
|
||||
|
||||
/// 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<EcoString> {
|
||||
if content.is::<SpaceElem>() {
|
||||
Some(' '.into())
|
||||
} else if let Some(elem) = content.to_packed::<TextElem>() {
|
||||
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::<SequenceElem>() {
|
||||
sequence
|
||||
.children
|
||||
.iter()
|
||||
.map(|item| convert_script(item, sub))
|
||||
.collect()
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
/// 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()
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
false
|
||||
}
|
||||
|
||||
/// Convert a character to its corresponding Unicode superscript.
|
||||
fn to_superscript_codepoint(c: char) -> Option<char> {
|
||||
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,
|
||||
}
|
||||
}
|
||||
|
||||
/// Convert a character to its corresponding Unicode subscript.
|
||||
fn to_subscript_codepoint(c: char) -> Option<char> {
|
||||
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,
|
||||
}
|
||||
}
|
||||
static DEFAULT_SUPERSCRIPT_METRICS: ScriptMetrics = ScriptMetrics {
|
||||
width: Em::new(0.6),
|
||||
height: Em::new(0.6),
|
||||
horizontal_offset: Em::zero(),
|
||||
vertical_offset: Em::new(0.5),
|
||||
};
|
||||
|
Before Width: | Height: | Size: 841 B After Width: | Height: | Size: 903 B |
BIN
tests/ref/long-scripts.png
Normal file
After Width: | Height: | Size: 956 B |
BIN
tests/ref/script-metrics-bundeled-fonts.png
Normal file
After Width: | Height: | Size: 3.0 KiB |
BIN
tests/ref/sub-super-italic-compensation.png
Normal file
After Width: | Height: | Size: 1.3 KiB |
Before Width: | Height: | Size: 311 B After Width: | Height: | Size: 318 B |
BIN
tests/ref/sub-super-typographic.png
Normal file
After Width: | Height: | Size: 1.3 KiB |
Before Width: | Height: | Size: 1.1 KiB After Width: | Height: | Size: 1.2 KiB |
BIN
tests/ref/super-highlight.png
Normal file
After Width: | Height: | Size: 1.3 KiB |
Before Width: | Height: | Size: 1.8 KiB After Width: | Height: | Size: 835 B |
@ -1,22 +1,89 @@
|
||||
// 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` and `sq`, 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[A#super[4]] B \
|
||||
A#super[#underline[4]] B \
|
||||
A #underline(super[4]) B \
|
||||
#set super(typographic: true)
|
||||
#underline[A#super[4]] B \
|
||||
A#super[#underline[4]] B \
|
||||
A #underline(super[4]) B
|
||||
|
||||
--- super-highlight ---
|
||||
#set super(typographic: false)
|
||||
#highlight[A#super[4]] B \
|
||||
A#super[#highlight[4]] B \
|
||||
A#super(highlight[4]) \
|
||||
#set super(typographic: true)
|
||||
#highlight[A#super[4]] B \
|
||||
A#super[#highlight[4]] B \
|
||||
A#super(highlight[4])
|
||||
|
||||
--- super-1em ---
|
||||
#set text(size: 10pt)
|
||||
#super(context test(1em.to-absolute(), 10pt))
|
||||
|
||||
--- long-scripts ---
|
||||
|longscript| \
|
||||
|#super(typographic: true)[longscript]| \
|
||||
|#super(typographic: false)[longscript]| \
|
||||
|#sub(typographic: true)[longscript]| \
|
||||
|#sub(typographic: false)[longscript]|
|
||||
|
||||
--- script-metrics-bundeled-fonts ---
|
||||
// Tests whether the script metrics are used properly by synthesizing
|
||||
// superscripts and subscripts for all bundled fonts.
|
||||
|
||||
#set super(typographic: false)
|
||||
#set sub(typographic: false)
|
||||
|
||||
#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",))
|
||||
|
||||
--- basic-sup-sub html ---
|
||||
1#super[st], 2#super[nd], 3#super[rd].
|
||||
|