Skip to main content

aylis_core/
text.rs

1//! Disposição de texto em linhas: quebra automática e reticências ("…"), iguais em todos
2//! os renderizadores (Skia, navegador).
3
4/// O que fazer quando o texto não cabe na largura.
5#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
6pub enum Trimming {
7    /// Não corta: o texto passa da borda (e o controle recorta).
8    None,
9    /// Corta no caractere e põe "…".
10    #[default]
11    Character,
12    /// Corta na palavra inteira e põe "…".
13    Word,
14}
15
16impl crate::prop::PropEnum for Trimming {
17    const NAMES: &'static [&'static str] = &["none", "character", "word"];
18
19    fn from_index(index: usize) -> Option<Self> {
20        [Trimming::None, Trimming::Character, Trimming::Word].get(index).copied()
21    }
22
23    fn index(self) -> usize {
24        self as usize
25    }
26}
27
28/// Maiúsculas ou minúsculas na hora de desenhar (o `text-transform` do CSS): o texto
29/// guardado não muda.
30#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
31pub enum TextCase {
32    #[default]
33    None,
34    Upper,
35    Lower,
36}
37
38impl TextCase {
39    pub fn apply(self, text: &str) -> String {
40        match self {
41            TextCase::None => text.to_string(),
42            TextCase::Upper => text.to_uppercase(),
43            TextCase::Lower => text.to_lowercase(),
44        }
45    }
46}
47
48impl crate::prop::PropEnum for TextCase {
49    const NAMES: &'static [&'static str] = &["none", "upper", "lower"];
50
51    fn from_index(index: usize) -> Option<Self> {
52        [TextCase::None, TextCase::Upper, TextCase::Lower].get(index).copied()
53    }
54
55    fn index(self) -> usize {
56        self as usize
57    }
58}
59
60const ELLIPSIS: &str = "…";
61
62/// Corta `text` para caber em `width` com "…" no fim (por caractere ou por palavra).
63/// Sem corte (`Trimming::None`) ou se já couber, devolve igual.
64pub fn trim_line(text: &str, width: f32, trimming: Trimming, measure: &mut dyn FnMut(&str) -> f32) -> String {
65    if trimming == Trimming::None || measure(text) <= width {
66        return text.to_string();
67    }
68    let chars: Vec<char> = text.chars().collect();
69    if trimming == Trimming::Word {
70        // O maior número de palavras inteiras que cabe junto com "…".
71        let mut best: Option<String> = None;
72        let mut end = 0;
73        while end < chars.len() {
74            // fim da próxima palavra
75            while end < chars.len() && chars[end].is_whitespace() {
76                end += 1;
77            }
78            while end < chars.len() && !chars[end].is_whitespace() {
79                end += 1;
80            }
81            let candidate: String = chars[..end].iter().collect::<String>().trim_end().to_string() + ELLIPSIS;
82            if measure(&candidate) <= width {
83                best = Some(candidate);
84            } else {
85                break;
86            }
87        }
88        if let Some(b) = best {
89            return b;
90        }
91        // Nem a primeira palavra cabe: corta no caractere.
92    }
93    let (mut lo, mut hi) = (0usize, chars.len());
94    while lo < hi {
95        let mid = (lo + hi).div_ceil(2);
96        let candidate = chars[..mid].iter().collect::<String>() + ELLIPSIS;
97        if measure(&candidate) <= width { lo = mid } else { hi = mid - 1 }
98    }
99    chars[..lo].iter().collect::<String>().trim_end().to_string() + ELLIPSIS
100}
101
102/// Quebra uma linha (sem `\n`) em pedaços que cabem em `width`: nos espaços e, se uma
103/// palavra sozinha não couber, no caractere. Devolve as posições (em caracteres) de
104/// início e fim de cada pedaço; o espaço da quebra fica no fim do pedaço de cima.
105pub fn wrap_ranges(line: &str, width: f32, measure: &mut dyn FnMut(&str) -> f32) -> Vec<(usize, usize)> {
106    let chars: Vec<char> = line.chars().collect();
107    let text = |a: usize, b: usize| chars[a..b].iter().collect::<String>();
108    let mut out = Vec::new();
109    let mut start = 0;
110    if chars.is_empty() {
111        return vec![(0, 0)];
112    }
113    while start < chars.len() {
114        // Avança palavra por palavra enquanto couber.
115        let mut end = start;
116        let mut fits_end = start;
117        loop {
118            let mut next = end;
119            while next < chars.len() && chars[next].is_whitespace() {
120                next += 1;
121            }
122            while next < chars.len() && !chars[next].is_whitespace() {
123                next += 1;
124            }
125            if next == end {
126                break;
127            }
128            if measure(text(start, next).trim_end()) <= width {
129                fits_end = next;
130                end = next;
131                if next >= chars.len() {
132                    break;
133                }
134            } else {
135                break;
136            }
137        }
138        if fits_end == start {
139            // Uma palavra maior que a largura: corta no caractere (pelo menos um).
140            let (mut lo, mut hi) = (start + 1, chars.len());
141            while lo < hi {
142                let mid = (lo + hi).div_ceil(2);
143                if measure(&text(start, mid)) <= width { lo = mid } else { hi = mid - 1 }
144            }
145            fits_end = lo.max(start + 1);
146        } else {
147            // Os espaços depois da última palavra ficam nesta linha.
148            while fits_end < chars.len() && chars[fits_end].is_whitespace() {
149                fits_end += 1;
150            }
151        }
152        out.push((start, fits_end));
153        start = fits_end;
154    }
155    out
156}
157
158/// As linhas a desenhar de `text` numa área de `width` × até `max_lines` linhas:
159/// respeita `\n`, quebra com `wrap` e corta com "…" o que não couber (com `trimming`).
160pub fn layout_lines(
161    text: &str,
162    width: f32,
163    max_lines: usize,
164    wrap: bool,
165    trimming: Trimming,
166    measure: &mut dyn FnMut(&str) -> f32,
167) -> Vec<String> {
168    layout_lines_marked(text, width, max_lines, wrap, trimming, measure).into_iter().map(|(line, _)| line).collect()
169}
170
171/// Como [`layout_lines`], dizendo também se cada linha fecha um parágrafo (vem antes de
172/// um `\n`, é a última do texto ou terminou em "…"): o justificado deixa essas à esquerda.
173pub fn layout_lines_marked(
174    text: &str,
175    width: f32,
176    max_lines: usize,
177    wrap: bool,
178    trimming: Trimming,
179    measure: &mut dyn FnMut(&str) -> f32,
180) -> Vec<(String, bool)> {
181    let max_lines = max_lines.max(1);
182    let mut lines: Vec<(String, bool)> = Vec::new();
183    let mut more = false;
184    'outer: for line in text.split('\n') {
185        let pieces: Vec<String> = if wrap {
186            let chars: Vec<char> = line.chars().collect();
187            wrap_ranges(line, width, measure).into_iter().map(|(a, b)| chars[a..b].iter().collect::<String>().trim_end().to_string()).collect()
188        } else {
189            vec![line.to_string()]
190        };
191        let count = pieces.len();
192        for (i, piece) in pieces.into_iter().enumerate() {
193            if lines.len() == max_lines {
194                more = true;
195                break 'outer;
196            }
197            lines.push((piece, i + 1 == count));
198        }
199    }
200    if !wrap {
201        for (l, _) in &mut lines {
202            *l = trim_line(l, width, trimming, measure);
203        }
204    }
205    // Sobrou texto além da última linha: ela termina em "…".
206    if more && trimming != Trimming::None {
207        if let Some((last, end)) = lines.last_mut() {
208            *end = true;
209            let base = last.trim_end().to_string();
210            let mut candidate = base.clone() + ELLIPSIS;
211            if measure(&candidate) > width {
212                candidate = trim_line(&(base + "  "), width, trimming, measure);
213                if !candidate.ends_with(ELLIPSIS) {
214                    candidate.push_str(ELLIPSIS);
215                }
216            }
217            *last = candidate;
218        }
219    }
220    lines
221}
222
223/// Uma linha justificada: as palavras e o `x` de cada uma (a partir da esquerda), com o
224/// espaço que sobra em `width` dividido entre elas. `None` quando a linha fica como está
225/// (à esquerda): uma palavra só ou mais larga que a área. Os espaços do começo (o recuo)
226/// ficam antes da primeira palavra.
227pub fn justify_line(line: &str, width: f32, measure: &mut dyn FnMut(&str) -> f32) -> Option<Vec<(f32, String)>> {
228    let body = line.trim_end();
229    let indent_len = body.len() - body.trim_start().len();
230    let indent = if indent_len > 0 { measure(&body[..indent_len]) } else { 0.0 };
231    let words: Vec<&str> = body.split_whitespace().collect();
232    if words.len() < 2 {
233        return None;
234    }
235    let widths: Vec<f32> = words.iter().map(|w| measure(w)).collect();
236    let free = width - indent - widths.iter().sum::<f32>();
237    if free <= 0.0 {
238        return None;
239    }
240    let gap = free / (words.len() - 1) as f32;
241    let mut x = indent;
242    let mut out = Vec::with_capacity(words.len());
243    for (word, w) in words.into_iter().zip(widths) {
244        out.push((x, word.to_string()));
245        x += w + gap;
246    }
247    Some(out)
248}
249
250#[cfg(test)]
251mod tests {
252    use super::*;
253
254    /// Cada caractere mede 1.
255    fn m(s: &str) -> f32 {
256        s.chars().count() as f32
257    }
258
259    #[test]
260    fn trims_by_character_and_by_word() {
261        assert_eq!(trim_line("abc", 5.0, Trimming::Character, &mut m), "abc");
262        assert_eq!(trim_line("abcdefgh", 5.0, Trimming::Character, &mut m), "abcd…");
263        assert_eq!(trim_line("um dois tres", 9.0, Trimming::Word, &mut m), "um dois…");
264        assert_eq!(trim_line("um dois tres", 9.0, Trimming::Character, &mut m), "um dois…");
265        // nem a primeira palavra cabe: volta para o caractere
266        assert_eq!(trim_line("paralelepipedo", 6.0, Trimming::Word, &mut m), "paral…");
267        assert_eq!(trim_line("abcdefgh", 5.0, Trimming::None, &mut m), "abcdefgh");
268    }
269
270    #[test]
271    fn wraps_at_spaces_and_inside_long_words() {
272        assert_eq!(wrap_ranges("", 5.0, &mut m), [(0, 0)]);
273        assert_eq!(wrap_ranges("aa bb cc", 5.0, &mut m), [(0, 6), (6, 8)]);
274        assert_eq!(wrap_ranges("abcdefgh", 3.0, &mut m), [(0, 3), (3, 6), (6, 8)]);
275    }
276
277    #[test]
278    fn lays_out_lines_with_ellipsis_on_the_last_one() {
279        let lines = layout_lines("aa bb cc dd\nee", 5.0, 2, true, Trimming::Character, &mut m);
280        assert_eq!(lines, ["aa bb", "cc d…"]);
281        let lines = layout_lines("aa bb cc dd", 5.0, 2, false, Trimming::Word, &mut m);
282        assert_eq!(lines, ["aa…"]);
283        let lines = layout_lines("x\ny\nz", 5.0, 2, false, Trimming::None, &mut m);
284        assert_eq!(lines, ["x", "y"]);
285    }
286
287    #[test]
288    fn justifies_lines_except_the_last_of_each_paragraph() {
289        let lines = layout_lines_marked("aa b cc dd\nee", 6.0, 10, true, Trimming::None, &mut m);
290        assert_eq!(lines, [("aa b".to_string(), false), ("cc dd".to_string(), true), ("ee".to_string(), true)]);
291        // "aa b" em 6: sobram 3, divididos no único espaço.
292        let words = justify_line("aa b", 6.0, &mut m).unwrap();
293        assert_eq!(words, [(0.0, "aa".to_string()), (5.0, "b".to_string())]);
294        // Três palavras: o que sobra vai em partes iguais; o recuo fica.
295        let words = justify_line("  a b c", 9.0, &mut m).unwrap();
296        assert_eq!(words, [(2.0, "a".to_string()), (5.0, "b".to_string()), (8.0, "c".to_string())]);
297        assert!(justify_line("palavra", 20.0, &mut m).is_none(), "uma palavra só fica à esquerda");
298        assert!(justify_line("aa bb", 3.0, &mut m).is_none(), "não cabe: fica como está");
299    }
300}