mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-21 01:05:45 +00:00
e47cb58448
Source-Repo: https://github.com/servo/servo Source-Revision: bbfca28a4f3770896955375d01f1c489b4632fd3 --HG-- extra : subtree_source : https%3A//hg.mozilla.org/projects/converted-servo-linear extra : subtree_revision : cca02ea2c160395889cfd6eb60c62a065d490300
335 lines
11 KiB
Rust
335 lines
11 KiB
Rust
/* 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 http://mozilla.org/MPL/2.0/. */
|
|
|
|
//! Traversals over the DOM and flow trees, running the layout computations.
|
|
|
|
use construct::FlowConstructor;
|
|
use context::LayoutContext;
|
|
use display_list::DisplayListBuildState;
|
|
use flow::{FlowFlags, Flow, GetBaseFlow, ImmutableFlowUtils};
|
|
use script_layout_interface::wrapper_traits::{LayoutNode, ThreadSafeLayoutNode};
|
|
use servo_config::opts;
|
|
use style::context::{SharedStyleContext, StyleContext};
|
|
use style::data::ElementData;
|
|
use style::dom::{NodeInfo, TElement, TNode};
|
|
use style::selector_parser::RestyleDamage;
|
|
use style::servo::restyle_damage::ServoRestyleDamage;
|
|
use style::traversal::{DomTraversal, recalc_style_at};
|
|
use style::traversal::PerLevelTraversalData;
|
|
use wrapper::{GetRawData, LayoutNodeLayoutData};
|
|
use wrapper::ThreadSafeLayoutNodeHelpers;
|
|
|
|
pub struct RecalcStyleAndConstructFlows<'a> {
|
|
context: LayoutContext<'a>,
|
|
}
|
|
|
|
impl<'a> RecalcStyleAndConstructFlows<'a> {
|
|
pub fn layout_context(&self) -> &LayoutContext<'a> {
|
|
&self.context
|
|
}
|
|
}
|
|
|
|
impl<'a> RecalcStyleAndConstructFlows<'a> {
|
|
/// Creates a traversal context, taking ownership of the shared layout context.
|
|
pub fn new(context: LayoutContext<'a>) -> Self {
|
|
RecalcStyleAndConstructFlows {
|
|
context: context,
|
|
}
|
|
}
|
|
|
|
/// Consumes this traversal context, returning ownership of the shared layout
|
|
/// context to the caller.
|
|
pub fn destroy(self) -> LayoutContext<'a> {
|
|
self.context
|
|
}
|
|
}
|
|
|
|
#[allow(unsafe_code)]
|
|
impl<'a, E> DomTraversal<E> for RecalcStyleAndConstructFlows<'a>
|
|
where
|
|
E: TElement,
|
|
E::ConcreteNode: LayoutNode,
|
|
E::FontMetricsProvider: Send,
|
|
{
|
|
fn process_preorder<F>(
|
|
&self,
|
|
traversal_data: &PerLevelTraversalData,
|
|
context: &mut StyleContext<E>, node: E::ConcreteNode,
|
|
note_child: F,
|
|
)
|
|
where
|
|
F: FnMut(E::ConcreteNode)
|
|
{
|
|
// FIXME(pcwalton): Stop allocating here. Ideally this should just be
|
|
// done by the HTML parser.
|
|
unsafe { node.initialize_data() };
|
|
|
|
if !node.is_text_node() {
|
|
let el = node.as_element().unwrap();
|
|
let mut data = el.mutate_data().unwrap();
|
|
recalc_style_at(self, traversal_data, context, el, &mut data, note_child);
|
|
}
|
|
}
|
|
|
|
fn process_postorder(&self, _style_context: &mut StyleContext<E>, node: E::ConcreteNode) {
|
|
construct_flows_at(&self.context, node);
|
|
}
|
|
|
|
fn text_node_needs_traversal(node: E::ConcreteNode, parent_data: &ElementData) -> bool {
|
|
// Text nodes never need styling. However, there are two cases they may need
|
|
// flow construction:
|
|
// (1) They child doesn't yet have layout data (preorder traversal initializes it).
|
|
// (2) The parent element has restyle damage (so the text flow also needs fixup).
|
|
node.get_raw_data().is_none() || !parent_data.damage.is_empty()
|
|
}
|
|
|
|
fn shared_context(&self) -> &SharedStyleContext {
|
|
&self.context.style_context
|
|
}
|
|
}
|
|
|
|
/// A top-down traversal.
|
|
pub trait PreorderFlowTraversal {
|
|
/// The operation to perform. Return true to continue or false to stop.
|
|
fn process(&self, flow: &mut Flow);
|
|
|
|
/// Returns true if this node should be processed and false if neither this node nor its
|
|
/// descendants should be processed.
|
|
fn should_process_subtree(&self, _flow: &mut Flow) -> bool {
|
|
true
|
|
}
|
|
|
|
/// Returns true if this node must be processed in-order. If this returns false,
|
|
/// we skip the operation for this node, but continue processing the descendants.
|
|
/// This is called *after* parent nodes are visited.
|
|
fn should_process(&self, _flow: &mut Flow) -> bool {
|
|
true
|
|
}
|
|
|
|
/// Traverses the tree in preorder.
|
|
fn traverse(&self, flow: &mut Flow) {
|
|
if !self.should_process_subtree(flow) {
|
|
return;
|
|
}
|
|
if self.should_process(flow) {
|
|
self.process(flow);
|
|
}
|
|
for kid in flow.mut_base().child_iter_mut() {
|
|
self.traverse(kid);
|
|
}
|
|
}
|
|
|
|
/// Traverse the Absolute flow tree in preorder.
|
|
///
|
|
/// Traverse all your direct absolute descendants, who will then traverse
|
|
/// their direct absolute descendants.
|
|
///
|
|
/// Return true if the traversal is to continue or false to stop.
|
|
fn traverse_absolute_flows(&self, flow: &mut Flow) {
|
|
if self.should_process(flow) {
|
|
self.process(flow);
|
|
}
|
|
for descendant_link in flow.mut_base().abs_descendants.iter() {
|
|
self.traverse_absolute_flows(descendant_link)
|
|
}
|
|
}
|
|
}
|
|
|
|
/// A bottom-up traversal, with a optional in-order pass.
|
|
pub trait PostorderFlowTraversal {
|
|
/// The operation to perform. Return true to continue or false to stop.
|
|
fn process(&self, flow: &mut Flow);
|
|
|
|
/// Returns false if this node must be processed in-order. If this returns false, we skip the
|
|
/// operation for this node, but continue processing the ancestors. This is called *after*
|
|
/// child nodes are visited.
|
|
fn should_process(&self, _flow: &mut Flow) -> bool {
|
|
true
|
|
}
|
|
|
|
/// Traverses the tree in postorder.
|
|
fn traverse(&self, flow: &mut Flow) {
|
|
for kid in flow.mut_base().child_iter_mut() {
|
|
self.traverse(kid);
|
|
}
|
|
if self.should_process(flow) {
|
|
self.process(flow);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// An in-order (sequential only) traversal.
|
|
pub trait InorderFlowTraversal {
|
|
/// The operation to perform. Returns the level of the tree we're at.
|
|
fn process(&mut self, flow: &mut Flow, level: u32);
|
|
|
|
/// Returns true if this node should be processed and false if neither this node nor its
|
|
/// descendants should be processed.
|
|
fn should_process_subtree(&mut self, _flow: &mut Flow) -> bool {
|
|
true
|
|
}
|
|
|
|
/// Traverses the tree in-order.
|
|
fn traverse(&mut self, flow: &mut Flow, level: u32) {
|
|
if !self.should_process_subtree(flow) {
|
|
return;
|
|
}
|
|
self.process(flow, level);
|
|
for kid in flow.mut_base().child_iter_mut() {
|
|
self.traverse(kid, level + 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// A bottom-up, parallelizable traversal.
|
|
pub trait PostorderNodeMutTraversal<ConcreteThreadSafeLayoutNode: ThreadSafeLayoutNode> {
|
|
/// The operation to perform. Return true to continue or false to stop.
|
|
fn process(&mut self, node: &ConcreteThreadSafeLayoutNode);
|
|
}
|
|
|
|
/// The flow construction traversal, which builds flows for styled nodes.
|
|
#[inline]
|
|
#[allow(unsafe_code)]
|
|
fn construct_flows_at<N>(context: &LayoutContext, node: N)
|
|
where N: LayoutNode,
|
|
{
|
|
debug!("construct_flows_at: {:?}", node);
|
|
|
|
// Construct flows for this node.
|
|
{
|
|
let tnode = node.to_threadsafe();
|
|
|
|
// Always reconstruct if incremental layout is turned off.
|
|
let nonincremental_layout = opts::get().nonincremental_layout;
|
|
if nonincremental_layout || tnode.restyle_damage() != RestyleDamage::empty() ||
|
|
node.as_element().map_or(false, |el| el.has_dirty_descendants()) {
|
|
let mut flow_constructor = FlowConstructor::new(context);
|
|
if nonincremental_layout || !flow_constructor.repair_if_possible(&tnode) {
|
|
flow_constructor.process(&tnode);
|
|
debug!("Constructed flow for {:?}: {:x}",
|
|
tnode,
|
|
tnode.flow_debug_id());
|
|
}
|
|
}
|
|
|
|
tnode.mutate_layout_data().unwrap().flags.insert(::data::LayoutDataFlags::HAS_BEEN_TRAVERSED);
|
|
}
|
|
|
|
if let Some(el) = node.as_element() {
|
|
unsafe { el.unset_dirty_descendants(); }
|
|
}
|
|
}
|
|
|
|
/// The bubble-inline-sizes traversal, the first part of layout computation. This computes
|
|
/// preferred and intrinsic inline-sizes and bubbles them up the tree.
|
|
pub struct BubbleISizes<'a> {
|
|
pub layout_context: &'a LayoutContext<'a>,
|
|
}
|
|
|
|
impl<'a> PostorderFlowTraversal for BubbleISizes<'a> {
|
|
#[inline]
|
|
fn process(&self, flow: &mut Flow) {
|
|
flow.bubble_inline_sizes();
|
|
flow.mut_base().restyle_damage.remove(ServoRestyleDamage::BUBBLE_ISIZES);
|
|
}
|
|
|
|
#[inline]
|
|
fn should_process(&self, flow: &mut Flow) -> bool {
|
|
flow.base().restyle_damage.contains(ServoRestyleDamage::BUBBLE_ISIZES)
|
|
}
|
|
}
|
|
|
|
/// The assign-inline-sizes traversal. In Gecko this corresponds to `Reflow`.
|
|
#[derive(Clone, Copy)]
|
|
pub struct AssignISizes<'a> {
|
|
pub layout_context: &'a LayoutContext<'a>,
|
|
}
|
|
|
|
impl<'a> PreorderFlowTraversal for AssignISizes<'a> {
|
|
#[inline]
|
|
fn process(&self, flow: &mut Flow) {
|
|
flow.assign_inline_sizes(self.layout_context);
|
|
}
|
|
|
|
#[inline]
|
|
fn should_process(&self, flow: &mut Flow) -> bool {
|
|
flow.base().restyle_damage.intersects(ServoRestyleDamage::REFLOW_OUT_OF_FLOW | ServoRestyleDamage::REFLOW)
|
|
}
|
|
}
|
|
|
|
/// The assign-block-sizes-and-store-overflow traversal, the last (and most expensive) part of
|
|
/// layout computation. Determines the final block-sizes for all layout objects and computes
|
|
/// positions. In Gecko this corresponds to `Reflow`.
|
|
#[derive(Clone, Copy)]
|
|
pub struct AssignBSizes<'a> {
|
|
pub layout_context: &'a LayoutContext<'a>,
|
|
}
|
|
|
|
impl<'a> PostorderFlowTraversal for AssignBSizes<'a> {
|
|
#[inline]
|
|
fn process(&self, flow: &mut Flow) {
|
|
// Can't do anything with anything that floats might flow through until we reach their
|
|
// inorder parent.
|
|
//
|
|
// NB: We must return without resetting the restyle bits for these, as we haven't actually
|
|
// reflowed anything!
|
|
if flow.floats_might_flow_through() {
|
|
return
|
|
}
|
|
|
|
flow.assign_block_size(self.layout_context);
|
|
}
|
|
|
|
#[inline]
|
|
fn should_process(&self, flow: &mut Flow) -> bool {
|
|
let base = flow.base();
|
|
base.restyle_damage.intersects(ServoRestyleDamage::REFLOW_OUT_OF_FLOW | ServoRestyleDamage::REFLOW) &&
|
|
// The fragmentation countainer is responsible for calling
|
|
// Flow::fragment recursively
|
|
!base.flags.contains(FlowFlags::CAN_BE_FRAGMENTED)
|
|
}
|
|
}
|
|
|
|
pub struct ComputeStackingRelativePositions<'a> {
|
|
pub layout_context: &'a LayoutContext<'a>,
|
|
}
|
|
|
|
impl<'a> PreorderFlowTraversal for ComputeStackingRelativePositions<'a> {
|
|
#[inline]
|
|
fn should_process_subtree(&self, flow: &mut Flow) -> bool {
|
|
flow.base().restyle_damage.contains(ServoRestyleDamage::REPOSITION)
|
|
}
|
|
|
|
#[inline]
|
|
fn process(&self, flow: &mut Flow) {
|
|
flow.compute_stacking_relative_position(self.layout_context);
|
|
flow.mut_base().restyle_damage.remove(ServoRestyleDamage::REPOSITION)
|
|
}
|
|
}
|
|
|
|
pub struct BuildDisplayList<'a> {
|
|
pub state: DisplayListBuildState<'a>,
|
|
}
|
|
|
|
impl<'a> BuildDisplayList<'a> {
|
|
#[inline]
|
|
pub fn traverse(&mut self, flow: &mut Flow) {
|
|
let parent_stacking_context_id = self.state.current_stacking_context_id;
|
|
self.state.current_stacking_context_id = flow.base().stacking_context_id;
|
|
|
|
let parent_clipping_and_scrolling = self.state.current_clipping_and_scrolling;
|
|
self.state.current_clipping_and_scrolling = flow.clipping_and_scrolling();
|
|
|
|
flow.build_display_list(&mut self.state);
|
|
flow.mut_base().restyle_damage.remove(ServoRestyleDamage::REPAINT);
|
|
|
|
for kid in flow.mut_base().child_iter_mut() {
|
|
self.traverse(kid);
|
|
}
|
|
|
|
self.state.current_stacking_context_id = parent_stacking_context_id;
|
|
self.state.current_clipping_and_scrolling = parent_clipping_and_scrolling;
|
|
}
|
|
}
|