Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-08-04 05:00:08 +01:00
Code Issues Projects Releases Packages Wiki Activity

Uncomment more stuff related to box construction

Browse source
This commit is contained in:
Anthony Ramine 2019-09-19 11:58:07 +02:00
parent c08cfbb5f3
commit 9cef3eee65
4 changed files with 226 additions and 202 deletions
Download patch file Download diff file Expand all files Collapse all files

173
components/layout_2020/flow/construct.rs
View file

@ -9,7 +9,7 @@ use crate::flow::inline::{InlineBox, InlineFormattingContext, InlineLevelBox, Te
use crate::flow::{BlockContainer, BlockFormattingContext, BlockLevelBox}; use crate::flow::{BlockContainer, BlockFormattingContext, BlockLevelBox};
use crate::positioned::AbsolutelyPositionedBox; use crate::positioned::AbsolutelyPositionedBox;
use crate::style_ext::{DisplayGeneratingBox, DisplayInside, DisplayOutside}; use crate::style_ext::{DisplayGeneratingBox, DisplayInside, DisplayOutside};
use crate::IndependentFormattingContext; use crate::{take, IndependentFormattingContext};
use rayon::iter::{IntoParallelIterator, ParallelIterator}; use rayon::iter::{IntoParallelIterator, ParallelIterator};
use rayon_croissant::ParallelIteratorExt; use rayon_croissant::ParallelIteratorExt;
use servo_arc::Arc; use servo_arc::Arc;
@ -152,8 +152,7 @@ impl BlockContainer {
); );
return (container, builder.contains_floats); return (container, builder.contains_floats);
} }
// FIXME builder.end_ongoing_inline_formatting_context();
// builder.end_ongoing_inline_formatting_context();
} }
let mut contains_floats = builder.contains_floats; let mut contains_floats = builder.contains_floats;
@ -166,8 +165,7 @@ impl BlockContainer {
|contains_floats, (intermediate, box_slot): (IntermediateBlockLevelBox<_>, BoxSlot<'_>)| { |contains_floats, (intermediate, box_slot): (IntermediateBlockLevelBox<_>, BoxSlot<'_>)| {
let (block_level_box, box_contains_floats) = intermediate.finish(context); let (block_level_box, box_contains_floats) = intermediate.finish(context);
*contains_floats |= box_contains_floats; *contains_floats |= box_contains_floats;
// FIXME box_slot.set(LayoutBox::BlockLevel(block_level_box.clone()));
// box_slot.set(LayoutBox::BlockLevel(block_level_box.clone()));
block_level_box block_level_box
}, },
|left, right| *left |= right, |left, right| *left |= right,
@ -195,21 +193,21 @@ where
self.handle_inline_level_element(style, inside, contents), self.handle_inline_level_element(style, inside, contents),
)), )),
DisplayOutside::Block => { DisplayOutside::Block => {
// FIXME let box_style = style.get_box();
// Floats and abspos cause blockification, so they only happen in this case. // Floats and abspos cause blockification, so they only happen in this case.
// https://drafts.csswg.org/css2/visuren.html#dis-pos-flo // https://drafts.csswg.org/css2/visuren.html#dis-pos-flo
// if style.box_.position.is_absolutely_positioned() { if box_style.position.is_absolutely_positioned() {
// self.handle_absolutely_positioned_element( self.handle_absolutely_positioned_element(
// style.clone(), style.clone(),
// inside, inside,
// contents, contents,
// box_slot, box_slot,
// ) )
// } else if style.box_.float.is_floating() { } else if box_style.float.is_floating() {
// self.handle_float_element(style.clone(), inside, contents, box_slot) self.handle_float_element(style.clone(), inside, contents, box_slot)
// } else { } else {
// self.handle_block_level_element(style.clone(), inside, contents, box_slot) self.handle_block_level_element(style.clone(), inside, contents, box_slot)
// } }
}, },
DisplayOutside::None => panic!(":("), DisplayOutside::None => panic!(":("),
}, },
@ -362,80 +360,79 @@ where
box_ box_
} }
// FIXME fn handle_block_level_element(
// fn handle_block_level_element( &mut self,
// &mut self, style: Arc<ComputedValues>,
// style: Arc<ComputedValues>, display_inside: DisplayInside,
// display_inside: DisplayInside, contents: Contents<Node>,
// contents: Contents, box_slot: BoxSlot<'dom>,
// box_slot: BoxSlot<'a>, ) {
// ) { // We just found a block level element, all ongoing inline level boxes
// // We just found a block level element, all ongoing inline level boxes // need to be split around it. We iterate on the fragmented inline
// // need to be split around it. We iterate on the fragmented inline // level box stack to take their contents and set their first_fragment
// // level box stack to take their contents and set their first_fragment // field to false, for the fragmented inline level boxes that will
// // field to false, for the fragmented inline level boxes that will // come after the block level element.
// // come after the block level element. let mut fragmented_inline_boxes =
// let mut fragmented_inline_boxes = self.ongoing_inline_boxes_stack
// self.ongoing_inline_boxes_stack .iter_mut()
// .iter_mut() .rev()
// .rev() .map(|ongoing| {
// .map(|ongoing| { let fragmented = InlineBox {
// let fragmented = InlineBox { style: ongoing.style.clone(),
// style: ongoing.style.clone(), first_fragment: ongoing.first_fragment,
// first_fragment: ongoing.first_fragment, // The fragmented boxes before the block level element
// // The fragmented boxes before the block level element // are obviously not the last fragment.
// // are obviously not the last fragment. last_fragment: false,
// last_fragment: false, children: take(&mut ongoing.children),
// children: take(&mut ongoing.children), };
// }; ongoing.first_fragment = false;
// ongoing.first_fragment = false; fragmented
// fragmented });
// });
// if let Some(last) = fragmented_inline_boxes.next() { if let Some(last) = fragmented_inline_boxes.next() {
// // There were indeed some ongoing inline level boxes before // There were indeed some ongoing inline level boxes before
// // the block, we accumulate them as a single inline level box // the block, we accumulate them as a single inline level box
// // to be pushed to the ongoing inline formatting context. // to be pushed to the ongoing inline formatting context.
// let mut fragmented_inline = InlineLevelBox::InlineBox(last); let mut fragmented_inline = InlineLevelBox::InlineBox(last);
// for mut fragmented_parent_inline_box in fragmented_inline_boxes { for mut fragmented_parent_inline_box in fragmented_inline_boxes {
// fragmented_parent_inline_box fragmented_parent_inline_box
// .children .children
// .push(Arc::new(fragmented_inline)); .push(Arc::new(fragmented_inline));
// fragmented_inline = InlineLevelBox::InlineBox(fragmented_parent_inline_box); fragmented_inline = InlineLevelBox::InlineBox(fragmented_parent_inline_box);
// } }
// self.ongoing_inline_formatting_context self.ongoing_inline_formatting_context
// .inline_level_boxes .inline_level_boxes
// .push(Arc::new(fragmented_inline)); .push(Arc::new(fragmented_inline));
// } }
// // We found a block level element, so the ongoing inline formatting // We found a block level element, so the ongoing inline formatting
// // context needs to be ended. // context needs to be ended.
// self.end_ongoing_inline_formatting_context(); self.end_ongoing_inline_formatting_context();
// let intermediate_box = match contents.try_into() { let intermediate_box = match contents.try_into() {
// Ok(contents) => match display_inside { Ok(contents) => match display_inside {
// DisplayInside::Flow => IntermediateBlockLevelBox::SameFormattingContextBlock { DisplayInside::Flow => IntermediateBlockLevelBox::SameFormattingContextBlock {
// style, style,
// contents: IntermediateBlockContainer::Deferred { contents }, contents: IntermediateBlockContainer::Deferred { contents },
// }, },
// _ => IntermediateBlockLevelBox::Independent { _ => IntermediateBlockLevelBox::Independent {
// style, style,
// display_inside, display_inside,
// contents: contents.into(), contents: contents.into(),
// }, },
// }, },
// Err(contents) => { Err(contents) => {
// let contents = Contents::Replaced(contents); let contents = Contents::Replaced(contents);
// IntermediateBlockLevelBox::Independent { IntermediateBlockLevelBox::Independent {
// style, style,
// display_inside, display_inside,
// contents, contents,
// } }
// } },
// }; };
// self.block_level_boxes.push((intermediate_box, box_slot)) self.block_level_boxes.push((intermediate_box, box_slot))
// } }
fn handle_absolutely_positioned_element( fn handle_absolutely_positioned_element(
&mut self, &mut self,

221
components/layout_2020/flow/root.rs
View file

@ -2,7 +2,25 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this * 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/. */ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
use super::*; use crate::dom_traversal::{Contents, NodeExt};
use crate::flow::construct::ContainsFloats;
use crate::flow::float::FloatBox;
use crate::flow::{BlockContainer, BlockFormattingContext, BlockLevelBox};
use crate::fragments::Fragment;
use crate::geom;
use crate::geom::flow_relative::Vec2;
use crate::positioned::AbsolutelyPositionedBox;
use crate::replaced::ReplacedContent;
use crate::style_ext::{
Direction, Display, DisplayGeneratingBox, DisplayInside, DisplayOutside, WritingMode,
};
use crate::{ContainingBlock, DefiniteContainingBlock, IndependentFormattingContext};
use rayon::iter::{IntoParallelRefIterator, ParallelExtend, ParallelIterator};
use servo_arc::Arc;
use style::context::SharedStyleContext;
use style::properties::ComputedValues;
use style::values::computed::{Length, LengthOrAuto};
use style_traits::CSSPixel;
// FIXME // FIXME
// impl crate::dom::Document { // impl crate::dom::Document {
@ -16,114 +34,107 @@ use super::*;
struct BoxTreeRoot(BlockFormattingContext); struct BoxTreeRoot(BlockFormattingContext);
// FIXME impl BoxTreeRoot {
// impl BoxTreeRoot { pub fn construct<'dom>(
// pub fn construct(document: &dom::Document) -> Self { context: &SharedStyleContext<'_>,
// let author_styles = &document.parse_stylesheets(); root_element: impl NodeExt<'dom>,
// let context = Context { ) -> Self {
// document, let (contains_floats, boxes) = construct_for_root_element(&context, root_element);
// author_styles, Self(BlockFormattingContext {
// }; contains_floats: contains_floats == ContainsFloats::Yes,
// let root_element = document.root_element(); contents: BlockContainer::BlockLevelBoxes(boxes),
// let style = style_for_element(context.author_styles, context.document, root_element, None); })
// let (contains_floats, boxes) = construct_for_root_element(&context, root_element, style); }
// Self(BlockFormattingContext { }
// contains_floats: contains_floats == ContainsFloats::Yes,
// contents: BlockContainer::BlockLevelBoxes(boxes),
// })
// }
// }
// fn construct_for_root_element( fn construct_for_root_element<'dom>(
// context: &Context, context: &SharedStyleContext<'_>,
// root_element: dom::NodeId, root_element: impl NodeExt<'dom>,
// style: Arc<ComputedValues>, ) -> (ContainsFloats, Vec<Arc<BlockLevelBox>>) {
// ) -> (ContainsFloats, Vec<Arc<BlockLevelBox>>) { let style = root_element.style(context);
// let replaced = ReplacedContent::for_element(root_element, context); let replaced = ReplacedContent::for_element(root_element, context);
let box_style = style.get_box();
// let display_inside = match style.box_.display { let display_inside = match Display::from(box_style.display) {
// Display::None => return (ContainsFloats::No, Vec::new()), Display::None => return (ContainsFloats::No, Vec::new()),
// Display::Contents if replaced.is_some() => { Display::Contents if replaced.is_some() => {
// // 'display: contents' computes to 'none' for replaced elements // 'display: contents' computes to 'none' for replaced elements
// return (ContainsFloats::No, Vec::new()); return (ContainsFloats::No, Vec::new());
// } },
// // https://drafts.csswg.org/css-display-3/#transformations // https://drafts.csswg.org/css-display-3/#transformations
// Display::Contents => DisplayInside::Flow, Display::Contents => DisplayInside::Flow,
// // The root element is blockified, ignore DisplayOutside // The root element is blockified, ignore DisplayOutside
// Display::GeneratingBox(DisplayGeneratingBox::OutsideInside { inside, .. }) => inside, Display::GeneratingBox(DisplayGeneratingBox::OutsideInside { inside, .. }) => inside,
// }; };
// if let Some(replaced) = replaced { if let Some(replaced) = replaced {
// let _box = match replaced {}; let _box = match replaced {};
// #[allow(unreachable_code)] #[allow(unreachable_code)]
// { {
// return (ContainsFloats::No, vec![Arc::new(_box)]); return (ContainsFloats::No, vec![Arc::new(_box)]);
// } }
// } }
// let contents = IndependentFormattingContext::construct( let contents = IndependentFormattingContext::construct(
// context, context,
// &style, &style,
// display_inside, display_inside,
// Contents::OfElement(root_element), Contents::OfElement(root_element),
// ); );
// if style.box_.position.is_absolutely_positioned() { if box_style.position.is_absolutely_positioned() {
// ( (
// ContainsFloats::No, ContainsFloats::No,
// vec![Arc::new(BlockLevelBox::OutOfFlowAbsolutelyPositionedBox( vec![Arc::new(BlockLevelBox::OutOfFlowAbsolutelyPositionedBox(
// AbsolutelyPositionedBox { style, contents }, AbsolutelyPositionedBox { style, contents },
// ))], ))],
// ) )
// } else if style.box_.float.is_floating() { } else if box_style.float.is_floating() {
// ( (
// ContainsFloats::Yes, ContainsFloats::Yes,
// vec![Arc::new(BlockLevelBox::OutOfFlowFloatBox(FloatBox { vec![Arc::new(BlockLevelBox::OutOfFlowFloatBox(FloatBox {
// contents, contents,
// style, style,
// }))], }))],
// ) )
// } else { } else {
// ( (
// ContainsFloats::No, ContainsFloats::No,
// vec![Arc::new(BlockLevelBox::Independent { style, contents })], vec![Arc::new(BlockLevelBox::Independent { style, contents })],
// ) )
// } }
// } }
// impl BoxTreeRoot { impl BoxTreeRoot {
// fn layout(&self, viewport: crate::geom::Size<crate::geom::CssPx>) -> Vec<Fragment> { fn layout(&self, viewport: geom::Size<CSSPixel>) -> Vec<Fragment> {
// let initial_containing_block_size = Vec2 { let initial_containing_block_size = Vec2 {
// inline: Length { px: viewport.width }, inline: Length::new(viewport.width),
// block: Length { block: Length::new(viewport.height),
// px: viewport.height, };
// },
// };
// let initial_containing_block = ContainingBlock { let initial_containing_block = ContainingBlock {
// inline_size: initial_containing_block_size.inline, inline_size: initial_containing_block_size.inline,
// block_size: LengthOrAuto::Length(initial_containing_block_size.block), block_size: LengthOrAuto::LengthPercentage(initial_containing_block_size.block),
// // FIXME: use the document’s mode: // FIXME: use the document’s mode:
// // https://drafts.csswg.org/css-writing-modes/#principal-flow // https://drafts.csswg.org/css-writing-modes/#principal-flow
// mode: (WritingMode::HorizontalTb, Direction::Ltr), mode: (WritingMode::HorizontalTb, Direction::Ltr),
// }; };
// let dummy_tree_rank = 0; let dummy_tree_rank = 0;
// let mut absolutely_positioned_fragments = vec![]; let mut absolutely_positioned_fragments = vec![];
// let mut fragments = self.0.layout( let mut flow_children = self.0.layout(
// &initial_containing_block, &initial_containing_block,
// &mut absolutely_positioned_fragments, dummy_tree_rank,
// dummy_tree_rank, &mut absolutely_positioned_fragments,
// &mut PlacementState::root(), );
// );
// let initial_containing_block = DefiniteContainingBlock { let initial_containing_block = DefiniteContainingBlock {
// size: initial_containing_block_size, size: initial_containing_block_size,
// mode: initial_containing_block.mode, mode: initial_containing_block.mode,
// }; };
// fragments.par_extend( flow_children.fragments.par_extend(
// absolutely_positioned_fragments absolutely_positioned_fragments
// .par_iter() .par_iter()
// .map(|a| a.layout(&initial_containing_block)), .map(|a| a.layout(&initial_containing_block)),
// ); );
// fragments flow_children.fragments
// } }
// } }

27
components/style/properties/longhands/box.mako.rs
View file

@ -42,15 +42,24 @@ ${helpers.single_keyword(
spec="Internal (not web-exposed)", spec="Internal (not web-exposed)",
)} )}
${helpers.single_keyword( <%helpers:single_keyword
"position", name="position"
"static absolute relative fixed" + (" sticky" if engine in ["gecko", "servo-2013"] else ""), values="static absolute relative fixed ${'sticky' if engine in ['gecko', 'servo-2013'] else ''}"
engines="gecko servo-2013 servo-2020", engines="gecko servo-2013 servo-2020"
animation_value_type="discrete", animation_value_type="discrete"
flags="CREATES_STACKING_CONTEXT ABSPOS_CB", flags="CREATES_STACKING_CONTEXT ABSPOS_CB"
spec="https://drafts.csswg.org/css-position/#position-property", spec="https://drafts.csswg.org/css-position/#position-property"
servo_restyle_damage="rebuild_and_reflow", servo_restyle_damage="rebuild_and_reflow"
)} >
impl computed_value::T {
pub fn is_absolutely_positioned(self) -> bool {
match self {
Self::Absolute | Self::Fixed => true,
_ => false,
}
}
}
</%helpers:single_keyword>
${helpers.predefined_type( ${helpers.predefined_type(
"float", "float",

7
components/style/values/computed/box.rs
View file

@ -61,6 +61,13 @@ pub enum Float {
None, None,
} }
impl Float {
/// Returns true if `self` is not `None`.
pub fn is_floating(self) -> bool {
self != Self::None
}
}
impl ToComputedValue for SpecifiedFloat { impl ToComputedValue for SpecifiedFloat {
type ComputedValue = Float; type ComputedValue = Float;