1use crate::font_features::FontFeature;
22use crate::fonts::{FONT_REF_LEN, FONT_REF_SYSTEM, FontRefs};
23use crate::protocol::ProtocolError;
24use crate::schema::{OverflowWrap, TypeRole, WordBreak};
25use crate::spans::{SPAN_FONT_ENTRY_LEN, SPAN_FONT_OFFSET_AT, SPAN_LEN, TextSpans};
26use std::marker::PhantomData;
27
28pub const MEASURE_RECORD_LEN: usize = 88;
30pub const MEASURE_RESULT_LEN: usize = 32;
32
33pub const MEASURE_TEXT: u16 = 1;
35pub const MEASURE_NODE: u16 = 2;
37
38pub const MEASURE_KIND_AT: usize = 0;
40
41pub const TEXT_TYPE_ROLE_AT: usize = 2;
42pub const TEXT_TEXT_OFFSET_AT: usize = 4;
43pub const TEXT_TEXT_LENGTH_AT: usize = 8;
44pub const TEXT_SPANS_OFFSET_AT: usize = 12;
45pub const TEXT_SPANS_COUNT_AT: usize = 16;
46pub const TEXT_SPAN_FONTS_OFFSET_AT: usize = 20;
47pub const TEXT_SPAN_FONTS_COUNT_AT: usize = 24;
48pub const TEXT_FONT_OFFSET_AT: usize = 28;
49pub const TEXT_FONT_COUNT_AT: usize = 32;
50pub const TEXT_FONT_SIZE_AT: usize = 36;
51pub const TEXT_FONT_WEIGHT_AT: usize = 40;
52pub const TEXT_ITALIC_AT: usize = 42;
53pub const TEXT_WRAP_AT: usize = 43;
54pub const TEXT_LETTER_SPACING_AT: usize = 44;
55pub const TEXT_LINE_HEIGHT_AT: usize = 48;
56pub const TEXT_MAX_LINES_AT: usize = 52;
57pub const TEXT_TAB_SIZE_AT: usize = 56;
58pub const TEXT_WORD_BREAK_AT: usize = 57;
59pub const TEXT_OVERFLOW_WRAP_AT: usize = 58;
60pub const TEXT_ABSOLUTE_SIZE_AT: usize = 59;
61pub const TEXT_CONSTRAINT_AT: usize = 60;
62pub const TEXT_WIDTH_AT: usize = 64;
63pub const TEXT_ZOOM_AT: usize = 68;
64pub const TEXT_FONT_FEATURES_OFFSET_AT: usize = 72;
65pub const TEXT_FONT_FEATURES_COUNT_AT: usize = 76;
66pub const TEXT_SPAN_FEATURES_OFFSET_AT: usize = 80;
69pub const TEXT_SPAN_FEATURES_LENGTH_AT: usize = 84;
71
72pub const NODE_ID_AT: usize = 4;
73pub const NODE_MIN_WIDTH_AT: usize = 8;
74pub const NODE_MAX_WIDTH_AT: usize = 12;
75pub const NODE_MIN_HEIGHT_AT: usize = 16;
76pub const NODE_MAX_HEIGHT_AT: usize = 20;
77pub const NODE_ZOOM_AT: usize = 24;
78
79pub const CONSTRAINT_MIN_CONTENT: u32 = 1;
81pub const CONSTRAINT_MAX_CONTENT: u32 = 2;
83pub const CONSTRAINT_AT_MOST: u32 = 3;
85
86pub const RESULT_WIDTH_AT: usize = 0;
88pub const RESULT_HEIGHT_AT: usize = 4;
89pub const RESULT_FIRST_BASELINE_AT: usize = 8;
90pub const RESULT_LAST_BASELINE_AT: usize = 12;
91pub const RESULT_LAST_LINE_WIDTH_AT: usize = 16;
92pub const RESULT_LINE_COUNT_AT: usize = 20;
93pub const RESULT_FLAGS_AT: usize = 24;
94pub const RESULT_STATUS_AT: usize = 28;
95
96pub const FLAG_TRUNCATED: u32 = 1;
98
99pub const RESULT_OK: u32 = 0;
100pub const RESULT_UNKNOWN_NODE: u32 = 1;
103pub const RESULT_MALFORMED: u32 = 2;
105
106pub const MEASURE_UNREADABLE: i32 = -1;
108pub const MEASURE_OFF_UI_THREAD: i32 = -4;
111pub const MEASURE_UNAVAILABLE: i32 = -5;
115
116pub(crate) const SCHEMA_DESCRIPTOR: &str = concat!(
119 "measure=v1;record=88;result=32;",
120 "text=kind@0,type_role@2,text@4,spans@12,span_fonts@20,font@28,font_size@36,",
121 "font_weight@40,italic@42,wrap@43,letter_spacing@44,line_height@48,max_lines@52,",
122 "tab_size@56,word_break@57,overflow_wrap@58,absolute_size@59,constraint@60,width@64,",
123 "zoom@68,font_features@72,span_features@80;",
124 "node=kind@0,node@4,min_width@8,max_width@12,min_height@16,max_height@20,zoom@24;",
125 "result=width@0,height@4,first_baseline@8,last_baseline@12,last_line_width@16,",
126 "line_count@20,flags@24,status@28;",
127 "fontref=12,kind@0,value@4,length@8;spanfont=12,span@0,offset@4,count@8;",
128);
129
130#[repr(C)]
132#[derive(Clone, Copy, Debug, Default, PartialEq)]
133pub struct MeasureResult {
134 pub width: f32,
135 pub height: f32,
136 pub first_baseline: f32,
138 pub last_baseline: f32,
139 pub last_line_width: f32,
142 pub line_count: u32,
144 pub flags: u32,
145 pub status: u32,
146}
147
148const _: () = assert!(std::mem::size_of::<MeasureResult>() == MEASURE_RESULT_LEN);
149
150impl MeasureResult {
151 pub const REFUSED: Self = Self {
154 width: 0.0,
155 height: 0.0,
156 first_baseline: f32::NAN,
157 last_baseline: f32::NAN,
158 last_line_width: f32::NAN,
159 line_count: 0,
160 flags: 0,
161 status: RESULT_MALFORMED,
162 };
163
164 pub fn status(&self) -> MeasureStatus {
165 match self.status {
166 RESULT_OK => MeasureStatus::Ok,
167 RESULT_UNKNOWN_NODE => MeasureStatus::UnknownNode,
168 RESULT_MALFORMED => MeasureStatus::Malformed,
169 other => MeasureStatus::Other(other),
170 }
171 }
172
173 pub fn truncated(&self) -> bool {
175 self.flags & FLAG_TRUNCATED != 0
176 }
177}
178
179#[derive(Clone, Copy, Debug, Eq, PartialEq)]
181pub enum MeasureStatus {
182 Ok,
183 UnknownNode,
184 Malformed,
185 Other(u32),
187}
188
189#[derive(Clone, Copy, Debug, PartialEq)]
191pub enum TextConstraint {
192 MinContent,
194 MaxContent,
196 AtMost(f32),
198}
199
200#[derive(Clone, Debug, PartialEq)]
206pub struct TextStyle {
207 pub type_role: TypeRole,
208 pub font: FontRefs,
210 pub font_features: Vec<FontFeature>,
212 pub font_size: Option<f32>,
214 pub font_weight: Option<u16>,
216 pub italic: bool,
217 pub letter_spacing: Option<f32>,
219 pub line_height: Option<f32>,
221 pub max_lines: Option<u32>,
223 pub wrap: bool,
225 pub tab_size: u8,
227 pub word_break: Option<WordBreak>,
228 pub overflow_wrap: Option<OverflowWrap>,
229 pub absolute_size: bool,
231}
232
233impl Default for TextStyle {
234 fn default() -> Self {
235 Self {
236 type_role: TypeRole::Body,
237 font: FontRefs::default(),
238 font_features: Vec::new(),
239 font_size: None,
240 font_weight: None,
241 italic: false,
242 letter_spacing: None,
243 line_height: None,
244 max_lines: None,
245 wrap: true,
246 tab_size: 8,
247 word_break: None,
248 overflow_wrap: None,
249 absolute_size: false,
250 }
251 }
252}
253
254impl TextStyle {
255 pub fn role(role: TypeRole) -> Self {
257 Self {
258 type_role: role,
259 ..Self::default()
260 }
261 }
262}
263
264#[derive(Clone, Copy, Debug, PartialEq)]
266pub struct NodeConstraints {
267 pub min_width: f32,
268 pub max_width: f32,
269 pub min_height: f32,
270 pub max_height: f32,
271}
272
273impl NodeConstraints {
274 pub const UNBOUNDED: Self = Self {
276 min_width: 0.0,
277 max_width: f32::INFINITY,
278 min_height: 0.0,
279 max_height: f32::INFINITY,
280 };
281
282 pub const fn width(width: f32) -> Self {
284 Self {
285 min_width: width,
286 max_width: width,
287 min_height: 0.0,
288 max_height: f32::INFINITY,
289 }
290 }
291}
292
293#[derive(Clone, Copy, Debug)]
295struct PendingRecord {
296 bytes: [u8; MEASURE_RECORD_LEN],
297}
298
299#[derive(Clone, Copy)]
301struct SideTable {
302 entry_len: usize,
303 list_offset_at: usize,
304 list_count_at: usize,
305}
306
307#[derive(Debug, Default)]
312pub struct MeasureRequests {
313 records: Vec<PendingRecord>,
314 payload: Vec<u8>,
317 payload_patches: Vec<u32>,
320 buffer: Vec<u8>,
322 zoom: Option<f32>,
324}
325
326impl MeasureRequests {
327 pub fn new() -> Self {
328 Self::default()
329 }
330
331 pub fn set_zoom(&mut self, zoom: f32) {
339 self.zoom = Some(zoom);
340 }
341
342 pub fn clear(&mut self) {
344 self.records.clear();
345 self.payload.clear();
346 self.payload_patches.clear();
347 self.buffer.clear();
348 }
349
350 pub fn len(&self) -> usize {
352 self.records.len()
353 }
354
355 pub fn is_empty(&self) -> bool {
356 self.records.is_empty()
357 }
358
359 pub fn text(
362 &mut self,
363 text: &str,
364 spans: &TextSpans,
365 style: &TextStyle,
366 constraint: TextConstraint,
367 ) -> usize {
368 let mut record = [0u8; MEASURE_RECORD_LEN];
369 put_u16(&mut record, MEASURE_KIND_AT, MEASURE_TEXT);
370 put_u16(&mut record, TEXT_TYPE_ROLE_AT, style.type_role as u16);
371
372 let text_at = self.payload.len() as u32;
373 self.payload.extend_from_slice(text.as_bytes());
374 put_u32(&mut record, TEXT_TEXT_OFFSET_AT, text_at);
375 put_u32(&mut record, TEXT_TEXT_LENGTH_AT, text.len() as u32);
376
377 let runs = spans.as_bytes();
378 let spans_at = self.payload.len() as u32;
379 self.payload.extend_from_slice(runs);
380 put_u32(&mut record, TEXT_SPANS_OFFSET_AT, spans_at);
381 put_u32(
382 &mut record,
383 TEXT_SPANS_COUNT_AT,
384 (runs.len() / SPAN_LEN) as u32,
385 );
386
387 let (entries_at, entries) = self.copy_span_font_table(spans.font_table());
390 put_u32(&mut record, TEXT_SPAN_FONTS_OFFSET_AT, entries_at);
391 put_u32(&mut record, TEXT_SPAN_FONTS_COUNT_AT, entries);
392 let (font_at, fonts) = self.copy_font_list(style.font.as_bytes());
393 put_u32(&mut record, TEXT_FONT_OFFSET_AT, font_at);
394 put_u32(&mut record, TEXT_FONT_COUNT_AT, fonts);
395
396 put_f32(
397 &mut record,
398 TEXT_FONT_SIZE_AT,
399 style.font_size.unwrap_or(0.0),
400 );
401 put_u16(
402 &mut record,
403 TEXT_FONT_WEIGHT_AT,
404 style.font_weight.unwrap_or(0),
405 );
406 record[TEXT_ITALIC_AT] = u8::from(style.italic);
407 record[TEXT_WRAP_AT] = u8::from(style.wrap);
408 put_f32(
409 &mut record,
410 TEXT_LETTER_SPACING_AT,
411 style.letter_spacing.unwrap_or(f32::NAN),
412 );
413 put_f32(
414 &mut record,
415 TEXT_LINE_HEIGHT_AT,
416 style.line_height.unwrap_or(f32::NAN),
417 );
418 put_u32(&mut record, TEXT_MAX_LINES_AT, style.max_lines.unwrap_or(0));
419 record[TEXT_TAB_SIZE_AT] = style.tab_size;
420 record[TEXT_WORD_BREAK_AT] = style.word_break.map_or(0, |value| value as u8);
421 record[TEXT_OVERFLOW_WRAP_AT] = style.overflow_wrap.map_or(0, |value| value as u8);
422 record[TEXT_ABSOLUTE_SIZE_AT] = u8::from(style.absolute_size);
423 let (constraint, width) = match constraint {
424 TextConstraint::MinContent => (CONSTRAINT_MIN_CONTENT, 0.0),
425 TextConstraint::MaxContent => (CONSTRAINT_MAX_CONTENT, 0.0),
426 TextConstraint::AtMost(width) => (CONSTRAINT_AT_MOST, width),
427 };
428 put_u32(&mut record, TEXT_CONSTRAINT_AT, constraint);
429 put_f32(&mut record, TEXT_WIDTH_AT, width);
430 put_f32(&mut record, TEXT_ZOOM_AT, self.zoom.unwrap_or(0.0));
431 let features_at = self.payload.len() as u32;
432 for feature in &style.font_features {
433 self.payload.extend_from_slice(&feature.to_bytes());
434 }
435 put_u32(&mut record, TEXT_FONT_FEATURES_OFFSET_AT, features_at);
436 put_u32(
437 &mut record,
438 TEXT_FONT_FEATURES_COUNT_AT,
439 style.font_features.len() as u32,
440 );
441 let table = spans.feature_table();
445 let span_features_at = self.payload.len() as u32;
446 self.payload.extend_from_slice(table);
447 put_u32(&mut record, TEXT_SPAN_FEATURES_OFFSET_AT, span_features_at);
448 put_u32(
449 &mut record,
450 TEXT_SPAN_FEATURES_LENGTH_AT,
451 table.len() as u32,
452 );
453 self.records.push(PendingRecord { bytes: record });
454 self.records.len() - 1
455 }
456
457 pub fn node(&mut self, node_id: u32, constraints: NodeConstraints) -> usize {
460 let mut record = [0u8; MEASURE_RECORD_LEN];
461 put_u16(&mut record, MEASURE_KIND_AT, MEASURE_NODE);
462 put_u32(&mut record, NODE_ID_AT, node_id);
463 put_f32(&mut record, NODE_MIN_WIDTH_AT, constraints.min_width);
464 put_f32(&mut record, NODE_MAX_WIDTH_AT, constraints.max_width);
465 put_f32(&mut record, NODE_MIN_HEIGHT_AT, constraints.min_height);
466 put_f32(&mut record, NODE_MAX_HEIGHT_AT, constraints.max_height);
467 put_f32(&mut record, NODE_ZOOM_AT, self.zoom.unwrap_or(0.0));
468 self.records.push(PendingRecord { bytes: record });
469 self.records.len() - 1
470 }
471
472 fn copy_font_list(&mut self, blob: &[u8]) -> (u32, u32) {
476 let at = self.payload.len();
477 if blob.len() < 4 {
478 return (at as u32, 0);
479 }
480 let count = read_u32(blob, 0);
481 self.payload.extend_from_slice(&blob[4..]);
482 let moved = (at as u32).wrapping_sub(4);
484 self.move_font_records(at, count, moved);
485 (at as u32, count)
486 }
487
488 fn copy_span_font_table(&mut self, table: &[u8]) -> (u32, u32) {
491 self.copy_side_table(
492 table,
493 SideTable {
494 entry_len: SPAN_FONT_ENTRY_LEN,
495 list_offset_at: SPAN_FONT_OFFSET_AT,
496 list_count_at: 8,
497 },
498 )
499 }
500
501 fn copy_side_table(&mut self, table: &[u8], layout: SideTable) -> (u32, u32) {
507 let at = self.payload.len();
508 if table.len() < 4 {
509 return (at as u32, 0);
510 }
511 let entries = read_u32(table, 0);
512 self.payload.extend_from_slice(&table[4..]);
513 let moved = (at as u32).wrapping_sub(4);
514 for entry in 0..entries as usize {
515 let start = at + entry * layout.entry_len;
516 let field = start + layout.list_offset_at;
517 if field + 4 > self.payload.len() {
518 break;
519 }
520 let list = read_u32(&self.payload, field).wrapping_add(moved);
521 self.payload[field..field + 4].copy_from_slice(&list.to_le_bytes());
522 self.payload_patches.push(field as u32);
523 let count = read_u32(&self.payload, start + layout.list_count_at);
524 self.move_font_records(list as usize, count, moved);
525 }
526 (at as u32, entries)
527 }
528
529 fn move_font_records(&mut self, at: usize, count: u32, moved: u32) {
532 for index in 0..count as usize {
533 let record = at + index * FONT_REF_LEN;
534 if record + FONT_REF_LEN > self.payload.len() {
535 break;
536 }
537 if read_u32(&self.payload, record) != FONT_REF_SYSTEM {
538 continue;
539 }
540 let field = record + 4;
541 let name = read_u32(&self.payload, field).wrapping_add(moved);
542 self.payload[field..field + 4].copy_from_slice(&name.to_le_bytes());
543 self.payload_patches.push(field as u32);
544 }
545 }
546
547 pub fn encoded(&mut self) -> &[u8] {
550 self.finish().0
551 }
552
553 fn finish(&mut self) -> (&[u8], u32) {
556 let base = (self.records.len() * MEASURE_RECORD_LEN) as u32;
557 self.buffer.clear();
558 self.buffer.reserve(base as usize + self.payload.len());
559 for record in &self.records {
560 let mut bytes = record.bytes;
561 if u16::from_le_bytes([bytes[0], bytes[1]]) == MEASURE_TEXT {
562 for field in [
563 TEXT_TEXT_OFFSET_AT,
564 TEXT_SPANS_OFFSET_AT,
565 TEXT_SPAN_FONTS_OFFSET_AT,
566 TEXT_FONT_OFFSET_AT,
567 TEXT_FONT_FEATURES_OFFSET_AT,
568 TEXT_SPAN_FEATURES_OFFSET_AT,
569 ] {
570 let value = read_u32(&bytes, field) + base;
571 put_u32(&mut bytes, field, value);
572 }
573 }
574 self.buffer.extend_from_slice(&bytes);
575 }
576 let payload_at = self.buffer.len();
577 self.buffer.extend_from_slice(&self.payload);
578 for &patch in &self.payload_patches {
579 let at = payload_at + patch as usize;
580 let value = read_u32(&self.buffer, at) + base;
581 self.buffer[at..at + 4].copy_from_slice(&value.to_le_bytes());
582 }
583 (&self.buffer, self.records.len() as u32)
584 }
585}
586
587pub struct Measurer {
592 _on_this_thread: PhantomData<*const ()>,
593}
594
595#[derive(Clone, Debug, Eq, PartialEq)]
597pub enum MeasureError {
598 OutsideHostCall,
600 Refused(ProtocolError),
603}
604
605pub fn measurer() -> Result<Measurer, MeasureError> {
608 if crate::boundary::in_host_call() {
609 Ok(Measurer {
610 _on_this_thread: PhantomData,
611 })
612 } else {
613 Err(MeasureError::OutsideHostCall)
614 }
615}
616
617impl Measurer {
618 pub fn measure(
626 &mut self,
627 requests: &mut MeasureRequests,
628 results: &mut Vec<MeasureResult>,
629 ) -> Result<(), MeasureError> {
630 let (buffer, count) = requests.finish();
631 results.clear();
632 results.resize(count as usize, MeasureResult::default());
633 self.measure_encoded(buffer, count, results)
634 }
635
636 pub fn measure_encoded(
639 &mut self,
640 buffer: &[u8],
641 count: u32,
642 results: &mut [MeasureResult],
643 ) -> Result<(), MeasureError> {
644 if results.len() < count as usize {
645 return Err(MeasureError::Refused(ProtocolError::LengthOverflow));
646 }
647 if count == 0 {
648 return Ok(());
649 }
650 let length = u32::try_from(buffer.len())
651 .map_err(|_| MeasureError::Refused(ProtocolError::LengthOverflow))?;
652 let status =
653 crate::boundary::renderer_measure(buffer.as_ptr(), length, count, results.as_mut_ptr());
654 if status < 0 {
655 for result in results.iter_mut().take(count as usize) {
656 *result = MeasureResult::REFUSED;
657 }
658 report_refusal(status);
659 return Err(MeasureError::Refused(ProtocolError::MeasureRefused(status)));
660 }
661 Ok(())
662 }
663}
664
665fn report_refusal(status: i32) {
669 use std::sync::atomic::{AtomicU32, Ordering};
670 static SAID: AtomicU32 = AtomicU32::new(0);
671 let bit = 1u32 << (status.unsigned_abs().min(31));
672 if SAID.fetch_or(bit, Ordering::Relaxed) & bit != 0 {
673 return;
674 }
675 let reason = match status {
676 MEASURE_UNREADABLE => "the request buffer could not be read",
677 MEASURE_OFF_UI_THREAD => "the call was made off the Renderer's UI thread",
678 MEASURE_UNAVAILABLE => {
679 "the Renderer has nothing to measure with yet (no first frame, or no renderer)"
680 }
681 _ => "the Renderer gave no reason",
682 };
683 eprintln!(
684 "compose-rust: a measure call was refused with status {status}: {reason}. Every \
685 size in it is zero and the layout carried on."
686 );
687}
688
689fn put_u16(bytes: &mut [u8], at: usize, value: u16) {
690 bytes[at..at + 2].copy_from_slice(&value.to_le_bytes());
691}
692
693fn put_u32(bytes: &mut [u8], at: usize, value: u32) {
694 bytes[at..at + 4].copy_from_slice(&value.to_le_bytes());
695}
696
697fn put_f32(bytes: &mut [u8], at: usize, value: f32) {
698 bytes[at..at + 4].copy_from_slice(&value.to_bits().to_le_bytes());
699}
700
701fn read_u32(bytes: &[u8], at: usize) -> u32 {
702 u32::from_le_bytes([bytes[at], bytes[at + 1], bytes[at + 2], bytes[at + 3]])
703}
704
705pub const FAKE_FONT_SIZE: f32 = 14.0;
716
717#[doc(hidden)]
725pub unsafe extern "C" fn fake_measure(
726 requests: *const u8,
727 length: u32,
728 count: u32,
729 results: *mut MeasureResult,
730) -> i32 {
731 if !crate::boundary::in_host_call() {
732 return MEASURE_OFF_UI_THREAD;
733 }
734 if requests.is_null() || results.is_null() {
735 return MEASURE_UNREADABLE;
736 }
737 let buffer = unsafe { std::slice::from_raw_parts(requests, length as usize) };
739 let results = unsafe { std::slice::from_raw_parts_mut(results, count as usize) };
741 fake_measure_slices(buffer, results)
742}
743
744#[doc(hidden)]
746pub fn fake_measure_slices(buffer: &[u8], results: &mut [MeasureResult]) -> i32 {
747 let count = results.len();
748 if buffer.len() < count * MEASURE_RECORD_LEN {
749 return MEASURE_UNREADABLE;
750 }
751 for (index, result) in results.iter_mut().enumerate() {
752 let record = &buffer[index * MEASURE_RECORD_LEN..(index + 1) * MEASURE_RECORD_LEN];
753 *result = fake_one(buffer, record);
754 }
755 0
756}
757
758fn fake_one(buffer: &[u8], record: &[u8]) -> MeasureResult {
759 let malformed = MeasureResult {
760 status: RESULT_MALFORMED,
761 ..MeasureResult::REFUSED
762 };
763 match u16::from_le_bytes([record[0], record[1]]) {
764 MEASURE_NODE => MeasureResult {
765 status: RESULT_UNKNOWN_NODE,
766 ..MeasureResult::REFUSED
767 },
768 MEASURE_TEXT => {
769 let at = read_u32(record, TEXT_TEXT_OFFSET_AT) as usize;
770 let length = read_u32(record, TEXT_TEXT_LENGTH_AT) as usize;
771 let Some(text) = at
772 .checked_add(length)
773 .and_then(|end| buffer.get(at..end))
774 .and_then(|bytes| std::str::from_utf8(bytes).ok())
775 else {
776 return malformed;
777 };
778 let size = f32::from_bits(read_u32(record, TEXT_FONT_SIZE_AT));
779 let size = if size > 0.0 { size } else { FAKE_FONT_SIZE };
780 let line_height = f32::from_bits(read_u32(record, TEXT_LINE_HEIGHT_AT));
781 let line_height = if line_height.is_nan() || line_height <= 0.0 {
782 size * 1.25
783 } else {
784 line_height
785 };
786 let max_lines = read_u32(record, TEXT_MAX_LINES_AT);
787 let wrap = record[TEXT_WRAP_AT] != 0;
788 let advance = size * 0.5;
789 let width = f32::from_bits(read_u32(record, TEXT_WIDTH_AT));
790 let lines = match read_u32(record, TEXT_CONSTRAINT_AT) {
791 CONSTRAINT_MIN_CONTENT => {
792 fake_lines(text, if wrap { 0.0 } else { f32::INFINITY }, advance)
793 }
794 CONSTRAINT_MAX_CONTENT => fake_lines(text, f32::INFINITY, advance),
795 CONSTRAINT_AT_MOST if width >= 0.0 => {
796 fake_lines(text, if wrap { width } else { f32::INFINITY }, advance)
797 }
798 _ => return malformed,
799 };
800 let shown = if max_lines == 0 {
801 lines.len()
802 } else {
803 lines.len().min(max_lines as usize)
804 };
805 let widest = lines[..shown].iter().copied().fold(0.0f32, f32::max);
806 MeasureResult {
807 width: widest,
808 height: shown as f32 * line_height,
809 first_baseline: size,
810 last_baseline: (shown.max(1) - 1) as f32 * line_height + size,
811 last_line_width: lines[shown.max(1) - 1],
812 line_count: shown as u32,
813 flags: if shown < lines.len() {
814 FLAG_TRUNCATED
815 } else {
816 0
817 },
818 status: RESULT_OK,
819 }
820 }
821 _ => malformed,
822 }
823}
824
825fn fake_lines(text: &str, width: f32, advance: f32) -> Vec<f32> {
828 let mut lines = Vec::new();
829 for paragraph in text.split('\n') {
830 let mut line = 0usize;
831 for word in paragraph.split(' ') {
832 let word_length = word.chars().count();
833 let joined = if line == 0 {
834 word_length
835 } else {
836 line + 1 + word_length
837 };
838 if line != 0 && joined as f32 * advance > width {
839 lines.push(line as f32 * advance);
840 line = word_length;
841 } else {
842 line = joined;
843 }
844 }
845 lines.push(line as f32 * advance);
846 }
847 lines
848}
849
850#[cfg(test)]
851mod side_table_tests {
852 use super::*;
853
854 fn table() -> Vec<u8> {
857 let mut t = Vec::new();
858 t.extend_from_slice(&1u32.to_le_bytes());
859 t.extend_from_slice(&7u32.to_le_bytes());
860 t.extend_from_slice(&(4 + SPAN_FONT_ENTRY_LEN as u32).to_le_bytes());
861 t.extend_from_slice(&1u32.to_le_bytes());
862 let name_at = 4 + SPAN_FONT_ENTRY_LEN as u32 + FONT_REF_LEN as u32;
863 t.extend_from_slice(&FONT_REF_SYSTEM.to_le_bytes());
864 t.extend_from_slice(&name_at.to_le_bytes());
865 t.resize(4 + SPAN_FONT_ENTRY_LEN + FONT_REF_LEN, 0);
866 t.extend_from_slice(b"name");
867 t
868 }
869
870 #[test]
871 fn pr2_side_table_copy_moves_offsets_and_keeps_the_bytes() {
872 let mut requests = MeasureRequests::new();
873 requests.payload.extend_from_slice(&[0xAA; 10]);
874 let table = table();
875 let (at, entries) = requests.copy_span_font_table(&table);
876 assert_eq!((at, entries), (10, 1));
877 let moved = 10u32 - 4;
878 let copied = &requests.payload[10..];
879 assert_eq!(copied.len(), table.len() - 4);
880 assert_eq!(
881 read_u32(copied, 0),
882 7,
883 "fields that are not offsets are untouched"
884 );
885 assert_eq!(
886 read_u32(copied, SPAN_FONT_OFFSET_AT),
887 table_u32(&table, 4 + SPAN_FONT_OFFSET_AT) + moved
888 );
889 assert_eq!(read_u32(copied, 8), 1);
890 let record = SPAN_FONT_ENTRY_LEN;
891 assert_eq!(
892 read_u32(copied, record + 4),
893 table_u32(&table, 4 + record + 4) + moved
894 );
895 assert_eq!(&copied[copied.len() - 4..], b"name");
896 assert_eq!(requests.payload_patches.len(), 2);
897 assert_eq!(
898 requests.copy_span_font_table(&[]),
899 (requests.payload.len() as u32, 0)
900 );
901 }
902
903 fn table_u32(table: &[u8], at: usize) -> u32 {
904 read_u32(table, at)
905 }
906}