diff options
Diffstat (limited to 'components/layout_2020/positioned.rs')
| -rw-r--r-- | components/layout_2020/positioned.rs | 89 |
1 files changed, 51 insertions, 38 deletions
diff --git a/components/layout_2020/positioned.rs b/components/layout_2020/positioned.rs index 9794d1acdae..55888fb8842 100644 --- a/components/layout_2020/positioned.rs +++ b/components/layout_2020/positioned.rs @@ -1,30 +1,41 @@ -use super::*; -use rayon::prelude::*; +/* 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 crate::fragments::{AnonymousFragment, BoxFragment, CollapsedBlockMargins, Fragment}; +use crate::geom::flow_relative::{Rect, Sides, Vec2}; +use crate::style_ext::{ComputedValuesExt, Direction, WritingMode}; +use crate::{ContainingBlock, DefiniteContainingBlock, IndependentFormattingContext}; +use rayon::iter::{IntoParallelRefIterator, ParallelIterator}; +use servo_arc::Arc; +use style::properties::ComputedValues; +use style::values::computed::{Length, LengthOrAuto, LengthPercentage, LengthPercentageOrAuto}; +use style::Zero; #[derive(Debug)] -pub(super) struct AbsolutelyPositionedBox { +pub(crate) struct AbsolutelyPositionedBox { pub style: Arc<ComputedValues>, pub contents: IndependentFormattingContext, } #[derive(Debug)] -pub(super) struct AbsolutelyPositionedFragment<'box_> { +pub(crate) struct AbsolutelyPositionedFragment<'box_> { absolutely_positioned_box: &'box_ AbsolutelyPositionedBox, /// The rank of the child from which this absolutely positioned fragment /// came from, when doing the layout of a block container. Used to compute /// static positions when going up the tree. - pub(super) tree_rank: usize, + pub(crate) tree_rank: usize, - pub(super) inline_start: AbsoluteBoxOffsets<LengthOrPercentage>, - inline_size: LengthOrPercentageOrAuto, + pub(crate) inline_start: AbsoluteBoxOffsets<LengthPercentage>, + inline_size: LengthPercentageOrAuto, - pub(super) block_start: AbsoluteBoxOffsets<LengthOrPercentage>, - block_size: LengthOrPercentageOrAuto, + pub(crate) block_start: AbsoluteBoxOffsets<LengthPercentage>, + block_size: LengthPercentageOrAuto, } #[derive(Clone, Copy, Debug)] -pub(super) enum AbsoluteBoxOffsets<NonStatic> { +pub(crate) enum AbsoluteBoxOffsets<NonStatic> { StaticStart { start: Length }, Start { start: NonStatic }, End { end: NonStatic }, @@ -32,7 +43,7 @@ pub(super) enum AbsoluteBoxOffsets<NonStatic> { } impl AbsolutelyPositionedBox { - pub(super) fn layout<'a>( + pub(crate) fn layout<'a>( &'a self, initial_start_corner: Vec2<Length>, tree_rank: usize, @@ -46,9 +57,9 @@ impl AbsolutelyPositionedBox { fn absolute_box_offsets( initial_static_start: Length, - start: LengthOrPercentageOrAuto, - end: LengthOrPercentageOrAuto, - ) -> AbsoluteBoxOffsets<LengthOrPercentage> { + start: LengthPercentageOrAuto, + end: LengthPercentageOrAuto, + ) -> AbsoluteBoxOffsets<LengthPercentage> { match (start.non_auto(), end.non_auto()) { (None, None) => AbsoluteBoxOffsets::StaticStart { start: initial_static_start, @@ -82,7 +93,7 @@ impl AbsolutelyPositionedBox { } impl<'a> AbsolutelyPositionedFragment<'a> { - pub(super) fn in_positioned_containing_block( + pub(crate) fn in_positioned_containing_block( absolute: &[Self], fragments: &mut Vec<Fragment>, content_rect_size: &Vec2<Length>, @@ -112,13 +123,13 @@ impl<'a> AbsolutelyPositionedFragment<'a> { })) } - pub(super) fn layout(&self, containing_block: &DefiniteContainingBlock) -> Fragment { + pub(crate) fn layout(&self, containing_block: &DefiniteContainingBlock) -> Fragment { let style = &self.absolutely_positioned_box.style; let cbis = containing_block.size.inline; let cbbs = containing_block.size.block; let padding = style.padding().percentages_relative_to(cbis); - let border = style.border_width().percentages_relative_to(cbis); + let border = style.border_width(); let computed_margin = style.margin().percentages_relative_to(cbis); let pb = &padding + &border; @@ -133,8 +144,8 @@ impl<'a> AbsolutelyPositionedFragment<'a> { computed_margin_start: LengthOrAuto, computed_margin_end: LengthOrAuto, solve_margins: impl FnOnce(Length) -> (Length, Length), - box_offsets: AbsoluteBoxOffsets<LengthOrPercentage>, - size: LengthOrPercentageOrAuto, + box_offsets: AbsoluteBoxOffsets<LengthPercentage>, + size: LengthPercentageOrAuto, ) -> (Anchor, LengthOrAuto, Length, Length) { let size = size.percentage_relative_to(containing_size); match box_offsets { @@ -163,40 +174,42 @@ impl<'a> AbsolutelyPositionedFragment<'a> { let mut margin_start = computed_margin_start.auto_is(Length::zero); let mut margin_end = computed_margin_end.auto_is(Length::zero); - let size = if let LengthOrAuto::Length(size) = size { - use LengthOrAuto::Auto; + let size = if let LengthOrAuto::LengthPercentage(size) = size { let margins = containing_size - start - end - padding_border_sum - size; match (computed_margin_start, computed_margin_end) { - (Auto, Auto) => { + (LengthOrAuto::Auto, LengthOrAuto::Auto) => { let (s, e) = solve_margins(margins); margin_start = s; margin_end = e; - } - (Auto, LengthOrAuto::Length(end)) => { + }, + (LengthOrAuto::Auto, LengthOrAuto::LengthPercentage(end)) => { margin_start = margins - end; - } - (LengthOrAuto::Length(start), Auto) => { + }, + (LengthOrAuto::LengthPercentage(start), LengthOrAuto::Auto) => { margin_end = margins - start; - } - (LengthOrAuto::Length(_), LengthOrAuto::Length(_)) => {} + }, + ( + LengthOrAuto::LengthPercentage(_), + LengthOrAuto::LengthPercentage(_), + ) => {}, } size } else { // FIXME(nox): What happens if that is negative? - containing_size - - start - - end - - padding_border_sum - - margin_start - - margin_end + containing_size - + start - + end - + padding_border_sum - + margin_start - + margin_end }; ( Anchor::Start(start), - LengthOrAuto::Length(size), + LengthOrAuto::LengthPercentage(size), margin_start, margin_end, ) - } + }, } } @@ -206,7 +219,7 @@ impl<'a> AbsolutelyPositionedFragment<'a> { computed_margin.inline_start, computed_margin.inline_end, |margins| { - if margins.px >= 0. { + if margins.px() >= 0. { (margins / 2., margins / 2.) } else { (Length::zero(), margins) @@ -303,7 +316,7 @@ impl<'a> AbsolutelyPositionedFragment<'a> { } } -pub(super) fn adjust_static_positions( +pub(crate) fn adjust_static_positions( absolutely_positioned_fragments: &mut [AbsolutelyPositionedFragment], child_fragments: &mut [Fragment], tree_rank_in_parent: usize, |