diff options
Diffstat (limited to 'components/layout/construct.rs')
| -rw-r--r-- | components/layout/construct.rs | 1049 |
1 files changed, 1049 insertions, 0 deletions
diff --git a/components/layout/construct.rs b/components/layout/construct.rs new file mode 100644 index 00000000000..0f832bacfb8 --- /dev/null +++ b/components/layout/construct.rs @@ -0,0 +1,1049 @@ +/* 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/. */ + +//! Creates flows and fragments from a DOM tree via a bottom-up, incremental traversal of the DOM. +//! +//! Each step of the traversal considers the node and existing flow, if there is one. If a node is +//! not dirty and an existing flow exists, then the traversal reuses that flow. Otherwise, it +//! proceeds to construct either a flow or a `ConstructionItem`. A construction item is a piece of +//! intermediate data that goes with a DOM node and hasn't found its "home" yet-maybe it's a box, +//! maybe it's an absolute or fixed position thing that hasn't found its containing block yet. +//! Construction items bubble up the tree from children to parents until they find their homes. +//! +//! TODO(pcwalton): There is no incremental reflow yet. This scheme requires that nodes either have +//! weak references to flows or that there be some mechanism to efficiently (O(1) time) "blow +//! apart" a flow tree and have the flows migrate "home" to their respective DOM nodes while we +//! perform flow tree construction. The precise mechanism for this will take some experimentation +//! to get right. + +#![deny(unsafe_block)] + +use css::node_style::StyledNode; +use block::BlockFlow; +use context::LayoutContext; +use floats::FloatKind; +use flow::{Flow, ImmutableFlowUtils, MutableOwnedFlowUtils}; +use flow::{Descendants, AbsDescendants}; +use flow; +use flow_ref::FlowRef; +use fragment::{Fragment, GenericFragment, IframeFragment, IframeFragmentInfo}; +use fragment::{ImageFragment, ImageFragmentInfo, SpecificFragmentInfo, TableFragment}; +use fragment::{TableCellFragment, TableColumnFragment, TableColumnFragmentInfo}; +use fragment::{TableRowFragment, TableWrapperFragment, UnscannedTextFragment}; +use fragment::{UnscannedTextFragmentInfo}; +use inline::{InlineFragments, InlineFlow}; +use parallel; +use table_wrapper::TableWrapperFlow; +use table::TableFlow; +use table_caption::TableCaptionFlow; +use table_colgroup::TableColGroupFlow; +use table_rowgroup::TableRowGroupFlow; +use table_row::TableRowFlow; +use table_cell::TableCellFlow; +use text::TextRunScanner; +use util::{LayoutDataAccess, OpaqueNodeMethods}; +use wrapper::{PostorderNodeMutTraversal, TLayoutNode, ThreadSafeLayoutNode}; +use wrapper::{Before, BeforeBlock, After, AfterBlock, Normal}; + +use gfx::display_list::OpaqueNode; +use script::dom::element::{HTMLIFrameElementTypeId, HTMLImageElementTypeId}; +use script::dom::element::{HTMLObjectElementTypeId}; +use script::dom::element::{HTMLTableColElementTypeId, HTMLTableDataCellElementTypeId}; +use script::dom::element::{HTMLTableElementTypeId, HTMLTableHeaderCellElementTypeId}; +use script::dom::element::{HTMLTableRowElementTypeId, HTMLTableSectionElementTypeId}; +use script::dom::node::{CommentNodeTypeId, DoctypeNodeTypeId, DocumentFragmentNodeTypeId}; +use script::dom::node::{DocumentNodeTypeId, ElementNodeTypeId, ProcessingInstructionNodeTypeId}; +use script::dom::node::{TextNodeTypeId}; +use script::dom::htmlobjectelement::is_image_data; +use servo_util::namespace; +use std::mem; +use std::sync::atomics::Relaxed; +use style::ComputedValues; +use style::computed_values::{display, position, float}; +use sync::Arc; +use url::Url; + +/// The results of flow construction for a DOM node. +pub enum ConstructionResult { + /// This node contributes nothing at all (`display: none`). Alternately, this is what newly + /// created nodes have their `ConstructionResult` set to. + NoConstructionResult, + + /// This node contributed a flow at the proper position in the tree. + /// Nothing more needs to be done for this node. It has bubbled up fixed + /// and absolute descendant flows that have a CB above it. + FlowConstructionResult(FlowRef, AbsDescendants), + + /// This node contributed some object or objects that will be needed to construct a proper flow + /// later up the tree, but these objects have not yet found their home. + ConstructionItemConstructionResult(ConstructionItem), +} + +/// Represents the output of flow construction for a DOM node that has not yet resulted in a +/// complete flow. Construction items bubble up the tree until they find a `Flow` to be +/// attached to. +pub enum ConstructionItem { + /// Inline fragments and associated {ib} splits that have not yet found flows. + InlineFragmentsConstructionItem(InlineFragmentsConstructionResult), + /// Potentially ignorable whitespace. + WhitespaceConstructionItem(OpaqueNode, Arc<ComputedValues>), + /// TableColumn Fragment + TableColumnFragmentConstructionItem(Fragment), +} + +/// Represents inline fragments and {ib} splits that are bubbling up from an inline. +pub struct InlineFragmentsConstructionResult { + /// Any {ib} splits that we're bubbling up. + pub splits: Vec<InlineBlockSplit>, + + /// Any fragments that succeed the {ib} splits. + pub fragments: InlineFragments, + + /// Any absolute descendants that we're bubbling up. + pub abs_descendants: AbsDescendants, +} + +/// Represents an {ib} split that has not yet found the containing block that it belongs to. This +/// is somewhat tricky. An example may be helpful. For this DOM fragment: +/// +/// <span> +/// A +/// <div>B</div> +/// C +/// </span> +/// +/// The resulting `ConstructionItem` for the outer `span` will be: +/// +/// InlineFragmentsConstructionItem(Some(~[ +/// InlineBlockSplit { +/// predecessor_fragments: ~[ +/// A +/// ], +/// block: ~BlockFlow { +/// B +/// }, +/// }),~[ +/// C +/// ]) +pub struct InlineBlockSplit { + /// The inline fragments that precede the flow. + pub predecessors: InlineFragments, + + /// The flow that caused this {ib} split. + pub flow: FlowRef, +} + +/// Holds inline fragments that we're gathering for children of an inline node. +struct InlineFragmentsAccumulator { + /// The list of fragments. + fragments: InlineFragments, + + /// Whether we've created a range to enclose all the fragments. This will be Some() if the outer node + /// is an inline and None otherwise. + enclosing_style: Option<Arc<ComputedValues>>, +} + +impl InlineFragmentsAccumulator { + fn new() -> InlineFragmentsAccumulator { + InlineFragmentsAccumulator { + fragments: InlineFragments::new(), + enclosing_style: None, + } + } + + fn from_inline_node(node: &ThreadSafeLayoutNode) -> InlineFragmentsAccumulator { + let fragments = InlineFragments::new(); + InlineFragmentsAccumulator { + fragments: fragments, + enclosing_style: Some(node.style().clone()), + } + } + + fn finish(self) -> InlineFragments { + let InlineFragmentsAccumulator { + fragments: mut fragments, + enclosing_style + } = self; + + match enclosing_style { + Some(enclosing_style) => { + for frag in fragments.fragments.mut_iter() { + frag.add_inline_context_style(enclosing_style.clone()); + } + } + None => {} + } + fragments + } +} + +enum WhitespaceStrippingMode { + NoWhitespaceStripping, + StripWhitespaceFromStart, + StripWhitespaceFromEnd, +} + +/// An object that knows how to create flows. +pub struct FlowConstructor<'a, 'b> { + /// The layout context. + pub layout_context: &'b LayoutContext<'b>, +} + +impl<'a, 'b> FlowConstructor<'a, 'b> { + /// Creates a new flow constructor. + pub fn new<'b>(layout_context: &'b LayoutContext) + -> FlowConstructor<'a, 'b> { + FlowConstructor { + layout_context: layout_context, + } + } + + /// Builds the `ImageFragmentInfo` for the given image. This is out of line to guide inlining. + fn build_fragment_info_for_image(&mut self, node: &ThreadSafeLayoutNode, url: Option<Url>) + -> SpecificFragmentInfo { + match url { + None => GenericFragment, + Some(url) => { + // FIXME(pcwalton): The fact that image fragments store the cache within them makes + // little sense to me. + ImageFragment(ImageFragmentInfo::new(node, url, self.layout_context.shared.image_cache.clone())) + } + } + } + + /// Builds specific `Fragment` info for the given node. + pub fn build_specific_fragment_info_for_node(&mut self, node: &ThreadSafeLayoutNode) + -> SpecificFragmentInfo { + match node.type_id() { + Some(ElementNodeTypeId(HTMLImageElementTypeId)) => { + self.build_fragment_info_for_image(node, node.image_url()) + } + Some(ElementNodeTypeId(HTMLIFrameElementTypeId)) => { + IframeFragment(IframeFragmentInfo::new(node)) + } + Some(ElementNodeTypeId(HTMLObjectElementTypeId)) => { + let data = node.get_object_data(); + self.build_fragment_info_for_image(node, data) + } + Some(ElementNodeTypeId(HTMLTableElementTypeId)) => TableWrapperFragment, + Some(ElementNodeTypeId(HTMLTableColElementTypeId)) => { + TableColumnFragment(TableColumnFragmentInfo::new(node)) + } + Some(ElementNodeTypeId(HTMLTableDataCellElementTypeId)) | + Some(ElementNodeTypeId(HTMLTableHeaderCellElementTypeId)) => TableCellFragment, + Some(ElementNodeTypeId(HTMLTableRowElementTypeId)) | + Some(ElementNodeTypeId(HTMLTableSectionElementTypeId)) => TableRowFragment, + None | Some(TextNodeTypeId) => UnscannedTextFragment(UnscannedTextFragmentInfo::new(node)), + _ => GenericFragment, + } + } + + /// Creates an inline flow from a set of inline fragments, then adds it as a child of the given flow + /// or pushes it onto the given flow list. + /// + /// `#[inline(always)]` because this is performance critical and LLVM will not inline it + /// otherwise. + #[inline(always)] + fn flush_inline_fragments_to_flow_or_list(&mut self, + fragment_accumulator: InlineFragmentsAccumulator, + flow: &mut FlowRef, + flow_list: &mut Vec<FlowRef>, + whitespace_stripping: WhitespaceStrippingMode, + node: &ThreadSafeLayoutNode) { + let mut fragments = fragment_accumulator.finish(); + if fragments.is_empty() { return }; + + match whitespace_stripping { + NoWhitespaceStripping => {} + StripWhitespaceFromStart => { + fragments.strip_ignorable_whitespace_from_start(); + if fragments.is_empty() { return }; + } + StripWhitespaceFromEnd => { + fragments.strip_ignorable_whitespace_from_end(); + if fragments.is_empty() { return }; + } + } + + let mut inline_flow = box InlineFlow::from_fragments((*node).clone(), fragments); + let (ascent, descent) = inline_flow.compute_minimum_ascent_and_descent(self.layout_context.font_context(), &**node.style()); + inline_flow.minimum_block_size_above_baseline = ascent; + inline_flow.minimum_depth_below_baseline = descent; + let mut inline_flow = inline_flow as Box<Flow>; + TextRunScanner::new().scan_for_runs(self.layout_context.font_context(), inline_flow); + let mut inline_flow = FlowRef::new(inline_flow); + inline_flow.finish(self.layout_context); + + if flow.get().need_anonymous_flow(inline_flow.get()) { + flow_list.push(inline_flow) + } else { + flow.add_new_child(inline_flow) + } + } + + fn build_block_flow_using_children_construction_result(&mut self, + flow: &mut FlowRef, + consecutive_siblings: &mut Vec<FlowRef>, + node: &ThreadSafeLayoutNode, + kid: ThreadSafeLayoutNode, + inline_fragment_accumulator: + &mut InlineFragmentsAccumulator, + abs_descendants: &mut Descendants, + first_fragment: &mut bool) { + match kid.swap_out_construction_result() { + NoConstructionResult => {} + FlowConstructionResult(kid_flow, kid_abs_descendants) => { + // If kid_flow is TableCaptionFlow, kid_flow should be added under + // TableWrapperFlow. + if flow.get().is_table() && kid_flow.get().is_table_caption() { + kid.set_flow_construction_result(FlowConstructionResult( + kid_flow, + Descendants::new())) + } else if flow.get().need_anonymous_flow(kid_flow.get()) { + consecutive_siblings.push(kid_flow) + } else { + // Flush any inline fragments that we were gathering up. This allows us to handle + // {ib} splits. + debug!("flushing {} inline box(es) to flow A", + inline_fragment_accumulator.fragments.len()); + self.flush_inline_fragments_to_flow_or_list( + mem::replace(inline_fragment_accumulator, InlineFragmentsAccumulator::new()), + flow, + consecutive_siblings, + StripWhitespaceFromStart, + node); + if !consecutive_siblings.is_empty() { + let consecutive_siblings = mem::replace(consecutive_siblings, vec!()); + self.generate_anonymous_missing_child(consecutive_siblings, + flow, + node); + } + flow.add_new_child(kid_flow); + } + abs_descendants.push_descendants(kid_abs_descendants); + } + ConstructionItemConstructionResult(InlineFragmentsConstructionItem( + InlineFragmentsConstructionResult { + splits: splits, + fragments: successor_fragments, + abs_descendants: kid_abs_descendants, + })) => { + // Add any {ib} splits. + for split in splits.move_iter() { + // Pull apart the {ib} split object and push its predecessor fragments + // onto the list. + let InlineBlockSplit { + predecessors: predecessors, + flow: kid_flow + } = split; + inline_fragment_accumulator.fragments.push_all(predecessors); + + // If this is the first fragment in flow, then strip ignorable + // whitespace per CSS 2.1 § 9.2.1.1. + let whitespace_stripping = if *first_fragment { + *first_fragment = false; + StripWhitespaceFromStart + } else { + NoWhitespaceStripping + }; + + // Flush any inline fragments that we were gathering up. + debug!("flushing {} inline box(es) to flow A", + inline_fragment_accumulator.fragments.len()); + self.flush_inline_fragments_to_flow_or_list( + mem::replace(inline_fragment_accumulator, + InlineFragmentsAccumulator::new()), + flow, + consecutive_siblings, + whitespace_stripping, + node); + + // Push the flow generated by the {ib} split onto our list of + // flows. + if flow.get().need_anonymous_flow(kid_flow.get()) { + consecutive_siblings.push(kid_flow) + } else { + flow.add_new_child(kid_flow) + } + } + + // Add the fragments to the list we're maintaining. + inline_fragment_accumulator.fragments.push_all(successor_fragments); + abs_descendants.push_descendants(kid_abs_descendants); + } + ConstructionItemConstructionResult(WhitespaceConstructionItem(whitespace_node, whitespace_style)) => { + // Add whitespace results. They will be stripped out later on when + // between block elements, and retained when between inline elements. + let fragment_info = UnscannedTextFragment(UnscannedTextFragmentInfo::from_text(" ".to_string())); + let mut fragment = Fragment::from_opaque_node_and_style(whitespace_node, + whitespace_style.clone(), + fragment_info); + inline_fragment_accumulator.fragments.push(&mut fragment, whitespace_style); + } + ConstructionItemConstructionResult(TableColumnFragmentConstructionItem(_)) => { + // TODO: Implement anonymous table objects for missing parents + // CSS 2.1 § 17.2.1, step 3-2 + } + } + } + + /// Build block flow for current node using information from children nodes. + /// + /// Consume results from children and combine them, handling {ib} splits. + /// Block flows and inline flows thus created will become the children of + /// this block flow. + /// Also, deal with the absolute and fixed descendants bubbled up by + /// children nodes. + fn build_flow_using_children(&mut self, mut flow: FlowRef, node: &ThreadSafeLayoutNode) + -> ConstructionResult { + // Gather up fragments for the inline flows we might need to create. + let mut inline_fragment_accumulator = InlineFragmentsAccumulator::new(); + let mut consecutive_siblings = vec!(); + let mut first_fragment = true; + + // List of absolute descendants, in tree order. + let mut abs_descendants = Descendants::new(); + for kid in node.children() { + if kid.get_pseudo_element_type() != Normal { + self.process(&kid); + } + + self.build_block_flow_using_children_construction_result(&mut flow, + &mut consecutive_siblings, + node, + kid, + &mut inline_fragment_accumulator, + &mut abs_descendants, + &mut first_fragment); + } + + // Perform a final flush of any inline fragments that we were gathering up to handle {ib} + // splits, after stripping ignorable whitespace. + self.flush_inline_fragments_to_flow_or_list(inline_fragment_accumulator, + &mut flow, + &mut consecutive_siblings, + StripWhitespaceFromEnd, + node); + if !consecutive_siblings.is_empty() { + self.generate_anonymous_missing_child(consecutive_siblings, &mut flow, node); + } + + // The flow is done. + flow.finish(self.layout_context); + let is_positioned = flow.get_mut().as_block().is_positioned(); + let is_fixed_positioned = flow.get_mut().as_block().is_fixed(); + let is_absolutely_positioned = flow.get_mut().as_block().is_absolutely_positioned(); + if is_positioned { + // This is the CB for all the absolute descendants. + flow.set_abs_descendants(abs_descendants); + + abs_descendants = Descendants::new(); + + if is_fixed_positioned || is_absolutely_positioned { + // This is now the only absolute flow in the subtree which hasn't yet + // reached its CB. + abs_descendants.push(flow.clone()); + } + } + FlowConstructionResult(flow, abs_descendants) + } + + /// Builds a flow for a node with `display: block`. This yields a `BlockFlow` with possibly + /// other `BlockFlow`s or `InlineFlow`s underneath it, depending on whether {ib} splits needed + /// to happen. + fn build_flow_for_block(&mut self, node: &ThreadSafeLayoutNode) -> ConstructionResult { + let flow = box BlockFlow::from_node(self, node) as Box<Flow>; + self.build_flow_using_children(FlowRef::new(flow), node) + } + + /// Builds the flow for a node with `float: {left|right}`. This yields a float `BlockFlow` with + /// a `BlockFlow` underneath it. + fn build_flow_for_floated_block(&mut self, node: &ThreadSafeLayoutNode, float_kind: FloatKind) + -> ConstructionResult { + let flow = box BlockFlow::float_from_node(self, node, float_kind) as Box<Flow>; + self.build_flow_using_children(FlowRef::new(flow), node) + } + + /// Concatenates the fragments of kids, adding in our own borders/padding/margins if necessary. + /// Returns the `InlineFragmentsConstructionResult`, if any. There will be no + /// `InlineFragmentsConstructionResult` if this node consisted entirely of ignorable whitespace. + fn build_fragments_for_nonreplaced_inline_content(&mut self, node: &ThreadSafeLayoutNode) + -> ConstructionResult { + let mut opt_inline_block_splits: Vec<InlineBlockSplit> = Vec::new(); + let mut fragment_accumulator = InlineFragmentsAccumulator::from_inline_node(node); + let mut abs_descendants = Descendants::new(); + + // Concatenate all the fragments of our kids, creating {ib} splits as necessary. + for kid in node.children() { + if kid.get_pseudo_element_type() != Normal { + self.process(&kid); + } + match kid.swap_out_construction_result() { + NoConstructionResult => {} + FlowConstructionResult(flow, kid_abs_descendants) => { + // {ib} split. Flush the accumulator to our new split and make a new + // accumulator to hold any subsequent fragments we come across. + let split = InlineBlockSplit { + predecessors: + mem::replace(&mut fragment_accumulator, + InlineFragmentsAccumulator::from_inline_node(node)).finish(), + flow: flow, + }; + opt_inline_block_splits.push(split); + abs_descendants.push_descendants(kid_abs_descendants); + } + ConstructionItemConstructionResult(InlineFragmentsConstructionItem( + InlineFragmentsConstructionResult { + splits: splits, + fragments: successors, + abs_descendants: kid_abs_descendants, + })) => { + + // Bubble up {ib} splits. + for split in splits.move_iter() { + let InlineBlockSplit { + predecessors: predecessors, + flow: kid_flow + } = split; + fragment_accumulator.fragments.push_all(predecessors); + + let split = InlineBlockSplit { + predecessors: + mem::replace(&mut fragment_accumulator, + InlineFragmentsAccumulator::from_inline_node(node)) + .finish(), + flow: kid_flow, + }; + opt_inline_block_splits.push(split) + } + + // Push residual fragments. + fragment_accumulator.fragments.push_all(successors); + abs_descendants.push_descendants(kid_abs_descendants); + } + ConstructionItemConstructionResult(WhitespaceConstructionItem(whitespace_node, + whitespace_style)) + => { + // Instantiate the whitespace fragment. + let fragment_info = UnscannedTextFragment(UnscannedTextFragmentInfo::from_text(" ".to_string())); + let mut fragment = Fragment::from_opaque_node_and_style(whitespace_node, + whitespace_style.clone(), + fragment_info); + fragment_accumulator.fragments.push(&mut fragment, whitespace_style) + } + ConstructionItemConstructionResult(TableColumnFragmentConstructionItem(_)) => { + // TODO: Implement anonymous table objects for missing parents + // CSS 2.1 § 17.2.1, step 3-2 + } + } + } + + // Finally, make a new construction result. + if opt_inline_block_splits.len() > 0 || fragment_accumulator.fragments.len() > 0 + || abs_descendants.len() > 0 { + let construction_item = InlineFragmentsConstructionItem(InlineFragmentsConstructionResult { + splits: opt_inline_block_splits, + fragments: fragment_accumulator.finish(), + abs_descendants: abs_descendants, + }); + ConstructionItemConstructionResult(construction_item) + } else { + NoConstructionResult + } + } + + /// Creates an `InlineFragmentsConstructionResult` for replaced content. Replaced content doesn't + /// render its children, so this just nukes a child's fragments and creates a `Fragment`. + fn build_fragments_for_replaced_inline_content(&mut self, node: &ThreadSafeLayoutNode) + -> ConstructionResult { + for kid in node.children() { + kid.set_flow_construction_result(NoConstructionResult) + } + + // If this node is ignorable whitespace, bail out now. + // + // FIXME(#2001, pcwalton): Don't do this if there's padding or borders. + if node.is_ignorable_whitespace() { + let opaque_node = OpaqueNodeMethods::from_thread_safe_layout_node(node); + return ConstructionItemConstructionResult(WhitespaceConstructionItem( + opaque_node, + node.style().clone())) + } + + let mut fragments = InlineFragments::new(); + fragments.push(&mut Fragment::new(self, node), node.style().clone()); + + let construction_item = InlineFragmentsConstructionItem(InlineFragmentsConstructionResult { + splits: Vec::new(), + fragments: fragments, + abs_descendants: Descendants::new(), + }); + ConstructionItemConstructionResult(construction_item) + } + + /// Builds one or more fragments for a node with `display: inline`. This yields an + /// `InlineFragmentsConstructionResult`. + fn build_fragments_for_inline(&mut self, node: &ThreadSafeLayoutNode) -> ConstructionResult { + // Is this node replaced content? + if !node.is_replaced_content() { + // Go to a path that concatenates our kids' fragments. + self.build_fragments_for_nonreplaced_inline_content(node) + } else { + // Otherwise, just nuke our kids' fragments, create our fragment if any, and be done + // with it. + self.build_fragments_for_replaced_inline_content(node) + } + } + + /// TableCaptionFlow is populated underneath TableWrapperFlow + fn place_table_caption_under_table_wrapper(&mut self, + table_wrapper_flow: &mut FlowRef, + node: &ThreadSafeLayoutNode) { + for kid in node.children() { + match kid.swap_out_construction_result() { + NoConstructionResult | ConstructionItemConstructionResult(_) => {} + FlowConstructionResult(kid_flow, _) => { + // Only kid flows with table-caption are matched here. + assert!(kid_flow.get().is_table_caption()); + table_wrapper_flow.add_new_child(kid_flow); + } + } + } + } + + /// Generates an anonymous table flow according to CSS 2.1 § 17.2.1, step 2. + /// If necessary, generate recursively another anonymous table flow. + fn generate_anonymous_missing_child(&mut self, + child_flows: Vec<FlowRef>, + flow: &mut FlowRef, + node: &ThreadSafeLayoutNode) { + let mut anonymous_flow = flow.get().generate_missing_child_flow(node); + let mut consecutive_siblings = vec!(); + for kid_flow in child_flows.move_iter() { + if anonymous_flow.get().need_anonymous_flow(kid_flow.get()) { + consecutive_siblings.push(kid_flow); + continue; + } + if !consecutive_siblings.is_empty() { + self.generate_anonymous_missing_child(consecutive_siblings, + &mut anonymous_flow, + node); + consecutive_siblings = vec!(); + } + anonymous_flow.add_new_child(kid_flow); + } + if !consecutive_siblings.is_empty() { + self.generate_anonymous_missing_child(consecutive_siblings, &mut anonymous_flow, node); + } + // The flow is done. + anonymous_flow.finish(self.layout_context); + flow.add_new_child(anonymous_flow); + } + + /// Builds a flow for a node with `display: table`. This yields a `TableWrapperFlow` with possibly + /// other `TableCaptionFlow`s or `TableFlow`s underneath it. + fn build_flow_for_table_wrapper(&mut self, node: &ThreadSafeLayoutNode) -> ConstructionResult { + let fragment = Fragment::new_from_specific_info(node, TableWrapperFragment); + let wrapper_flow = box TableWrapperFlow::from_node_and_fragment(node, fragment); + let mut wrapper_flow = FlowRef::new(wrapper_flow as Box<Flow>); + + let table_fragment = Fragment::new_from_specific_info(node, TableFragment); + let table_flow = box TableFlow::from_node_and_fragment(node, table_fragment); + let table_flow = FlowRef::new(table_flow as Box<Flow>); + + // We first populate the TableFlow with other flows than TableCaptionFlow. + // We then populate the TableWrapperFlow with TableCaptionFlow, and attach + // the TableFlow to the TableWrapperFlow + let construction_result = self.build_flow_using_children(table_flow, node); + self.place_table_caption_under_table_wrapper(&mut wrapper_flow, node); + + let mut abs_descendants = Descendants::new(); + let mut fixed_descendants = Descendants::new(); + + // NOTE: The order of captions and table are not the same order as in the DOM tree. + // All caption blocks are placed before the table flow + match construction_result { + FlowConstructionResult(table_flow, table_abs_descendants) => { + wrapper_flow.add_new_child(table_flow); + abs_descendants.push_descendants(table_abs_descendants); + } + _ => {} + } + + // The flow is done. + wrapper_flow.finish(self.layout_context); + let is_positioned = wrapper_flow.get_mut().as_block().is_positioned(); + let is_fixed_positioned = wrapper_flow.get_mut().as_block().is_fixed(); + let is_absolutely_positioned = wrapper_flow.get_mut() + .as_block() + .is_absolutely_positioned(); + if is_positioned { + // This is the CB for all the absolute descendants. + wrapper_flow.set_abs_descendants(abs_descendants); + + abs_descendants = Descendants::new(); + + if is_fixed_positioned { + // Send itself along with the other fixed descendants. + fixed_descendants.push(wrapper_flow.clone()); + } else if is_absolutely_positioned { + // This is now the only absolute flow in the subtree which hasn't yet + // reached its CB. + abs_descendants.push(wrapper_flow.clone()); + } + } + FlowConstructionResult(wrapper_flow, abs_descendants) + } + + /// Builds a flow for a node with `display: table-caption`. This yields a `TableCaptionFlow` + /// with possibly other `BlockFlow`s or `InlineFlow`s underneath it. + fn build_flow_for_table_caption(&mut self, node: &ThreadSafeLayoutNode) -> ConstructionResult { + let flow = box TableCaptionFlow::from_node(self, node) as Box<Flow>; + self.build_flow_using_children(FlowRef::new(flow), node) + } + + /// Builds a flow for a node with `display: table-row-group`. This yields a `TableRowGroupFlow` + /// with possibly other `TableRowFlow`s underneath it. + fn build_flow_for_table_rowgroup(&mut self, node: &ThreadSafeLayoutNode) -> ConstructionResult { + let fragment = Fragment::new_from_specific_info(node, TableRowFragment); + let flow = box TableRowGroupFlow::from_node_and_fragment(node, fragment); + let flow = flow as Box<Flow>; + self.build_flow_using_children(FlowRef::new(flow), node) + } + + /// Builds a flow for a node with `display: table-row`. This yields a `TableRowFlow` with + /// possibly other `TableCellFlow`s underneath it. + fn build_flow_for_table_row(&mut self, node: &ThreadSafeLayoutNode) -> ConstructionResult { + let fragment = Fragment::new_from_specific_info(node, TableRowFragment); + let flow = box TableRowFlow::from_node_and_fragment(node, fragment) as Box<Flow>; + self.build_flow_using_children(FlowRef::new(flow), node) + } + + /// Builds a flow for a node with `display: table-cell`. This yields a `TableCellFlow` with + /// possibly other `BlockFlow`s or `InlineFlow`s underneath it. + fn build_flow_for_table_cell(&mut self, node: &ThreadSafeLayoutNode) -> ConstructionResult { + let fragment = Fragment::new_from_specific_info(node, TableCellFragment); + let flow = box TableCellFlow::from_node_and_fragment(node, fragment) as Box<Flow>; + self.build_flow_using_children(FlowRef::new(flow), node) + } + + /// Creates a fragment for a node with `display: table-column`. + fn build_fragments_for_table_column(&mut self, node: &ThreadSafeLayoutNode) -> ConstructionResult { + // CSS 2.1 § 17.2.1. Treat all child fragments of a `table-column` as `display: none`. + for kid in node.children() { + kid.set_flow_construction_result(NoConstructionResult) + } + + let specific = TableColumnFragment(TableColumnFragmentInfo::new(node)); + let construction_item = TableColumnFragmentConstructionItem( + Fragment::new_from_specific_info(node, specific) + ); + ConstructionItemConstructionResult(construction_item) + } + + /// Builds a flow for a node with `display: table-column-group`. + /// This yields a `TableColGroupFlow`. + fn build_flow_for_table_colgroup(&mut self, node: &ThreadSafeLayoutNode) -> ConstructionResult { + let fragment = Fragment::new_from_specific_info(node, + TableColumnFragment(TableColumnFragmentInfo::new(node))); + let mut col_fragments = vec!(); + for kid in node.children() { + // CSS 2.1 § 17.2.1. Treat all non-column child fragments of `table-column-group` + // as `display: none`. + match kid.swap_out_construction_result() { + ConstructionItemConstructionResult(TableColumnFragmentConstructionItem(fragment)) => { + col_fragments.push(fragment); + } + _ => {} + } + } + if col_fragments.is_empty() { + debug!("add TableColumnFragment for empty colgroup"); + let specific = TableColumnFragment(TableColumnFragmentInfo::new(node)); + col_fragments.push(Fragment::new_from_specific_info(node, specific)); + } + let flow = box TableColGroupFlow::from_node_and_fragments(node, fragment, col_fragments); + let mut flow = FlowRef::new(flow as Box<Flow>); + flow.finish(self.layout_context); + + FlowConstructionResult(flow, Descendants::new()) + } +} + +impl<'a, 'b> PostorderNodeMutTraversal for FlowConstructor<'a, 'b> { + // Construct Flow based on 'display', 'position', and 'float' values. + // + // CSS 2.1 Section 9.7 + // + // TODO: This should actually consult the table in that section to get the + // final computed value for 'display'. + // + // `#[inline(always)]` because this is always called from the traversal function and for some + // reason LLVM's inlining heuristics go awry here. + #[inline(always)] + fn process(&mut self, node: &ThreadSafeLayoutNode) -> bool { + // Get the `display` property for this node, and determine whether this node is floated. + let (display, float, positioning) = match node.type_id() { + None => { + // Pseudo-element. + let style = node.style(); + (display::inline, style.get_box().float, style.get_box().position) + } + Some(ElementNodeTypeId(_)) => { + let style = node.style(); + (style.get_box().display, style.get_box().float, style.get_box().position) + } + Some(TextNodeTypeId) => (display::inline, float::none, position::static_), + Some(CommentNodeTypeId) | + Some(DoctypeNodeTypeId) | + Some(DocumentFragmentNodeTypeId) | + Some(DocumentNodeTypeId) | + Some(ProcessingInstructionNodeTypeId) => { + (display::none, float::none, position::static_) + } + }; + + debug!("building flow for node: {:?} {:?}", display, float); + + // Switch on display and floatedness. + match (display, float, positioning) { + // `display: none` contributes no flow construction result. Nuke the flow construction + // results of children. + (display::none, _, _) => { + for child in node.children() { + drop(child.swap_out_construction_result()) + } + } + + // Table items contribute table flow construction results. + (display::table, _, _) => { + let construction_result = self.build_flow_for_table_wrapper(node); + node.set_flow_construction_result(construction_result) + } + + // Absolutely positioned elements will have computed value of + // `float` as 'none' and `display` as per the table. + // Only match here for block items. If an item is absolutely + // positioned, but inline we shouldn't try to construct a block + // flow here - instead, let it match the inline case + // below. + (display::block, _, position::absolute) | (_, _, position::fixed) => { + node.set_flow_construction_result(self.build_flow_for_block(node)) + } + + // Inline items contribute inline fragment construction results. + (display::inline, float::none, _) => { + let construction_result = self.build_fragments_for_inline(node); + node.set_flow_construction_result(construction_result) + } + + // Table items contribute table flow construction results. + (display::table_caption, _, _) => { + let construction_result = self.build_flow_for_table_caption(node); + node.set_flow_construction_result(construction_result) + } + + // Table items contribute table flow construction results. + (display::table_column_group, _, _) => { + let construction_result = self.build_flow_for_table_colgroup(node); + node.set_flow_construction_result(construction_result) + } + + // Table items contribute table flow construction results. + (display::table_column, _, _) => { + let construction_result = self.build_fragments_for_table_column(node); + node.set_flow_construction_result(construction_result) + } + + // Table items contribute table flow construction results. + (display::table_row_group, _, _) | (display::table_header_group, _, _) | + (display::table_footer_group, _, _) => { + let construction_result = self.build_flow_for_table_rowgroup(node); + node.set_flow_construction_result(construction_result) + } + + // Table items contribute table flow construction results. + (display::table_row, _, _) => { + let construction_result = self.build_flow_for_table_row(node); + node.set_flow_construction_result(construction_result) + } + + // Table items contribute table flow construction results. + (display::table_cell, _, _) => { + let construction_result = self.build_flow_for_table_cell(node); + node.set_flow_construction_result(construction_result) + } + + // Block flows that are not floated contribute block flow construction results. + // + // TODO(pcwalton): Make this only trigger for blocks and handle the other `display` + // properties separately. + + (_, float::none, _) => { + node.set_flow_construction_result(self.build_flow_for_block(node)) + } + + // Floated flows contribute float flow construction results. + (_, float_value, _) => { + let float_kind = FloatKind::from_property(float_value); + node.set_flow_construction_result( + self.build_flow_for_floated_block(node, float_kind)) + } + } + + true + } +} + +/// A utility trait with some useful methods for node queries. +trait NodeUtils { + /// Returns true if this node doesn't render its kids and false otherwise. + fn is_replaced_content(&self) -> bool; + + /// Sets the construction result of a flow. + fn set_flow_construction_result(&self, result: ConstructionResult); + + /// Replaces the flow construction result in a node with `NoConstructionResult` and returns the + /// old value. + fn swap_out_construction_result(&self) -> ConstructionResult; +} + +impl<'ln> NodeUtils for ThreadSafeLayoutNode<'ln> { + fn is_replaced_content(&self) -> bool { + match self.type_id() { + Some(TextNodeTypeId) | + Some(ProcessingInstructionNodeTypeId) | + Some(CommentNodeTypeId) | + Some(DoctypeNodeTypeId) | + Some(DocumentFragmentNodeTypeId) | + Some(DocumentNodeTypeId) | + None | + Some(ElementNodeTypeId(HTMLImageElementTypeId)) => true, + Some(ElementNodeTypeId(HTMLObjectElementTypeId)) => self.has_object_data(), + Some(ElementNodeTypeId(_)) => false, + } + } + + #[inline(always)] + fn set_flow_construction_result(&self, result: ConstructionResult) { + let mut layout_data_ref = self.mutate_layout_data(); + match &mut *layout_data_ref { + &Some(ref mut layout_data) =>{ + match self.get_pseudo_element_type() { + Before | BeforeBlock => { + layout_data.data.before_flow_construction_result = result + }, + After | AfterBlock => { + layout_data.data.after_flow_construction_result = result + }, + Normal => layout_data.data.flow_construction_result = result, + } + }, + &None => fail!("no layout data"), + } + } + + #[inline(always)] + fn swap_out_construction_result(&self) -> ConstructionResult { + let mut layout_data_ref = self.mutate_layout_data(); + match &mut *layout_data_ref { + &Some(ref mut layout_data) => { + match self.get_pseudo_element_type() { + Before | BeforeBlock => { + mem::replace(&mut layout_data.data.before_flow_construction_result, + NoConstructionResult) + } + After | AfterBlock => { + mem::replace(&mut layout_data.data.after_flow_construction_result, + NoConstructionResult) + } + Normal => { + mem::replace(&mut layout_data.data.flow_construction_result, + NoConstructionResult) + } + } + } + &None => fail!("no layout data"), + } + } +} + +/// Methods for interacting with HTMLObjectElement nodes +trait ObjectElement { + /// Returns None if this node is not matching attributes. + fn get_type_and_data(&self) -> (Option<&'static str>, Option<&'static str>); + + /// Returns true if this node has object data that is correct uri. + fn has_object_data(&self) -> bool; + + /// Returns the "data" attribute value parsed as a URL + fn get_object_data(&self) -> Option<Url>; +} + +impl<'ln> ObjectElement for ThreadSafeLayoutNode<'ln> { + fn get_type_and_data(&self) -> (Option<&'static str>, Option<&'static str>) { + let elem = self.as_element(); + (elem.get_attr(&namespace::Null, "type"), elem.get_attr(&namespace::Null, "data")) + } + + fn has_object_data(&self) -> bool { + match self.get_type_and_data() { + (None, Some(uri)) => is_image_data(uri), + _ => false + } + } + + fn get_object_data(&self) -> Option<Url> { + match self.get_type_and_data() { + (None, Some(uri)) if is_image_data(uri) => Url::parse(uri).ok(), + _ => None + } + } +} + +pub trait FlowConstructionUtils { + /// Adds a new flow as a child of this flow. Removes the flow from the given leaf set if + /// it's present. + fn add_new_child(&mut self, new_child: FlowRef); + + /// Finishes a flow. Once a flow is finished, no more child flows or boxes may be added to it. + /// This will normally run the bubble-inline-sizes (minimum and preferred -- i.e. intrinsic -- inline-size) + /// calculation, unless the global `bubble_inline-sizes_separately` flag is on. + /// + /// All flows must be finished at some point, or they will not have their intrinsic inline-sizes + /// properly computed. (This is not, however, a memory safety problem.) + fn finish(&mut self, context: &LayoutContext); +} + +impl FlowConstructionUtils for FlowRef { + /// Adds a new flow as a child of this flow. Fails if this flow is marked as a leaf. + /// + /// This must not be public because only the layout constructor can do this. + fn add_new_child(&mut self, mut new_child: FlowRef) { + { + let kid_base = flow::mut_base(new_child.get_mut()); + kid_base.parallel.parent = parallel::mut_owned_flow_to_unsafe_flow(self); + } + + let base = flow::mut_base(self.get_mut()); + base.children.push_back(new_child); + let _ = base.parallel.children_count.fetch_add(1, Relaxed); + let _ = base.parallel.children_and_absolute_descendant_count.fetch_add(1, Relaxed); + } + + /// Finishes a flow. Once a flow is finished, no more child flows or fragments may be added to + /// it. This will normally run the bubble-inline-sizes (minimum and preferred -- i.e. intrinsic -- + /// inline-size) calculation, unless the global `bubble_inline-sizes_separately` flag is on. + /// + /// All flows must be finished at some point, or they will not have their intrinsic inline-sizes + /// properly computed. (This is not, however, a memory safety problem.) + /// + /// This must not be public because only the layout constructor can do this. + fn finish(&mut self, context: &LayoutContext) { + if !context.shared.opts.bubble_inline_sizes_separately { + self.get_mut().bubble_inline_sizes(context) + } + } +} + |