Skip to main content

layout/
geom.rs

1/* This Source Code Form is subject to the terms of the Mozilla Public
2 * License, v. 2.0. If a copy of the MPL was not distributed with this
3 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
4
5use 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        // Not using f.debug_struct on purpose here, to keep {:?} output somewhat compact
75        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        // https://drafts.csswg.org/css-writing-modes/#logical-to-physical
118        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        // https://drafts.csswg.org/css-writing-modes/#logical-to-physical
232        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    /// Convert from a physical point in the parent container to a [`LogicalVec2`] point.
242    ///
243    /// TODO: This will eventually need to be passed the parent container size.
244    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    /// Convert the vector to an offset in the parent container.
266    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    /// Convert the vector to an offset in the parent container, but without flipping anything
287    /// in the block axis.
288    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        // https://drafts.csswg.org/css-writing-modes/#logical-to-physical
306        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/// A `PhysicalRect<Au>` with shared mutablitiy
768///
769/// It is based on `AtomicI32` but is not atomic itself: there is no protection against tearing:
770/// If multiple threads are calling `set()`, the rectangle may end up with some fields from one call
771/// and some fields from another call.
772///
773/// Compared to `AtomicRefCell<PhysicalRect<Au>>`:
774///
775/// * Both are meant for uses where despite shared ownership, no concurrency is expected in practice.
776/// * If concurrent access does unexpectedly happen `AtomicRefCell` will panic,
777///   whereas `SyncPhysicalRectAu` can tear and result in invalid/inconsistent data.
778/// * `SyncPhysicalRectAu` has no space overhead, `AtomicRefCell` stores an `AtomicUsize` borrow flag
779/// * `SyncPhysicalRectAu` uses relaxed atomic access for each field separately
780#[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            // Bypass clamping in `Au::new`: the value originally came from another `Au`
805            // so it’s expected to already be in range
806            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            // Bypass clamping in `Au::new`: the value originally came from another `Au`
815            // so it’s expected to already be in range
816            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        // This code explicitly does not use `AtomicI32::fetch_add`, as we rely on Au's
838        // overflow detection to clamp the resulting value between `MAX_AU` and `MIN_AU`.
839        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    // `writing-mode: horizontal-tb` `direction: ltr`
885    assert_conversion(
886        make_physical_rect(10, 20, 30, 40),
887        WritingMode::horizontal_tb(),
888    );
889    // `writing-mode: horizontal-tb` `direction: rtl`
890    assert_conversion(
891        make_physical_rect(60, 20, 30, 40),
892        WritingMode::RTL | WritingMode::INLINE_REVERSED,
893    );
894    // `writing-mode: vertical-lr` `direction: ltr`
895    assert_conversion(
896        make_physical_rect(20, 10, 40, 30),
897        WritingMode::WRITING_MODE_VERTICAL_LR,
898    );
899    // `writing-mode: vertical-lr` `direction: rtl`
900    assert_conversion(
901        make_physical_rect(20, 60, 40, 30),
902        WritingMode::WRITING_MODE_VERTICAL_LR | WritingMode::RTL | WritingMode::INLINE_REVERSED,
903    );
904    // `writing-mode: vertical-rl` `direction: ltr`
905    assert_conversion(
906        make_physical_rect(140, 10, 40, 30),
907        WritingMode::WRITING_MODE_VERTICAL_RL,
908    );
909    // `writing-mode: vertical-rl` `direction: rtl`
910    assert_conversion(
911        make_physical_rect(140, 60, 40, 30),
912        WritingMode::WRITING_MODE_VERTICAL_RL | WritingMode::RTL | WritingMode::INLINE_REVERSED,
913    );
914    // `writing-mode: sideways-lr` `direction: ltr`
915    assert_conversion(
916        make_physical_rect(20, 60, 40, 30),
917        WritingMode::WRITING_MODE_SIDEWAYS_LR | WritingMode::INLINE_REVERSED,
918    );
919    // `writing-mode: sideways-lr` `direction: rtl`
920    assert_conversion(
921        make_physical_rect(20, 10, 40, 30),
922        WritingMode::WRITING_MODE_SIDEWAYS_LR | WritingMode::RTL,
923    );
924    // `writing-mode: sideways-rl` `direction: ltr`
925    assert_conversion(
926        make_physical_rect(140, 10, 40, 30),
927        WritingMode::WRITING_MODE_SIDEWAYS_RL,
928    );
929    // `writing-mode: sideways-rl` `direction: rtl`
930    assert_conversion(
931        make_physical_rect(140, 60, 40, 30),
932        WritingMode::WRITING_MODE_SIDEWAYS_RL | WritingMode::RTL | WritingMode::INLINE_REVERSED,
933    );
934    // `writing-mode: sideways-rl` `direction: rtl` `text-orientation: upright`
935    assert_conversion(
936        make_physical_rect(140, 10, 40, 30),
937        WritingMode::WRITING_MODE_VERTICAL_RL | WritingMode::UPRIGHT,
938    );
939}