From 8825d588c14ba6a72fdad4ec5ae67c7b4397daf1 Mon Sep 17 00:00:00 2001 From: Martin Robinson Date: Wed, 15 Jan 2020 13:48:25 +0100 Subject: [PATCH] Add initial support for scrollable overflow in layout_2020 This still isn't totally correct and non-root scrolling is not handled at all, but the root frame now scrolls. --- components/layout_2020/flow/inline.rs | 65 +++++++++++++------------ components/layout_2020/flow/mod.rs | 19 ++++---- components/layout_2020/flow/root.rs | 52 ++++++++++++++++++-- components/layout_2020/fragments.rs | 68 +++++++++++++++++++++++++++ components/layout_2020/geom.rs | 36 ++++++++++++++ components/layout_2020/positioned.rs | 20 ++++---- components/layout_thread_2020/lib.rs | 8 +++- 7 files changed, 212 insertions(+), 56 deletions(-) diff --git a/components/layout_2020/flow/inline.rs b/components/layout_2020/flow/inline.rs index 7c3fd9a29e3..ba9453a5b80 100644 --- a/components/layout_2020/flow/inline.rs +++ b/components/layout_2020/flow/inline.rs @@ -339,11 +339,12 @@ impl Lines { block: line_block_size, }; self.next_line_block_position += size.block; - self.fragments.push(Fragment::Anonymous(AnonymousFragment { - children: line_contents, - rect: Rect { start_corner, size }, - mode: containing_block.style.writing_mode, - })) + self.fragments + .push(Fragment::Anonymous(AnonymousFragment::new( + Rect { start_corner, size }, + line_contents, + containing_block.style.writing_mode, + ))) } } @@ -402,22 +403,24 @@ impl<'box_tree> PartialInlineBoxFragment<'box_tree> { inline_position: &mut Length, at_line_break: bool, ) { - let mut fragment = BoxFragment { - tag: self.tag, - style: self.style.clone(), - children: std::mem::take(&mut nesting_level.fragments_so_far), - content_rect: Rect { - size: Vec2 { - inline: *inline_position - self.start_corner.inline, - block: nesting_level.max_block_size_of_fragments_so_far, - }, - start_corner: self.start_corner.clone(), + let content_rect = Rect { + size: Vec2 { + inline: *inline_position - self.start_corner.inline, + block: nesting_level.max_block_size_of_fragments_so_far, }, - padding: self.padding.clone(), - border: self.border.clone(), - margin: self.margin.clone(), - block_margins_collapsed_with_children: CollapsedBlockMargins::zero(), + start_corner: self.start_corner.clone(), }; + + let mut fragment = BoxFragment::new( + self.tag, + self.style.clone(), + std::mem::take(&mut nesting_level.fragments_so_far), + content_rect, + self.padding.clone(), + self.border.clone(), + self.margin.clone(), + CollapsedBlockMargins::zero(), + ); let last_fragment = self.last_box_tree_fragment && !at_line_break; if last_fragment { *inline_position += fragment.padding.inline_end + @@ -470,16 +473,16 @@ fn layout_atomic<'box_tree>( let size = replaced.used_size_as_if_inline_element(ifc.containing_block, &atomic.style); let fragments = replaced.make_fragments(&atomic.style, size.clone()); let content_rect = Rect { start_corner, size }; - BoxFragment { - tag: atomic.tag, - style: atomic.style.clone(), - children: fragments, + BoxFragment::new( + atomic.tag, + atomic.style.clone(), + fragments, content_rect, padding, border, margin, - block_margins_collapsed_with_children: CollapsedBlockMargins::zero(), - } + CollapsedBlockMargins::zero(), + ) }, Err(non_replaced) => { let box_size = atomic.style.box_size(); @@ -545,16 +548,16 @@ fn layout_atomic<'box_tree>( inline: inline_size, }, }; - BoxFragment { - tag: atomic.tag, - style: atomic.style.clone(), - children: independent_layout.fragments, + BoxFragment::new( + atomic.tag, + atomic.style.clone(), + independent_layout.fragments, content_rect, padding, border, margin, - block_margins_collapsed_with_children: CollapsedBlockMargins::zero(), - } + CollapsedBlockMargins::zero(), + ) }, }; diff --git a/components/layout_2020/flow/mod.rs b/components/layout_2020/flow/mod.rs index b7373baf55a..b047fee78df 100644 --- a/components/layout_2020/flow/mod.rs +++ b/components/layout_2020/flow/mod.rs @@ -495,16 +495,16 @@ fn layout_in_flow_non_replaced_block_level<'a>( inline: inline_size, }, }; - BoxFragment { + BoxFragment::new( tag, - style: style.clone(), - children: fragments, + style.clone(), + fragments, content_rect, padding, border, margin, block_margins_collapsed_with_children, - } + ) } /// https://drafts.csswg.org/css2/visudet.html#block-replaced-width @@ -545,16 +545,17 @@ fn layout_in_flow_replaced_block_level<'a>( }, size, }; - BoxFragment { + let block_margins_collapsed_with_children = CollapsedBlockMargins::from_margin(&margin); + BoxFragment::new( tag, - style: style.clone(), - children: fragments, + style.clone(), + fragments, content_rect, padding, border, - block_margins_collapsed_with_children: CollapsedBlockMargins::from_margin(&margin), margin, - } + block_margins_collapsed_with_children, + ) } fn solve_inline_margins_for_in_flow_block_level( diff --git a/components/layout_2020/flow/root.rs b/components/layout_2020/flow/root.rs index 14b1081c84a..5b801c1fd7a 100644 --- a/components/layout_2020/flow/root.rs +++ b/components/layout_2020/flow/root.rs @@ -11,12 +11,14 @@ use crate::formatting_contexts::IndependentFormattingContext; use crate::fragments::Fragment; use crate::geom; use crate::geom::flow_relative::Vec2; +use crate::geom::physical; use crate::positioned::AbsolutelyPositionedBox; use crate::positioned::PositioningContext; use crate::replaced::ReplacedContent; use crate::sizing::ContentSizesRequest; use crate::style_ext::{Display, DisplayGeneratingBox, DisplayInside}; use crate::DefiniteContainingBlock; +use euclid::Size2D; use gfx_traits::print_tree::PrintTree; use script_layout_interface::wrapper_traits::LayoutNode; use servo_arc::Arc; @@ -26,7 +28,14 @@ use style::Zero; use style_traits::CSSPixel; pub struct BoxTreeRoot(BlockFormattingContext); -pub struct FragmentTreeRoot(Vec); + +pub struct FragmentTreeRoot { + /// The children of the root of the fragment tree. + children: Vec, + + /// The scrollable overflow of the root of the fragment tree. + scrollable_overflow: physical::Rect, +} impl BoxTreeRoot { pub fn construct<'dom, Node>(context: &LayoutContext, root_element: Node) -> Self @@ -131,7 +140,35 @@ impl BoxTreeRoot { &mut independent_layout.fragments, ); - FragmentTreeRoot(independent_layout.fragments) + // FIXME(mrobinson, bug 25564): We should be using the containing block + // here to properly convert scrollable overflow to physical geometry. + let scrollable_overflow = + independent_layout + .fragments + .iter() + .fold(physical::Rect::zero(), |acc, child| { + let child_overflow = child.scrollable_overflow(); + + // https://drafts.csswg.org/css-overflow/#scrolling-direction + // We want to clip scrollable overflow on box-start and inline-start + // sides of the scroll container. + // + // FIXME(mrobinson, bug 25564): This should take into account writing + // mode. + let child_overflow = physical::Rect { + top_left: physical::Vec2::zero(), + size: physical::Vec2 { + x: child_overflow.size.x + child_overflow.top_left.x, + y: child_overflow.size.y + child_overflow.top_left.y, + }, + }; + acc.axis_aligned_bounding_box(&child_overflow) + }); + + FragmentTreeRoot { + children: independent_layout.fragments, + scrollable_overflow, + } } } @@ -151,15 +188,22 @@ impl FragmentTreeRoot { y: Length::new(viewport_size.height), }, }; - for fragment in &self.0 { + for fragment in &self.children { fragment.build_display_list(builder, &containing_block) } } pub fn print(&self) { let mut print_tree = PrintTree::new("Fragment Tree".to_string()); - for fragment in &self.0 { + for fragment in &self.children { fragment.print(&mut print_tree); } } + + pub fn scrollable_overflow(&self) -> webrender_api::units::LayoutSize { + webrender_api::units::LayoutSize::from_untyped(Size2D::new( + self.scrollable_overflow.size.x.px(), + self.scrollable_overflow.size.y.px(), + )) + } } diff --git a/components/layout_2020/fragments.rs b/components/layout_2020/fragments.rs index 1bef85d16a7..887b8c3b04a 100644 --- a/components/layout_2020/fragments.rs +++ b/components/layout_2020/fragments.rs @@ -3,6 +3,7 @@ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ use crate::geom::flow_relative::{Rect, Sides, Vec2}; +use crate::geom::physical; use gfx::text::glyph::GlyphStore; use gfx_traits::print_tree::PrintTree; use servo_arc::Arc as ServoArc; @@ -36,6 +37,9 @@ pub(crate) struct BoxFragment { pub margin: Sides, pub block_margins_collapsed_with_children: CollapsedBlockMargins, + + /// The scrollable overflow of this box fragment. + pub scrollable_overflow: physical::Rect, } pub(crate) struct CollapsedBlockMargins { @@ -55,6 +59,9 @@ pub(crate) struct AnonymousFragment { pub rect: Rect, pub children: Vec, pub mode: WritingMode, + + /// The scrollable overflow of this anonymous fragment's children. + pub scrollable_overflow: physical::Rect, } pub(crate) struct TextFragment { @@ -90,6 +97,21 @@ impl Fragment { Fragment::Image(fragment) => fragment.print(tree), } } + + pub fn scrollable_overflow(&self) -> physical::Rect { + // FIXME(mrobinson, bug 25564): We should be using the containing block + // here to properly convert scrollable overflow to physical geometry. + match self { + Fragment::Box(fragment) => fragment.scrollable_overflow.clone(), + Fragment::Anonymous(fragment) => fragment.scrollable_overflow.clone(), + Fragment::Text(fragment) => fragment + .rect + .to_physical(fragment.parent_style.writing_mode, &physical::Rect::zero()), + Fragment::Image(fragment) => fragment + .rect + .to_physical(fragment.style.writing_mode, &physical::Rect::zero()), + } + } } impl AnonymousFragment { @@ -98,6 +120,21 @@ impl AnonymousFragment { children: vec![], rect: Rect::zero(), mode, + scrollable_overflow: physical::Rect::zero(), + } + } + + pub fn new(rect: Rect, children: Vec, mode: WritingMode) -> Self { + // FIXME(mrobinson, bug 25564): We should be using the containing block + // here to properly convert scrollable overflow to physical geometry. + let scrollable_overflow = children.iter().fold(physical::Rect::zero(), |acc, child| { + acc.axis_aligned_bounding_box(&child.scrollable_overflow()) + }); + AnonymousFragment { + rect, + children, + mode, + scrollable_overflow, } } @@ -116,6 +153,37 @@ impl AnonymousFragment { } impl BoxFragment { + pub fn new( + tag: OpaqueNode, + style: ServoArc, + children: Vec, + content_rect: Rect, + padding: Sides, + border: Sides, + margin: Sides, + block_margins_collapsed_with_children: CollapsedBlockMargins, + ) -> BoxFragment { + // FIXME(mrobinson, bug 25564): We should be using the containing block + // here to properly convert scrollable overflow to physical geometry. + let scrollable_overflow = children.iter().fold( + content_rect + .inflate(&border) + .to_physical(style.writing_mode, &physical::Rect::zero()), + |acc, child| acc.axis_aligned_bounding_box(&child.scrollable_overflow()), + ); + BoxFragment { + tag, + style, + children, + content_rect, + padding, + border, + margin, + block_margins_collapsed_with_children, + scrollable_overflow, + } + } + pub fn padding_rect(&self) -> Rect { self.content_rect.inflate(&self.padding) } diff --git a/components/layout_2020/geom.rs b/components/layout_2020/geom.rs index 166ba7a0494..918cbf47fd2 100644 --- a/components/layout_2020/geom.rs +++ b/components/layout_2020/geom.rs @@ -60,6 +60,15 @@ pub(crate) mod flow_relative { } } +impl physical::Vec2 { + pub fn zero() -> Self { + Self { + x: T::zero(), + y: T::zero(), + } + } +} + impl fmt::Debug for physical::Vec2 { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { // Not using f.debug_struct on purpose here, to keep {:?} output somewhat compact @@ -387,6 +396,33 @@ impl physical::Rect { } } +impl physical::Rect { + pub fn axis_aligned_bounding_box(&self, other: &Self) -> Self { + let top_left = physical::Vec2 { + x: self.top_left.x.min(other.top_left.x), + y: self.top_left.y.min(other.top_left.y), + }; + + let bottom_corner_x = (self.top_left.x + self.size.x).max(other.top_left.x + other.size.x); + let bottom_corner_y = (self.top_left.y + self.size.y).max(other.top_left.y + other.size.y); + let size = physical::Vec2 { + x: bottom_corner_x - top_left.x, + y: bottom_corner_y - top_left.y, + }; + + Self { top_left, size } + } +} + +impl physical::Rect { + pub fn zero() -> Self { + Self { + top_left: physical::Vec2::zero(), + size: physical::Vec2::zero(), + } + } +} + impl From> for Rect { fn from(r: physical::Rect) -> Self { Rect { diff --git a/components/layout_2020/positioned.rs b/components/layout_2020/positioned.rs index b10b489bc1d..7b7d67bd122 100644 --- a/components/layout_2020/positioned.rs +++ b/components/layout_2020/positioned.rs @@ -290,11 +290,11 @@ impl<'box_tree> PositioningContext<'box_tree> { ); positioned_box_fragment .children - .push(Fragment::Anonymous(AnonymousFragment { + .push(Fragment::Anonymous(AnonymousFragment::new( + padding_rect, children, - rect: padding_rect, - mode: positioned_box_fragment.style.writing_mode, - })) + positioned_box_fragment.style.writing_mode, + ))) } } } @@ -470,16 +470,16 @@ impl<'box_tree> HoistedAbsolutelyPositionedBox<'box_tree> { size, }; - BoxFragment { - tag: self.absolutely_positioned_box.contents.tag, - style: style.clone(), - children: fragments, + BoxFragment::new( + self.absolutely_positioned_box.contents.tag, + style.clone(), + fragments, content_rect, padding, border, margin, - block_margins_collapsed_with_children: CollapsedBlockMargins::zero(), - } + CollapsedBlockMargins::zero(), + ) }) } } diff --git a/components/layout_thread_2020/lib.rs b/components/layout_thread_2020/lib.rs index 70233892d63..b221774390f 100644 --- a/components/layout_thread_2020/lib.rs +++ b/components/layout_thread_2020/lib.rs @@ -1374,12 +1374,16 @@ impl LayoutThread { document.will_paint(); } + let mut display_list = DisplayListBuilder::new( + self.id.to_webrender(), + context, + fragment_tree.scrollable_overflow(), + ); + let viewport_size = webrender_api::units::LayoutSize::from_untyped(Size2D::new( self.viewport_size.width.to_f32_px(), self.viewport_size.height.to_f32_px(), )); - let mut display_list = - DisplayListBuilder::new(self.id.to_webrender(), context, viewport_size); fragment_tree.build_display_list(&mut display_list, viewport_size); if self.dump_flow_tree {