use std::ops::Range;
use crate::{
layout::{quad::RichTextSpan, text_style::TextStyle},
markdown::{
Direction, FIRST_STRONG_ISOLATE, LEFT_TO_RIGHT_ISOLATE, LEFT_TO_RIGHT_MARK, POP_DIRECTIONAL_ISOLATE,
RIGHT_TO_LEFT_ISOLATE, RIGHT_TO_LEFT_MARK, WORD_JOINER, has_right_to_left, line_break_offsets,
},
};
#[derive(Clone, Copy, PartialEq, Eq)]
enum Role {
Mark,
Words,
Run,
}
pub(super) struct LinkBlock {
pub(super) spans: Vec<RichTextSpan>,
pub(super) generated: Vec<Range<usize>>,
pub(super) label: Range<usize>,
pub(super) trailing: Range<usize>,
pub(super) target: Range<usize>,
}
impl LinkBlock {
pub(super) fn new(
direction: Direction,
words: Vec<RichTextSpan>,
runs: Vec<RichTextSpan>,
style: &TextStyle,
) -> Self {
let mut pieces = Pieces::new(style);
match direction {
Direction::LeftToRight => {
pieces.mark(LEFT_TO_RIGHT_MARK);
pieces.mark(LEFT_TO_RIGHT_ISOLATE);
pieces.inside(|pieces| {
pieces.isolated_if_needed(Role::Words, words);
for run in runs {
pieces.isolated_if_needed(Role::Run, vec![run]);
}
});
pieces.mark(POP_DIRECTIONAL_ISOLATE);
pieces.mark(LEFT_TO_RIGHT_MARK);
}
Direction::RightToLeft => {
pieces.mark(RIGHT_TO_LEFT_MARK);
pieces.mark(RIGHT_TO_LEFT_ISOLATE);
pieces.inside(|pieces| {
pieces.mark(LEFT_TO_RIGHT_ISOLATE);
for run in runs {
pieces.isolated_if_needed(Role::Run, vec![run]);
}
pieces.mark(POP_DIRECTIONAL_ISOLATE);
pieces.mark(FIRST_STRONG_ISOLATE);
pieces.push(Role::Words, words);
pieces.mark(POP_DIRECTIONAL_ISOLATE);
});
pieces.mark(POP_DIRECTIONAL_ISOLATE);
pieces.mark(RIGHT_TO_LEFT_MARK);
}
}
pieces.join_words();
pieces.into_block()
}
}
struct Pieces<'s> {
spans: Vec<(Role, RichTextSpan)>,
inside: Range<usize>,
style: &'s TextStyle,
}
impl<'s> Pieces<'s> {
fn new(style: &'s TextStyle) -> Self {
Self {
spans: Vec::new(),
inside: 0..0,
style,
}
}
fn mark(&mut self, mark: char) {
self.spans.push((
Role::Mark,
RichTextSpan {
text: mark.to_string(),
style: self.style.clone(),
},
));
}
fn push(&mut self, role: Role, spans: Vec<RichTextSpan>) {
self.spans.extend(
spans
.into_iter()
.filter(|span| !span.text.is_empty())
.map(|span| (role, span)),
);
}
fn inside(&mut self, push: impl FnOnce(&mut Self)) {
let start = self.spans.len();
push(self);
self.inside = start..self.spans.len();
}
fn isolated_if_needed(&mut self, role: Role, spans: Vec<RichTextSpan>) {
if spans.iter().any(|span| has_right_to_left(&span.text)) {
self.mark(FIRST_STRONG_ISOLATE);
self.push(role, spans);
self.mark(POP_DIRECTIONAL_ISOLATE);
} else {
self.push(role, spans);
}
}
fn join_words(&mut self) {
let after = self.spans.split_off(self.inside.end);
let inside = self.spans.split_off(self.inside.start);
let text: String = inside.iter().map(|(_, span)| span.text.as_str()).collect();
let mut breaks = line_break_offsets(&text).peekable();
let mut offset = 0;
let start = self.spans.len();
for (role, span) in inside {
let end = offset + span.text.len();
let mut from = 0;
while let Some(at) = breaks.next_if(|at| *at <= end) {
let split = at - offset;
if split > from {
self.spans.push((role, piece_of(&span, from..split)));
}
self.spans.push((
Role::Mark,
RichTextSpan {
text: WORD_JOINER.to_string(),
style: span.style.clone(),
},
));
from = split;
}
if from < span.text.len() {
self.spans.push((role, piece_of(&span, from..span.text.len())));
}
offset = end;
}
self.inside = start..self.spans.len();
self.spans.extend(after);
}
fn into_block(self) -> LinkBlock {
let span_of = |role: Role| {
let has_role = |(span_role, _): &(Role, RichTextSpan)| *span_role == role;
match (
self.spans.iter().position(has_role),
self.spans.iter().rposition(has_role),
) {
(Some(first), Some(last)) => first..last + 1,
_ => 0..0,
}
};
let label = span_of(Role::Words);
let trailing = span_of(Role::Run);
let generated = self
.spans
.iter()
.enumerate()
.filter(|(_, (role, _))| *role != Role::Words)
.map(|(index, _)| index..index + 1)
.collect();
LinkBlock {
spans: self.spans.into_iter().map(|(_, span)| span).collect(),
generated,
label,
trailing,
target: self.inside,
}
}
}
fn piece_of(span: &RichTextSpan, bytes: Range<usize>) -> RichTextSpan {
RichTextSpan {
text: span.text[bytes].to_owned(),
style: span.style.clone(),
}
}