1#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
6pub enum Trimming {
7 None,
9 #[default]
11 Character,
12 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#[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
62pub 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 let mut best: Option<String> = None;
72 let mut end = 0;
73 while end < chars.len() {
74 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 }
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
102pub 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 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 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 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
158pub 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
171pub 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 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
223pub 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 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 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 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 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}