use super::*;
use crate::css::{ModeledLonghandSet, copy_modeled_longhand, modeled_longhand_has_same_source};
pub(in crate::layout) fn apply_first_line_pseudos_to_line_items(
items: &mut Vec<InlineLineItem>,
block_style: &ComputedStyle,
apply_first_letter: bool,
font_system: &mut FontSystem,
) {
if let Some(first_line_style) = block_style.first_line_style.as_deref() {
for item in items.iter_mut() {
match item {
InlineLineItem::Fragment(fragment) => {
if matches!(fragment.source(), InlineTextSource::BlockEllipsis) {
continue;
}
if apply_first_line_style_delta(
fragment.style_mut(),
block_style,
first_line_style,
&block_style.first_line_overrides,
) {
fragment.set_force_inline_background_paint(true);
}
fragment.apply_to_ancestor_inline_decoration_styles(|style| {
apply_first_line_style_delta(
style,
block_style,
first_line_style,
&block_style.first_line_overrides,
);
});
}
InlineLineItem::Atom(atom) => {
if matches!(
atom.content(),
InlineAtomContent::InlineEdge(InlineEdgeRole::BoxEdge(_))
) {
if first_line_style.color != block_style.color
&& atom.style().color == block_style.color
{
atom.set_current_color_override(first_line_style.color);
}
continue;
}
if matches!(
atom.content(),
InlineAtomContent::InlineEdge(InlineEdgeRole::TextAutospace(_))
) {
let mut style = atom.style().clone();
apply_first_line_style_delta(
&mut style,
block_style,
first_line_style,
&block_style.first_line_overrides,
);
let advance = font_system.ic_advance_for_style(&style) / 8.0;
atom.set_text_autospace_advance(&style, advance);
continue;
}
let content = Rc::make_mut(&mut atom.data);
let InlineAtomContent::Ruby {
base,
annotations,
annotation_sides,
..
} = &mut content.content
else {
continue;
};
apply_first_line_style_to_ruby_level(
base,
block_style,
first_line_style,
&block_style.first_line_overrides,
);
for (annotation, side) in annotations.iter_mut().zip(annotation_sides) {
apply_first_line_style_to_ruby_level(
annotation,
block_style,
first_line_style,
&block_style.first_line_overrides,
);
*side = annotation.style.ruby_position.interlinear_side();
}
}
InlineLineItem::Float(_) => {}
}
}
}
if apply_first_letter
&& let Some(first_letter_style) = block_style.first_letter_style.as_deref()
{
apply_first_letter_pseudo_to_line_items(items, first_letter_style);
}
}
fn apply_first_line_style_to_ruby_level(
level: &mut RubyInlineLevel,
originating_style: &ComputedStyle,
first_line_style: &ComputedStyle,
overrides: &ModeledLonghandSet,
) {
apply_first_line_style_delta(
&mut level.style,
originating_style,
first_line_style,
overrides,
);
for record in &mut level.sequence.records {
let Some(fragment) = &mut record.fragment else {
continue;
};
for measured in Rc::make_mut(&mut fragment.items).iter_mut() {
match &mut measured.item {
InlineLineItem::Fragment(fragment) => {
apply_first_line_style_delta(
fragment.style_mut(),
originating_style,
first_line_style,
overrides,
);
}
InlineLineItem::Atom(_) | InlineLineItem::Float(_) => {}
}
}
}
}
pub(in crate::layout) fn apply_first_line_style_delta(
fragment_style: &mut ComputedStyle,
originating_style: &ComputedStyle,
first_line_style: &ComputedStyle,
overrides: &ModeledLonghandSet,
) -> bool {
let mut background_changed = false;
for longhand in overrides.iter() {
let is_background = longhand.css_name().starts_with("background");
if !longhand.is_inherited() && !is_background && longhand.css_name() != "vertical-align" {
continue;
}
if !modeled_longhand_has_same_source(fragment_style, originating_style, longhand) {
continue;
}
if is_background {
background_changed = true;
}
copy_modeled_longhand(fragment_style, first_line_style, longhand);
}
background_changed
}
pub(in crate::layout) fn apply_first_letter_pseudo_to_line_items(
items: &mut Vec<InlineLineItem>,
first_letter_style: &ComputedStyle,
) {
for index in 0..items.len() {
let InlineLineItem::Fragment(fragment) = &items[index] else {
continue;
};
let Some(range) = first_letter_byte_range(fragment.text()) else {
continue;
};
let pieces = split_fragment_for_first_letter(fragment, range, first_letter_style)
.into_iter()
.map(InlineLineItem::Fragment)
.collect::<Vec<_>>();
items.splice(index..=index, pieces);
break;
}
}
pub(in crate::layout) fn split_fragment_for_first_letter(
fragment: &InlineFragment,
range: std::ops::Range<usize>,
first_letter_style: &ComputedStyle,
) -> Vec<InlineFragment> {
let mut pieces = Vec::new();
if range.start > 0 {
let mut before = fragment.clone();
before.set_text(Rc::<str>::from(&fragment.text()[..range.start]));
pieces.push(before);
}
let mut letter = fragment.clone();
letter.set_text(Rc::<str>::from(&fragment.text()[range.clone()]));
*letter.style_mut() = first_letter_style.clone();
letter.set_mergeable(false);
pieces.push(letter);
if range.end < fragment.text().len() {
let mut after = fragment.clone();
after.set_text(Rc::<str>::from(&fragment.text()[range.end..]));
pieces.push(after);
}
pieces
}
pub(in crate::layout) fn first_letter_byte_range(text: &str) -> Option<std::ops::Range<usize>> {
fn unit_base(unit: &str) -> Option<char> {
unit.chars().find(|character| {
!character_is_unicode_mark(*character)
&& !character_is_default_ignorable_code_point(*character)
})
}
let units = CursiveProtectedUnitRanges::new(text);
let mut prefix_start = None;
let mut selected_start = None;
let mut selected_end = None;
let mut pending_suffix_space_start = None;
for range in units {
let unit = &text[range.clone()];
let Some(base) = unit_base(unit) else {
continue;
};
let selected = selected_start.is_some();
if !selected {
if character_is_first_letter_associated_space(base) && prefix_start.is_some() {
continue;
}
if base.is_whitespace() && prefix_start.is_none() {
continue;
}
if character_is_unicode_punctuation(base) {
prefix_start.get_or_insert(range.start);
continue;
}
if character_is_unicode_first_letter_base(base) {
selected_start = Some(prefix_start.unwrap_or(range.start));
selected_end = Some(range.end);
continue;
}
if prefix_start.is_some() {
return None;
}
continue;
}
if character_is_first_letter_associated_space(base) {
pending_suffix_space_start.get_or_insert(range.start);
continue;
}
if character_is_first_letter_suffix_punctuation(base) {
if let Some(space_start) = pending_suffix_space_start.take() {
selected_end = Some(range.end.max(space_start));
} else {
selected_end = Some(range.end);
}
continue;
}
break;
}
selected_start
.zip(selected_end)
.map(|(start, end)| start..end)
}
#[cfg(test)]
mod first_letter_tests {
use super::first_letter_byte_range;
#[test]
fn selects_symbol_first_letters_and_associated_punctuation() {
for (text, expected) in [
("$1,234.56", "$"),
("(£)78.90", "(£)"),
("₹10,000", "₹"),
("©2021", "©"),
] {
let range = first_letter_byte_range(text).expect("expected first-letter text");
assert_eq!(&text[range], expected, "{text}");
}
}
#[test]
fn preserves_complete_typographic_units_and_associated_spaces() {
let text = "“\u{00a0}e\u{301}”x";
let range = first_letter_byte_range(text).expect("expected first-letter text");
assert_eq!(&text[range], "“\u{00a0}e\u{301}”");
}
#[test]
fn rejects_unassociated_prefix_punctuation() {
assert_eq!(first_letter_byte_range("(\u{3000}A"), None);
}
}
#[cfg(test)]
mod inter_character_unit_tests {
use super::*;
fn fragment(text: &str, generated_leader: bool) -> InlineFragment {
InlineFragment::new(
text,
ComputedStyle::initial(),
0.0,
None,
true,
InlineTextSource::Normal,
generated_leader,
InlineHangingEdges::default(),
Vec::new(),
)
}
#[test]
fn inter_character_unit_eligibility_requires_nonempty_non_leader_text() {
assert!(!inline_fragment_is_inter_character_unit(&fragment(
"", false
)));
assert!(!inline_fragment_is_inter_character_unit(&fragment(
"text", true
)));
assert!(inline_fragment_is_inter_character_unit(&fragment(
"text", false
)));
assert!(inline_fragment_is_inter_character_unit(&fragment(
"\u{200e}", false
)));
}
}
#[cfg(test)]
mod first_line_autospace_tests {
use super::*;
#[test]
fn first_line_materializes_font_synthesis_subproperties() {
let originating = ComputedStyle::initial();
let mut pseudo = originating.clone();
pseudo.font_synthesis.weight = false;
pseudo.font_synthesis.style = false;
let mut overrides = ModeledLonghandSet::empty();
overrides.insert_css_name("font-synthesis-weight");
overrides.insert_css_name("font-synthesis-style");
let mut fragment = originating.clone();
apply_first_line_style_delta(&mut fragment, &originating, &pseudo, &overrides);
assert!(!fragment.font_synthesis.weight);
assert!(!fragment.font_synthesis.style);
}
#[test]
fn first_line_remeasures_an_autospace_marker_with_its_font_style() {
let mut block_style = ComputedStyle::initial();
block_style.font_size = 12.0;
let mut first_line_style = block_style.clone();
first_line_style.font_size = 48.0;
block_style
.first_line_overrides
.insert_css_name("font-size");
block_style.first_line_style = Some(Box::new(first_line_style));
let mut font_system = FontSystem::new();
let initial_advance = font_system.ic_advance_for_style(&block_style) / 8.0;
let mut items = vec![InlineLineItem::Atom(InlineAtom::new(
InlineAtomContent::InlineEdge(InlineEdgeRole::TextAutospace(
InlineTextBoundarySpacing::new(initial_advance),
)),
block_style.clone(),
None,
InlineSize::new(initial_advance.points(), 0.0),
0.0,
0.0,
None,
None,
))];
apply_first_line_pseudos_to_line_items(&mut items, &block_style, false, &mut font_system);
let InlineLineItem::Atom(atom) = &items[0] else {
panic!("test setup creates an autospace atom");
};
let InlineAtomContent::InlineEdge(InlineEdgeRole::TextAutospace(spacing)) = atom.content()
else {
panic!("expected an autospace atom");
};
assert_eq!(atom.style().font_size, 48.0);
assert_eq!(
spacing.advance().points(),
(font_system.ic_advance_for_style(atom.style()) / 8.0).points()
);
assert_ne!(spacing.advance().points(), initial_advance.points());
}
}