use super::*;
pub(in crate::layout) fn prepare_text_decoration_strokes(
input: TextDecorationPreparationInput<'_>,
) -> Vec<PreparedTextDecorationStroke> {
let TextDecorationPreparationInput {
baseline,
inline_span,
inset_start,
inset_end,
style,
inset_style,
inset_inline_axis,
decoration,
phase,
color,
color_override,
geometry,
} = input;
if inline_span.length() <= 0.0 {
return Vec::new();
}
let axis = if style.writing_mode == WritingMode::HorizontalTb {
TextDecorationStrokeAxis::Horizontal
} else {
TextDecorationStrokeAxis::Vertical
};
let Some(inline_span) = text_decoration_inline_span(
axis,
inline_span,
inset_start,
inset_end,
inset_style,
inset_inline_axis,
) else {
return Vec::new();
};
let underline_thickness = used_text_decoration_thickness(
decoration.thickness.clone(),
decoration_thickness_font_size(&decoration.thickness, geometry),
&geometry.considered_metrics,
false,
);
let strikeout_thickness = used_text_decoration_thickness(
decoration.thickness.clone(),
decoration_thickness_font_size(&decoration.thickness, geometry),
&geometry.considered_metrics,
true,
);
let mut strokes = Vec::new();
if phase.paints_underlines()
&& decoration.underline
&& !text_decoration_skip_self_suppresses(style, TextDecorationLineKind::Underline)
{
strokes.push(PreparedTextDecorationStroke {
axis,
baseline,
inline_span,
block_position: text_decoration_block_position(
axis,
baseline.x,
baseline.y,
geometry.considered_font_size,
style.writing_mode,
decoration.underline_position,
decoration.underline_offset.clone(),
&geometry.considered_metrics,
underline_thickness,
TextDecorationPreparedLineKind::Underline,
),
thickness: underline_thickness,
color,
style: decoration.style,
skip_ink: decoration.skip_ink,
skip_spaces: decoration.skip_spaces,
});
}
if phase.paints_overlines()
&& decoration.overline
&& !text_decoration_skip_self_suppresses(style, TextDecorationLineKind::Overline)
{
strokes.push(PreparedTextDecorationStroke {
axis,
baseline,
inline_span,
block_position: text_decoration_block_position(
axis,
baseline.x,
baseline.y,
geometry.considered_font_size,
style.writing_mode,
decoration.underline_position,
decoration.underline_offset.clone(),
&geometry.considered_metrics,
underline_thickness,
TextDecorationPreparedLineKind::Overline,
),
thickness: underline_thickness,
color,
style: decoration.style,
skip_ink: decoration.skip_ink,
skip_spaces: decoration.skip_spaces,
});
}
if phase.paints_after_text()
&& decoration.line_through
&& !text_decoration_skip_self_suppresses(style, TextDecorationLineKind::LineThrough)
{
strokes.push(PreparedTextDecorationStroke {
axis,
baseline,
inline_span,
block_position: text_decoration_block_position(
axis,
baseline.x,
baseline.y,
geometry.considered_font_size,
style.writing_mode,
decoration.underline_position,
decoration.underline_offset.clone(),
&geometry.considered_metrics,
strikeout_thickness,
TextDecorationPreparedLineKind::LineThrough,
),
thickness: strikeout_thickness,
color,
style: decoration.style,
skip_ink: decoration.skip_ink,
skip_spaces: decoration.skip_spaces,
});
}
if phase.paints_underlines() && decoration.spelling_error {
strokes.push(PreparedTextDecorationStroke {
axis,
baseline,
inline_span,
block_position: text_decoration_block_position(
axis,
baseline.x,
baseline.y,
geometry.considered_font_size,
style.writing_mode,
decoration.underline_position,
decoration.underline_offset.clone(),
&geometry.considered_metrics,
underline_thickness,
TextDecorationPreparedLineKind::Underline,
),
thickness: underline_thickness,
color: color_override.unwrap_or(CssColor::new(255, 0, 0)),
style: TextDecorationStyle::Wavy,
skip_ink: TextDecorationSkipInk::None,
skip_spaces: TextDecorationSkipSpaces::NONE,
});
}
if phase.paints_underlines() && decoration.grammar_error {
strokes.push(PreparedTextDecorationStroke {
axis,
baseline,
inline_span,
block_position: text_decoration_block_position(
axis,
baseline.x,
baseline.y,
geometry.considered_font_size,
style.writing_mode,
decoration.underline_position,
decoration.underline_offset,
&geometry.considered_metrics,
underline_thickness,
TextDecorationPreparedLineKind::Underline,
),
thickness: underline_thickness,
color: color_override.unwrap_or(CssColor::new(0, 128, 0)),
style: TextDecorationStyle::Wavy,
skip_ink: TextDecorationSkipInk::None,
skip_spaces: TextDecorationSkipSpaces::NONE,
});
}
strokes
}
fn decoration_thickness_font_size(
thickness: &TextDecorationThickness,
geometry: TextDecorationLineGeometry,
) -> f32 {
match thickness {
TextDecorationThickness::Auto | TextDecorationThickness::FromFont => {
geometry.considered_font_size
}
TextDecorationThickness::LengthPercentage(_) => geometry.origin_font_size,
}
}
pub(in crate::layout) fn text_decoration_inline_span(
axis: TextDecorationStrokeAxis,
span: TextInlineSpan,
inset_start: f32,
inset_end: f32,
_inset_style: &ComputedStyle,
inset_inline_axis: TextDecorationInlineAxis,
) -> Option<TextInlineSpan> {
debug_assert_eq!(axis, inset_inline_axis.stroke_axis());
inset_inline_axis.inset_span(span, inset_start, inset_end)
}
#[allow(clippy::too_many_arguments)]
pub(in crate::layout) fn text_decoration_block_position(
axis: TextDecorationStrokeAxis,
x: f32,
baseline_y: f32,
considered_font_size: f32,
writing_mode: WritingMode,
underline_position: TextUnderlinePosition,
underline_offset: TextUnderlineOffset,
metrics: &TextDecorationFontMetrics,
thickness: f32,
kind: TextDecorationPreparedLineKind,
) -> f32 {
match axis {
TextDecorationStrokeAxis::Horizontal => match kind {
TextDecorationPreparedLineKind::Underline => {
used_underline_y(
baseline_y,
underline_position,
underline_offset,
considered_font_size,
metrics,
) - thickness
}
TextDecorationPreparedLineKind::Overline => baseline_y + considered_font_size,
TextDecorationPreparedLineKind::LineThrough => baseline_y + metrics.strikeout_position,
},
TextDecorationStrokeAxis::Vertical => {
match kind {
TextDecorationPreparedLineKind::Underline => {
let offset = used_text_underline_offset(underline_offset, considered_font_size);
vertical_text_decoration_side_position(
x,
considered_font_size,
resolve_vertical_underline_side(underline_position, writing_mode),
thickness,
offset,
)
}
TextDecorationPreparedLineKind::Overline => vertical_text_decoration_side_position(
x,
considered_font_size,
opposite_text_decoration_side(resolve_vertical_underline_side(
underline_position,
writing_mode,
)),
thickness,
0.0,
),
TextDecorationPreparedLineKind::LineThrough => x + considered_font_size * 0.5,
}
}
}
}
pub(in crate::layout) fn resolve_vertical_underline_side(
position: TextUnderlinePosition,
writing_mode: WritingMode,
) -> TextDecorationSide {
if position.left {
return TextDecorationSide::Left;
}
if position.right {
return TextDecorationSide::Right;
}
match css::line_under_side(writing_mode) {
PhysicalSide::Left => TextDecorationSide::Left,
PhysicalSide::Right => TextDecorationSide::Right,
PhysicalSide::Top | PhysicalSide::Bottom => TextDecorationSide::Right,
}
}
pub(in crate::layout) fn opposite_text_decoration_side(
side: TextDecorationSide,
) -> TextDecorationSide {
match side {
TextDecorationSide::Left => TextDecorationSide::Right,
TextDecorationSide::Right => TextDecorationSide::Left,
}
}
pub(in crate::layout) fn vertical_text_decoration_side_position(
x: f32,
font_size: f32,
side: TextDecorationSide,
thickness: f32,
offset: f32,
) -> f32 {
match side {
TextDecorationSide::Left => x - thickness - offset,
TextDecorationSide::Right => x + font_size + offset,
}
}
pub(in crate::layout) fn apply_inline_fragment_edge_painting(
style: &mut ComputedStyle,
edges: InlineHangingEdges,
x: &mut f32,
y: &mut f32,
width: &mut f32,
height: &mut f32,
) {
let borders = used_border_widths(style);
let top_extra = borders.top + style.padding.top;
let bottom_extra = borders.bottom + style.padding.bottom;
*y -= bottom_extra;
*height += top_extra + bottom_extra;
let start_extra = match style.direction {
Direction::Ltr => borders.left + style.padding.left,
Direction::Rtl => borders.right + style.padding.right,
};
let end_extra = match style.direction {
Direction::Ltr => borders.right + style.padding.right,
Direction::Rtl => borders.left + style.padding.left,
};
if edges.blocks_start {
match style.direction {
Direction::Ltr => *x -= start_extra,
Direction::Rtl => {}
}
*width += start_extra;
} else {
match style.direction {
Direction::Ltr => {
style.border_widths.left = 0.0;
style.border_styles.left = BorderStyle::None;
style.padding.left = 0.0;
}
Direction::Rtl => {
style.border_widths.right = 0.0;
style.border_styles.right = BorderStyle::None;
style.padding.right = 0.0;
}
}
}
if edges.blocks_end {
match style.direction {
Direction::Ltr => {}
Direction::Rtl => *x -= end_extra,
}
*width += end_extra;
} else {
match style.direction {
Direction::Ltr => {
style.border_widths.right = 0.0;
style.border_styles.right = BorderStyle::None;
style.padding.right = 0.0;
}
Direction::Rtl => {
style.border_widths.left = 0.0;
style.border_styles.left = BorderStyle::None;
style.padding.left = 0.0;
}
}
}
}
pub(in crate::layout) fn inline_fragment_text_summary<F: InlineFragmentAccess>(
fragments: &[F],
preserve_leading_summary_space: bool,
synthesize_leading_summary_space: bool,
) -> String {
let mut summary = String::new();
for (index, fragment) in fragments.iter().enumerate() {
if index == 0 && synthesize_leading_summary_space {
summary.push(' ');
summary.push_str(fragment.text());
} else if index == 0
&& !preserve_leading_summary_space
&& fragment.style().white_space.collapses_spaces()
{
summary.push_str(trim_start_css_collapsible_whitespace(fragment.text()));
} else {
summary.push_str(fragment.text());
}
}
summary
}