1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */

use app_units::Au;
use serde::Serialize;
use style::logical_geometry::WritingMode;
use style::values::specified::align::AlignFlags;

use super::Fragment;
use crate::cell::ArcRefCell;
use crate::geom::{LogicalVec2, PhysicalRect, PhysicalVec};

/// A reference to a Fragment which is shared between `HoistedAbsolutelyPositionedBox`
/// and its placeholder `AbsoluteOrFixedPositionedFragment` in the original tree position.
/// This will be used later in order to paint this hoisted box in tree order.
#[derive(Serialize)]
pub(crate) struct HoistedSharedFragment {
    pub fragment: Option<ArcRefCell<Fragment>>,
    /// The "static-position rect" of this absolutely positioned box. This is defined by the
    /// layout mode from which the box originates.
    ///
    /// See <https://drafts.csswg.org/css-position-3/#staticpos-rect>
    pub static_position_rect: PhysicalRect<Au>,
    /// The resolved alignment values used for aligning this absolutely positioned element
    /// if the "static-position rect" ends up being the "inset-modified containing block".
    /// These values are dependent on the layout mode (currently only interesting for
    /// flexbox).
    pub resolved_alignment: LogicalVec2<AlignFlags>,
    /// This is the [`WritingMode`] of the original parent of the element that created this
    /// hoisted absolutely-positioned fragment. This helps to interpret the offset for
    /// static positioning. If the writing mode is right-to-left or bottom-to-top, the static
    /// offset needs to be adjusted by the absolutely positioned element's inline size.
    pub original_parent_writing_mode: WritingMode,
}

impl HoistedSharedFragment {
    pub(crate) fn new(
        static_position_rect: PhysicalRect<Au>,
        resolved_alignment: LogicalVec2<AlignFlags>,
        original_parent_writing_mode: WritingMode,
    ) -> Self {
        HoistedSharedFragment {
            fragment: None,
            static_position_rect,
            resolved_alignment,
            original_parent_writing_mode,
        }
    }
}

impl HoistedSharedFragment {
    /// `inset: auto`-positioned elements do not know their precise position until after
    /// they're hoisted. This lets us adjust auto values after the fact.
    pub(crate) fn adjust_offsets(&mut self, offset: &PhysicalVec<Au>) {
        self.static_position_rect = self.static_position_rect.translate(*offset);
    }
}