1use std::convert::From;
6use std::fmt;
7use std::ops::{Add, AddAssign, Neg, Sub, SubAssign};
8use std::sync::atomic::{AtomicI32, Ordering};
9
10use app_units::Au;
11use euclid::{Point2D, Size2D};
12use layout_api::WritingModeExt;
13use malloc_size_of_derive::MallocSizeOf;
14use style::Zero;
15use style::logical_geometry::{BlockFlowDirection, InlineBaseDirection, WritingMode};
16use style::values::computed::{CSSPixelLength, LengthPercentage};
17use style::values::generics::length::GenericLengthPercentageOrAuto as AutoOr;
18use style_traits::CSSPixel;
19
20use crate::containing_block::ContainingBlock;
21use crate::sizing::Size;
22
23pub type PhysicalPoint<U> = euclid::Point2D<U, CSSPixel>;
24pub type PhysicalSize<U> = euclid::Size2D<U, CSSPixel>;
25pub type PhysicalVec<U> = euclid::Vector2D<U, CSSPixel>;
26pub type PhysicalRect<U> = euclid::Rect<U, CSSPixel>;
27pub type PhysicalSides<U> = euclid::SideOffsets2D<U, CSSPixel>;
28pub type AuOrAuto = AutoOr<Au>;
29pub type LengthPercentageOrAuto<'a> = AutoOr<&'a LengthPercentage>;
30
31#[derive(Clone, Copy, Default, MallocSizeOf, PartialEq)]
32pub struct LogicalVec2<T> {
33 pub inline: T,
34 pub block: T,
35}
36
37#[derive(Clone, Copy, Default, MallocSizeOf, PartialEq)]
38pub struct LogicalRect<T> {
39 pub start_corner: LogicalVec2<T>,
40 pub size: LogicalVec2<T>,
41}
42
43#[derive(Clone, Copy, Debug, Default)]
44pub struct LogicalSides<T> {
45 pub inline_start: T,
46 pub inline_end: T,
47 pub block_start: T,
48 pub block_end: T,
49}
50
51#[derive(Clone, Copy, Debug, Default, MallocSizeOf, PartialEq)]
52pub(crate) struct LogicalSides1D<T> {
53 pub start: T,
54 pub end: T,
55}
56
57impl<T> LogicalSides1D<T> {
58 pub(crate) fn map<U>(&self, f: impl Fn(&T) -> U) -> LogicalSides1D<U> {
59 LogicalSides1D {
60 start: f(&self.start),
61 end: f(&self.end),
62 }
63 }
64}
65
66impl LogicalSides1D<AutoOr<&LengthPercentage>> {
67 pub(crate) fn percentages_relative_to(&self, basis: Au) -> LogicalSides1D<AutoOr<Au>> {
68 self.map(|value| value.map(|length_percentage| length_percentage.to_used_value(basis)))
69 }
70}
71
72impl<T: fmt::Debug> fmt::Debug for LogicalVec2<T> {
73 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
74 f.write_str("Vec2 { i: ")?;
76 self.inline.fmt(f)?;
77 f.write_str(", b: ")?;
78 self.block.fmt(f)?;
79 f.write_str(" }")
80 }
81}
82
83impl<T: Copy> From<T> for LogicalVec2<T> {
84 fn from(value: T) -> Self {
85 Self {
86 inline: value,
87 block: value,
88 }
89 }
90}
91
92impl<T> LogicalVec2<T> {
93 pub fn map_inline_and_block_axes<U>(
94 &self,
95 inline_f: impl FnOnce(&T) -> U,
96 block_f: impl FnOnce(&T) -> U,
97 ) -> LogicalVec2<U> {
98 LogicalVec2 {
99 inline: inline_f(&self.inline),
100 block: block_f(&self.block),
101 }
102 }
103}
104
105impl<T: Clone> LogicalVec2<Size<T>> {
106 pub fn map_inline_and_block_sizes<U>(
107 &self,
108 inline_f: impl FnOnce(T) -> U,
109 block_f: impl FnOnce(T) -> U,
110 ) -> LogicalVec2<Size<U>> {
111 self.map_inline_and_block_axes(|size| size.map(inline_f), |size| size.map(block_f))
112 }
113}
114
115impl<T: Clone> LogicalVec2<T> {
116 pub(crate) fn from_physical_size(physical_size: &PhysicalSize<T>, mode: WritingMode) -> Self {
117 let (i, b) = if mode.is_horizontal() {
119 (&physical_size.width, &physical_size.height)
120 } else {
121 (&physical_size.height, &physical_size.width)
122 };
123 LogicalVec2 {
124 inline: i.clone(),
125 block: b.clone(),
126 }
127 }
128
129 pub fn map<U>(&self, f: impl Fn(&T) -> U) -> LogicalVec2<U> {
130 LogicalVec2 {
131 inline: f(&self.inline),
132 block: f(&self.block),
133 }
134 }
135
136 pub(crate) fn map_with<U, V>(
137 &self,
138 other: &LogicalVec2<U>,
139 f: impl Fn(&T, &U) -> V,
140 ) -> LogicalVec2<V> {
141 LogicalVec2 {
142 inline: f(&self.inline, &other.inline),
143 block: f(&self.block, &other.block),
144 }
145 }
146}
147
148impl<T: Add<Output = T> + Copy> Add<LogicalVec2<T>> for LogicalVec2<T> {
149 type Output = LogicalVec2<T>;
150 fn add(self, other: Self) -> Self::Output {
151 LogicalVec2 {
152 inline: self.inline + other.inline,
153 block: self.block + other.block,
154 }
155 }
156}
157
158impl<T: Sub<Output = T> + Copy> Sub<LogicalVec2<T>> for LogicalVec2<T> {
159 type Output = LogicalVec2<T>;
160 fn sub(self, other: Self) -> Self::Output {
161 LogicalVec2 {
162 inline: self.inline - other.inline,
163 block: self.block - other.block,
164 }
165 }
166}
167
168impl<T: AddAssign<T> + Copy> AddAssign<LogicalVec2<T>> for LogicalVec2<T> {
169 fn add_assign(&mut self, other: LogicalVec2<T>) {
170 self.inline += other.inline;
171 self.block += other.block;
172 }
173}
174
175impl<T: SubAssign<T> + Copy> SubAssign<LogicalVec2<T>> for LogicalVec2<T> {
176 fn sub_assign(&mut self, other: LogicalVec2<T>) {
177 self.inline -= other.inline;
178 self.block -= other.block;
179 }
180}
181
182impl<T: Neg<Output = T> + Copy> Neg for LogicalVec2<T> {
183 type Output = LogicalVec2<T>;
184 fn neg(self) -> Self::Output {
185 Self {
186 inline: -self.inline,
187 block: -self.block,
188 }
189 }
190}
191
192impl<T: Zero> LogicalVec2<T> {
193 pub fn zero() -> Self {
194 Self {
195 inline: T::zero(),
196 block: T::zero(),
197 }
198 }
199}
200
201impl<T: Clone> LogicalVec2<AutoOr<T>> {
202 pub fn auto_is(&self, f: impl Fn() -> T) -> LogicalVec2<T> {
203 self.map(|t| t.auto_is(&f))
204 }
205}
206
207impl<T: Zero> LogicalRect<T> {
208 pub fn zero() -> Self {
209 Self {
210 start_corner: LogicalVec2::zero(),
211 size: LogicalVec2::zero(),
212 }
213 }
214}
215
216impl fmt::Debug for LogicalRect<Au> {
217 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
218 write!(
219 f,
220 "Rect(i{}×b{} @ (i{},b{}))",
221 self.size.inline.to_f32_px(),
222 self.size.block.to_f32_px(),
223 self.start_corner.inline.to_f32_px(),
224 self.start_corner.block.to_f32_px(),
225 )
226 }
227}
228
229impl<T: Clone> LogicalVec2<T> {
230 pub fn to_physical_size(&self, mode: WritingMode) -> PhysicalSize<T> {
231 if mode.is_horizontal() {
233 PhysicalSize::new(self.inline.clone(), self.block.clone())
234 } else {
235 PhysicalSize::new(self.block.clone(), self.inline.clone())
236 }
237 }
238}
239
240impl LogicalVec2<Au> {
241 pub(crate) fn from_physical_point_deprecated(
245 point: &PhysicalPoint<Au>,
246 containing_block: &ContainingBlock,
247 ) -> LogicalVec2<Au> {
248 let writing_mode = containing_block.style.writing_mode;
249 let (inline, block) = if writing_mode.is_horizontal() {
250 (point.x, point.y)
251 } else {
252 (point.y, point.x)
253 };
254
255 let inline = flip(
256 inline,
257 Au::zero(),
258 containing_block.inline_size(),
259 writing_mode.is_inline_flipped(),
260 );
261
262 LogicalVec2 { inline, block }
263 }
264
265 pub(crate) fn to_physical_offset(self, mode: WritingMode) -> PhysicalVec<Au> {
267 let inline = if mode.is_inline_flipped() {
268 -self.inline
269 } else {
270 self.inline
271 };
272 let block = if mode.is_block_flipped() {
273 -self.block
274 } else {
275 self.block
276 };
277
278 if mode.is_horizontal() {
279 PhysicalVec::new(inline, block)
280 } else {
281 debug_assert!(mode.is_vertical());
282 PhysicalVec::new(block, inline)
283 }
284 }
285
286 pub(crate) fn to_physical_offset_deprecated(self, mode: WritingMode) -> PhysicalVec<Au> {
289 let inline = if mode.is_inline_flipped() {
290 -self.inline
291 } else {
292 self.inline
293 };
294 if mode.is_horizontal() {
295 PhysicalVec::new(inline, self.block)
296 } else {
297 debug_assert!(mode.is_vertical());
298 PhysicalVec::new(self.block, inline)
299 }
300 }
301}
302
303impl<T: Clone> LogicalSides<T> {
304 pub(crate) fn from_physical(sides: &PhysicalSides<T>, mode: WritingMode) -> Self {
305 let block_flow = mode.block_flow_direction();
307 let (bs, be) = match mode.block_flow_direction() {
308 BlockFlowDirection::TopToBottom => (&sides.top, &sides.bottom),
309 BlockFlowDirection::RightToLeft => (&sides.right, &sides.left),
310 BlockFlowDirection::LeftToRight => (&sides.left, &sides.right),
311 };
312 use BlockFlowDirection::TopToBottom;
313 let (is, ie) = match (block_flow, mode.inline_base_direction()) {
314 (TopToBottom, InlineBaseDirection::LeftToRight) => (&sides.left, &sides.right),
315 (TopToBottom, InlineBaseDirection::RightToLeft) => (&sides.right, &sides.left),
316 (_, InlineBaseDirection::LeftToRight) => (&sides.top, &sides.bottom),
317 (_, InlineBaseDirection::RightToLeft) => (&sides.bottom, &sides.top),
318 };
319 Self {
320 inline_start: is.clone(),
321 inline_end: ie.clone(),
322 block_start: bs.clone(),
323 block_end: be.clone(),
324 }
325 }
326}
327
328impl<T> LogicalSides<T> {
329 pub fn map<U>(&self, f: impl Fn(&T) -> U) -> LogicalSides<U> {
330 LogicalSides {
331 inline_start: f(&self.inline_start),
332 inline_end: f(&self.inline_end),
333 block_start: f(&self.block_start),
334 block_end: f(&self.block_end),
335 }
336 }
337
338 pub fn map_inline_and_block_axes<U>(
339 &self,
340 inline_f: impl Fn(&T) -> U,
341 block_f: impl Fn(&T) -> U,
342 ) -> LogicalSides<U> {
343 LogicalSides {
344 inline_start: inline_f(&self.inline_start),
345 inline_end: inline_f(&self.inline_end),
346 block_start: block_f(&self.block_start),
347 block_end: block_f(&self.block_end),
348 }
349 }
350
351 pub fn inline_sum(&self) -> T::Output
352 where
353 T: Add + Copy,
354 {
355 self.inline_start + self.inline_end
356 }
357
358 pub fn block_sum(&self) -> T::Output
359 where
360 T: Add + Copy,
361 {
362 self.block_start + self.block_end
363 }
364
365 pub fn sum(&self) -> LogicalVec2<T::Output>
366 where
367 T: Add + Copy,
368 {
369 LogicalVec2 {
370 inline: self.inline_sum(),
371 block: self.block_sum(),
372 }
373 }
374
375 pub fn to_physical(&self, mode: WritingMode) -> PhysicalSides<T>
376 where
377 T: Clone,
378 {
379 let top;
380 let right;
381 let bottom;
382 let left;
383 if mode.is_vertical() {
384 if mode.is_vertical_lr() {
385 left = self.block_start.clone();
386 right = self.block_end.clone();
387 } else {
388 right = self.block_start.clone();
389 left = self.block_end.clone();
390 }
391
392 if mode.is_inline_tb() {
393 top = self.inline_start.clone();
394 bottom = self.inline_end.clone();
395 } else {
396 bottom = self.inline_start.clone();
397 top = self.inline_end.clone();
398 }
399 } else {
400 top = self.block_start.clone();
401 bottom = self.block_end.clone();
402 if mode.is_bidi_ltr() {
403 left = self.inline_start.clone();
404 right = self.inline_end.clone();
405 } else {
406 right = self.inline_start.clone();
407 left = self.inline_end.clone();
408 }
409 }
410 PhysicalSides::new(top, right, bottom, left)
411 }
412}
413
414impl<T: Copy> LogicalSides<T> {
415 pub fn start_offset(&self) -> LogicalVec2<T> {
416 LogicalVec2 {
417 inline: self.inline_start,
418 block: self.block_start,
419 }
420 }
421
422 #[inline]
423 pub(crate) fn inline_sides(&self) -> LogicalSides1D<T> {
424 LogicalSides1D::new(self.inline_start, self.inline_end)
425 }
426
427 #[inline]
428 pub(crate) fn block_sides(&self) -> LogicalSides1D<T> {
429 LogicalSides1D::new(self.block_start, self.block_end)
430 }
431}
432
433impl LogicalSides<LengthPercentage> {
434 pub fn percentages_relative_to(&self, basis: Au) -> LogicalSides<Au> {
435 self.map(|value| value.to_used_value(basis))
436 }
437}
438
439impl LogicalSides<LengthPercentageOrAuto<'_>> {
440 pub fn percentages_relative_to(&self, basis: Au) -> LogicalSides<AuOrAuto> {
441 self.map(|value| value.map(|value| value.to_used_value(basis)))
442 }
443}
444
445impl<T: Clone> LogicalSides<AutoOr<T>> {
446 pub fn auto_is(&self, f: impl Fn() -> T) -> LogicalSides<T> {
447 self.map(|s| s.auto_is(&f))
448 }
449}
450
451impl<T: Add<Output = T> + Copy> Add<LogicalSides<T>> for LogicalSides<T> {
452 type Output = LogicalSides<T>;
453
454 fn add(self, other: Self) -> Self::Output {
455 LogicalSides {
456 inline_start: self.inline_start + other.inline_start,
457 inline_end: self.inline_end + other.inline_end,
458 block_start: self.block_start + other.block_start,
459 block_end: self.block_end + other.block_end,
460 }
461 }
462}
463
464impl<T: Sub<Output = T> + Copy> Sub<LogicalSides<T>> for LogicalSides<T> {
465 type Output = LogicalSides<T>;
466
467 fn sub(self, other: Self) -> Self::Output {
468 LogicalSides {
469 inline_start: self.inline_start - other.inline_start,
470 inline_end: self.inline_end - other.inline_end,
471 block_start: self.block_start - other.block_start,
472 block_end: self.block_end - other.block_end,
473 }
474 }
475}
476
477impl<T: Neg<Output = T> + Copy> Neg for LogicalSides<T> {
478 type Output = LogicalSides<T>;
479 fn neg(self) -> Self::Output {
480 Self {
481 inline_start: -self.inline_start,
482 inline_end: -self.inline_end,
483 block_start: -self.block_start,
484 block_end: -self.block_end,
485 }
486 }
487}
488
489impl<T: Zero> LogicalSides<T> {
490 pub(crate) fn zero() -> LogicalSides<T> {
491 Self {
492 inline_start: T::zero(),
493 inline_end: T::zero(),
494 block_start: T::zero(),
495 block_end: T::zero(),
496 }
497 }
498}
499
500impl From<LogicalSides<CSSPixelLength>> for LogicalSides<Au> {
501 fn from(value: LogicalSides<CSSPixelLength>) -> Self {
502 Self {
503 inline_start: value.inline_start.into(),
504 inline_end: value.inline_end.into(),
505 block_start: value.block_start.into(),
506 block_end: value.block_end.into(),
507 }
508 }
509}
510
511impl From<LogicalSides<Au>> for LogicalSides<CSSPixelLength> {
512 fn from(value: LogicalSides<Au>) -> Self {
513 Self {
514 inline_start: value.inline_start.into(),
515 inline_end: value.inline_end.into(),
516 block_start: value.block_start.into(),
517 block_end: value.block_end.into(),
518 }
519 }
520}
521
522impl<T> LogicalSides1D<T> {
523 #[inline]
524 pub(crate) fn new(start: T, end: T) -> Self {
525 Self { start, end }
526 }
527}
528
529impl<T> LogicalSides1D<AutoOr<T>> {
530 #[inline]
531 pub(crate) fn either_specified(&self) -> bool {
532 !self.start.is_auto() || !self.end.is_auto()
533 }
534
535 #[inline]
536 pub(crate) fn either_auto(&self) -> bool {
537 self.start.is_auto() || self.end.is_auto()
538 }
539}
540
541impl<T> LogicalRect<T> {
542 pub fn max_inline_position(&self) -> T
543 where
544 T: Add<Output = T> + Copy,
545 {
546 self.start_corner.inline + self.size.inline
547 }
548
549 pub fn max_block_position(&self) -> T
550 where
551 T: Add<Output = T> + Copy,
552 {
553 self.start_corner.block + self.size.block
554 }
555
556 pub fn inflate(&self, sides: &LogicalSides<T>) -> Self
557 where
558 T: Add<Output = T> + Copy,
559 T: Sub<Output = T> + Copy,
560 {
561 Self {
562 start_corner: LogicalVec2 {
563 inline: self.start_corner.inline - sides.inline_start,
564 block: self.start_corner.block - sides.block_start,
565 },
566 size: LogicalVec2 {
567 inline: self.size.inline + sides.inline_sum(),
568 block: self.size.block + sides.block_sum(),
569 },
570 }
571 }
572
573 pub fn deflate(&self, sides: &LogicalSides<T>) -> Self
574 where
575 T: Add<Output = T> + Copy,
576 T: Sub<Output = T> + Copy,
577 {
578 LogicalRect {
579 start_corner: LogicalVec2 {
580 inline: self.start_corner.inline + sides.inline_start,
581 block: self.start_corner.block + sides.block_start,
582 },
583 size: LogicalVec2 {
584 inline: self.size.inline - sides.inline_sum(),
585 block: self.size.block - sides.block_sum(),
586 },
587 }
588 }
589}
590
591fn flip(start: Au, size: Au, container_size: Au, flipped: bool) -> Au {
592 if flipped {
593 container_size - (start + size)
594 } else {
595 start
596 }
597}
598
599impl LogicalRect<Au> {
600 fn from_physical_inner(
601 rect: PhysicalRect<Au>,
602 writing_mode: WritingMode,
603 container_inline_size: Au,
604 container_block_size: Option<Au>,
605 ) -> LogicalRect<Au> {
606 let inline_start;
607 let mut block_start;
608 let inline_size;
609 let block_size;
610 if writing_mode.is_vertical() {
611 inline_start = rect.origin.y;
612 block_start = rect.origin.x;
613 inline_size = rect.size.height;
614 block_size = rect.size.width;
615 } else {
616 inline_start = rect.origin.x;
617 block_start = rect.origin.y;
618 inline_size = rect.size.width;
619 block_size = rect.size.height;
620 }
621
622 let inline_start = flip(
623 inline_start,
624 inline_size,
625 container_inline_size,
626 writing_mode.is_inline_flipped(),
627 );
628 if writing_mode.is_block_flipped() &&
629 let Some(container_block_size) = container_block_size
630 {
631 block_start = flip(block_start, block_size, container_block_size, true);
632 }
633
634 Self {
635 start_corner: LogicalVec2 {
636 inline: inline_start,
637 block: block_start,
638 },
639 size: LogicalVec2 {
640 inline: inline_size,
641 block: block_size,
642 },
643 }
644 }
645
646 pub(crate) fn from_physical(
647 rect: PhysicalRect<Au>,
648 writing_mode: WritingMode,
649 container_size: LogicalVec2<Au>,
650 ) -> Self {
651 Self::from_physical_inner(
652 rect,
653 writing_mode,
654 container_size.inline,
655 Some(container_size.block),
656 )
657 }
658
659 pub(crate) fn from_physical_deprecated(
660 rect: PhysicalRect<Au>,
661 containing_block: &ContainingBlock,
662 ) -> Self {
663 Self::from_physical_inner(
664 rect,
665 containing_block.style.writing_mode,
666 containing_block.inline_size(),
667 None,
668 )
669 }
670
671 fn as_physical_inner(
672 &self,
673 writing_mode: WritingMode,
674 container_inline_size: Au,
675 container_block_size: Option<Au>,
676 ) -> PhysicalRect<Au> {
677 let inline_offset = flip(
678 self.start_corner.inline,
679 self.size.inline,
680 container_inline_size,
681 writing_mode.is_inline_flipped(),
682 );
683 let block_offset = container_block_size
684 .map(|container_block_size| {
685 flip(
686 self.start_corner.block,
687 self.size.block,
688 container_block_size,
689 writing_mode.is_block_flipped(),
690 )
691 })
692 .unwrap_or(self.start_corner.block);
693
694 if writing_mode.is_vertical() {
695 PhysicalRect::new(
696 PhysicalPoint::new(block_offset, inline_offset),
697 PhysicalSize::new(self.size.block, self.size.inline),
698 )
699 } else {
700 PhysicalRect::new(
701 PhysicalPoint::new(inline_offset, block_offset),
702 PhysicalSize::new(self.size.inline, self.size.block),
703 )
704 }
705 }
706
707 pub(crate) fn as_physical(
708 &self,
709 writing_mode: WritingMode,
710 container_size: LogicalVec2<Au>,
711 ) -> PhysicalRect<Au> {
712 self.as_physical_inner(
713 writing_mode,
714 container_size.inline,
715 Some(container_size.block),
716 )
717 }
718
719 pub(crate) fn as_physical_deprecated(
720 &self,
721 containing_block: &ContainingBlock<'_>,
722 ) -> PhysicalRect<Au> {
723 self.as_physical_inner(
724 containing_block.style.writing_mode,
725 containing_block.inline_size(),
726 None,
727 )
728 }
729}
730
731impl From<LogicalVec2<CSSPixelLength>> for LogicalVec2<Au> {
732 fn from(value: LogicalVec2<CSSPixelLength>) -> Self {
733 LogicalVec2 {
734 inline: value.inline.into(),
735 block: value.block.into(),
736 }
737 }
738}
739
740impl From<LogicalVec2<Au>> for LogicalVec2<CSSPixelLength> {
741 fn from(value: LogicalVec2<Au>) -> Self {
742 LogicalVec2 {
743 inline: value.inline.into(),
744 block: value.block.into(),
745 }
746 }
747}
748
749impl From<LogicalRect<Au>> for LogicalRect<CSSPixelLength> {
750 fn from(value: LogicalRect<Au>) -> Self {
751 LogicalRect {
752 start_corner: value.start_corner.into(),
753 size: value.size.into(),
754 }
755 }
756}
757
758impl From<LogicalRect<CSSPixelLength>> for LogicalRect<Au> {
759 fn from(value: LogicalRect<CSSPixelLength>) -> Self {
760 LogicalRect {
761 start_corner: value.start_corner.into(),
762 size: value.size.into(),
763 }
764 }
765}
766
767#[derive(MallocSizeOf, Default)]
781pub(crate) struct SyncPhysicalRectAu(PhysicalRect<AtomicI32>);
782
783impl SyncPhysicalRectAu {
784 #[inline]
785 pub(crate) fn new(rect: PhysicalRect<Au>) -> Self {
786 Self(PhysicalRect::new(
787 PhysicalPoint::new(rect.origin.x.0.into(), rect.origin.y.0.into()),
788 PhysicalSize::new(rect.size.width.0.into(), rect.size.height.0.into()),
789 ))
790 }
791
792 pub(crate) fn get(&self) -> PhysicalRect<Au> {
793 PhysicalRect::new(self.origin(), self.size())
794 }
795
796 pub(crate) fn set(&self, new_rect: PhysicalRect<Au>) {
797 self.set_origin(new_rect.origin);
798 self.set_size(new_rect.size);
799 }
800
801 #[inline]
802 pub(crate) fn origin(&self) -> PhysicalPoint<Au> {
803 Point2D::new(
804 Au(self.0.origin.x.load(Ordering::Relaxed)),
807 Au(self.0.origin.y.load(Ordering::Relaxed)),
808 )
809 }
810
811 #[inline]
812 pub(crate) fn size(&self) -> PhysicalSize<Au> {
813 Size2D::new(
814 Au(self.0.size.width.load(Ordering::Relaxed)),
817 Au(self.0.size.height.load(Ordering::Relaxed)),
818 )
819 }
820
821 #[inline]
822 pub(crate) fn set_origin(&self, new_origin: PhysicalPoint<Au>) {
823 let origin = &self.0.origin;
824 origin.x.store(new_origin.x.0, Ordering::Relaxed);
825 origin.y.store(new_origin.y.0, Ordering::Relaxed);
826 }
827
828 #[inline]
829 pub(crate) fn set_size(&self, new_size: PhysicalSize<Au>) {
830 let size = &self.0.size;
831 size.width.store(new_size.width.0, Ordering::Relaxed);
832 size.height.store(new_size.height.0, Ordering::Relaxed);
833 }
834
835 #[inline]
836 pub(crate) fn translate(&self, offset: PhysicalSize<Au>) {
837 let new_origin = self.origin() + offset;
840 self.set_origin(new_origin);
841 }
842}
843
844impl fmt::Debug for SyncPhysicalRectAu {
845 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
846 self.get().fmt(f)
847 }
848}
849
850#[test]
851fn test_rectangle_logical_physical_conversion() {
852 let make_logical_rect =
853 |inline_origin: i32, block_origin: i32, inline_size: i32, block_size: i32| LogicalRect {
854 start_corner: LogicalVec2 {
855 inline: Au::from_px(inline_origin),
856 block: Au::from_px(block_origin),
857 },
858 size: LogicalVec2 {
859 inline: Au::from_px(inline_size),
860 block: Au::from_px(block_size),
861 },
862 };
863
864 let make_physical_rect = |x: i32, y: i32, width: i32, height: i32| {
865 PhysicalRect::new(
866 Point2D::new(Au::from_px(x), Au::from_px(y)),
867 Size2D::new(Au::from_px(width), Au::from_px(height)),
868 )
869 };
870
871 let test_rectangle = make_logical_rect(10, 20, 30, 40);
872 let container_size = LogicalVec2 {
873 inline: Au::from_px(100),
874 block: Au::from_px(200),
875 };
876
877 let assert_conversion = |expected_rect: PhysicalRect<Au>, writing_mode| {
878 let converted = test_rectangle.as_physical(writing_mode, container_size);
879 assert_eq!(converted, expected_rect);
880 let converted_back = LogicalRect::from_physical(converted, writing_mode, container_size);
881 assert_eq!(converted_back, test_rectangle);
882 };
883
884 assert_conversion(
886 make_physical_rect(10, 20, 30, 40),
887 WritingMode::horizontal_tb(),
888 );
889 assert_conversion(
891 make_physical_rect(60, 20, 30, 40),
892 WritingMode::RTL | WritingMode::INLINE_REVERSED,
893 );
894 assert_conversion(
896 make_physical_rect(20, 10, 40, 30),
897 WritingMode::WRITING_MODE_VERTICAL_LR,
898 );
899 assert_conversion(
901 make_physical_rect(20, 60, 40, 30),
902 WritingMode::WRITING_MODE_VERTICAL_LR | WritingMode::RTL | WritingMode::INLINE_REVERSED,
903 );
904 assert_conversion(
906 make_physical_rect(140, 10, 40, 30),
907 WritingMode::WRITING_MODE_VERTICAL_RL,
908 );
909 assert_conversion(
911 make_physical_rect(140, 60, 40, 30),
912 WritingMode::WRITING_MODE_VERTICAL_RL | WritingMode::RTL | WritingMode::INLINE_REVERSED,
913 );
914 assert_conversion(
916 make_physical_rect(20, 60, 40, 30),
917 WritingMode::WRITING_MODE_SIDEWAYS_LR | WritingMode::INLINE_REVERSED,
918 );
919 assert_conversion(
921 make_physical_rect(20, 10, 40, 30),
922 WritingMode::WRITING_MODE_SIDEWAYS_LR | WritingMode::RTL,
923 );
924 assert_conversion(
926 make_physical_rect(140, 10, 40, 30),
927 WritingMode::WRITING_MODE_SIDEWAYS_RL,
928 );
929 assert_conversion(
931 make_physical_rect(140, 60, 40, 30),
932 WritingMode::WRITING_MODE_SIDEWAYS_RL | WritingMode::RTL | WritingMode::INLINE_REVERSED,
933 );
934 assert_conversion(
936 make_physical_rect(140, 10, 40, 30),
937 WritingMode::WRITING_MODE_VERTICAL_RL | WritingMode::UPRIGHT,
938 );
939}