/* 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 boxes 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. //! //! TODO(pcwalton): This scheme should be amenable to parallelization, but, of course, that's not //! yet implemented. use css::node_style::StyledNode; use layout::block::BlockFlow; use layout::box_::{Box, GenericBox, IframeBox, IframeBoxInfo, ImageBox, ImageBoxInfo}; use layout::box_::{InlineInfo, InlineParentInfo, SpecificBoxInfo}; use layout::box_::{TableBox, TableCellBox, TableColumnBox, TableColumnBoxInfo, TableRowBox}; use layout::box_::{TableWrapperBox, UnscannedTextBox, UnscannedTextBoxInfo}; use layout::context::LayoutContext; use layout::floats::FloatKind; use layout::flow::{Flow, ImmutableFlowUtils, MutableOwnedFlowUtils}; use layout::flow::{Descendants, AbsDescendants}; use layout::flow_list::{Rawlink}; use layout::inline::InlineFlow; use layout::table_wrapper::TableWrapperFlow; use layout::table::TableFlow; use layout::table_caption::TableCaptionFlow; use layout::table_colgroup::TableColGroupFlow; use layout::table_rowgroup::TableRowGroupFlow; use layout::table_row::TableRowFlow; use layout::table_cell::TableCellFlow; use layout::text::TextRunScanner; use layout::util::{LayoutDataAccess, OpaqueNodeMethods}; use layout::wrapper::{PostorderNodeMutTraversal, TLayoutNode, ThreadSafeLayoutNode}; use layout::wrapper::{Before, BeforeBlock, After, AfterBlock, Normal}; use gfx::display_list::OpaqueNode; use gfx::font_context::FontContext; use script::dom::bindings::codegen::InheritTypes::TextCast; use script::dom::bindings::js::JS; 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::text::Text; use servo_util::geometry::Au; use servo_util::namespace; use servo_util::smallvec::SmallVec; use servo_util::str::is_whitespace; use servo_util::url::{is_image_data, parse_url}; use std::mem; use std::num::Zero; use style::ComputedValues; use style::computed_values::{display, position, float, white_space}; 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(~Flow, 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), } impl ConstructionResult { fn destroy(&mut self) { match *self { NoConstructionResult => {} FlowConstructionResult(ref mut flow, _) => flow.destroy(), ConstructionItemConstructionResult(ref mut item) => item.destroy(), } } } /// 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. enum ConstructionItem { /// Inline boxes and associated {ib} splits that have not yet found flows. InlineBoxesConstructionItem(InlineBoxesConstructionResult), /// Potentially ignorable whitespace. WhitespaceConstructionItem(OpaqueNode, Arc), /// TableColumn Box TableColumnBoxConstructionItem(Box), } impl ConstructionItem { fn destroy(&mut self) { match *self { InlineBoxesConstructionItem(ref mut result) => { for splits in result.splits.mut_iter() { for split in splits.mut_iter() { split.destroy() } } } WhitespaceConstructionItem(..) => {} TableColumnBoxConstructionItem(_) => {} } } } /// Represents inline boxes and {ib} splits that are bubbling up from an inline. struct InlineBoxesConstructionResult { /// Any {ib} splits that we're bubbling up. /// /// TODO(pcwalton): Small vector optimization. splits: Option<~[InlineBlockSplit]>, /// Any boxes that succeed the {ib} splits. boxes: ~[Box], /// Any absolute descendants that we're bubbling up. 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: /// /// /// A ///
B
/// C /// /// /// The resulting `ConstructionItem` for the outer `span` will be: /// /// InlineBoxesConstructionItem(Some(~[ /// InlineBlockSplit { /// predecessor_boxes: ~[ /// A /// ], /// block: ~BlockFlow { /// B /// }, /// }),~[ /// C /// ]) struct InlineBlockSplit { /// The inline boxes that precede the flow. /// /// TODO(pcwalton): Small vector optimization. predecessor_boxes: ~[Box], /// The flow that caused this {ib} split. flow: ~Flow, } impl InlineBlockSplit { fn destroy(&mut self) { self.flow.destroy() } } /// Methods on optional vectors. /// /// TODO(pcwalton): I think this will no longer be necessary once Rust #8981 lands. pub trait OptVector { /// Turns this optional vector into an owned one. If the optional vector is `None`, then this /// simply returns an empty owned vector. fn to_vec(self) -> ~[T]; /// Pushes a value onto this vector. fn push(&mut self, value: T); /// Pushes a vector onto this vector, consuming the original. fn push_all_move(&mut self, values: ~[T]); /// Pushes an optional vector onto this vector, consuming the original. fn push_opt_vec_move(&mut self, values: Self); /// Returns the length of this optional vector. fn len(&self) -> uint; } impl OptVector for Option<~[T]> { #[inline] fn to_vec(self) -> ~[T] { match self { None => ~[], Some(vector) => vector, } } #[inline] fn push(&mut self, value: T) { match *self { None => *self = Some(~[value]), Some(ref mut vector) => vector.push(value), } } #[inline] fn push_all_move(&mut self, values: ~[T]) { match *self { None => *self = Some(values), Some(ref mut vector) => vector.push_all_move(values), } } #[inline] fn push_opt_vec_move(&mut self, values: Option<~[T]>) { match values { None => {} Some(values) => self.push_all_move(values), } } #[inline] fn len(&self) -> uint { match *self { None => 0, Some(ref vector) => vector.len(), } } } /// An object that knows how to create flows. pub struct FlowConstructor<'a> { /// The layout context. layout_context: &'a mut LayoutContext, /// An optional font context. If this is `None`, then we fetch the font context from the /// layout context. /// /// FIXME(pcwalton): This is pretty bogus and is basically just a workaround for libgreen /// having slow TLS. font_context: Option<~FontContext>, } impl<'a> FlowConstructor<'a> { /// Creates a new flow constructor. pub fn new(layout_context: &'a mut LayoutContext, font_context: Option<~FontContext>) -> FlowConstructor<'a> { FlowConstructor { layout_context: layout_context, font_context: font_context, } } fn font_context<'a>(&'a mut self) -> &'a mut FontContext { match self.font_context { Some(ref mut font_context) => { let font_context: &mut FontContext = *font_context; font_context } None => self.layout_context.font_context(), } } /// Destroys this flow constructor and retrieves the font context. pub fn unwrap_font_context(self) -> Option<~FontContext> { let FlowConstructor { font_context, .. } = self; font_context } /// Builds the `ImageBoxInfo` for the given image. This is out of line to guide inlining. fn build_box_info_for_image(&mut self, node: &ThreadSafeLayoutNode, url: Option) -> SpecificBoxInfo { match url { None => GenericBox, Some(url) => { // FIXME(pcwalton): The fact that image boxes store the cache within them makes // little sense to me. ImageBox(ImageBoxInfo::new(node, url, self.layout_context.image_cache.clone())) } } } /// Builds specific `Box` info for the given node. pub fn build_specific_box_info_for_node(&mut self, node: &ThreadSafeLayoutNode) -> SpecificBoxInfo { match node.type_id() { Some(ElementNodeTypeId(HTMLImageElementTypeId)) => { self.build_box_info_for_image(node, node.image_url()) } Some(ElementNodeTypeId(HTMLIFrameElementTypeId)) => { IframeBox(IframeBoxInfo::new(node)) } Some(ElementNodeTypeId(HTMLObjectElementTypeId)) => { let data = node.get_object_data(&self.layout_context.url); self.build_box_info_for_image(node, data) } Some(ElementNodeTypeId(HTMLTableElementTypeId)) => TableWrapperBox, Some(ElementNodeTypeId(HTMLTableColElementTypeId)) => { TableColumnBox(TableColumnBoxInfo::new(node)) } Some(ElementNodeTypeId(HTMLTableDataCellElementTypeId)) | Some(ElementNodeTypeId(HTMLTableHeaderCellElementTypeId)) => TableCellBox, Some(ElementNodeTypeId(HTMLTableRowElementTypeId)) | Some(ElementNodeTypeId(HTMLTableSectionElementTypeId)) => TableRowBox, None | Some(TextNodeTypeId) => UnscannedTextBox(UnscannedTextBoxInfo::new(node)), _ => GenericBox, } } /// Creates an inline flow from a set of inline boxes, 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_boxes_to_flow_or_list(&mut self, boxes: ~[Box], flow: &mut ~Flow, flow_list: &mut ~[~Flow], node: &ThreadSafeLayoutNode) { if boxes.len() == 0 { return } let mut inline_flow = ~InlineFlow::from_boxes((*node).clone(), boxes) as ~Flow; TextRunScanner::new().scan_for_runs(self.font_context(), inline_flow); inline_flow.finish(self.layout_context); if flow.need_anonymous_flow(inline_flow) { flow_list.push(inline_flow) } else { flow.add_new_child(inline_flow) } } /// Creates an inline flow from a set of inline boxes, if present, and adds it as a child of /// the given flow or pushes it onto the given flow list. fn flush_inline_boxes_to_flow_or_list_if_necessary(&mut self, opt_boxes: &mut Option<~[Box]>, flow: &mut ~Flow, flow_list: &mut ~[~Flow], node: &ThreadSafeLayoutNode) { let opt_boxes = mem::replace(opt_boxes, None); if opt_boxes.len() > 0 { self.flush_inline_boxes_to_flow_or_list(opt_boxes.to_vec(), flow, flow_list, node) } } fn build_block_flow_using_children_construction_result(&mut self, flow: &mut ~Flow, consecutive_siblings: &mut ~[~Flow], node: &ThreadSafeLayoutNode, kid: ThreadSafeLayoutNode, opt_boxes_for_inline_flow: &mut Option<~[Box]>, abs_descendants: &mut Descendants, first_box: &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.is_table() && kid_flow.is_table_caption() { kid.set_flow_construction_result(FlowConstructionResult( kid_flow, Descendants::new())) } else if flow.need_anonymous_flow(kid_flow) { consecutive_siblings.push(kid_flow) } else { // Strip ignorable whitespace from the start of this flow per CSS 2.1 § // 9.2.1.1. if flow.is_table_kind() || *first_box { strip_ignorable_whitespace_from_start(opt_boxes_for_inline_flow); *first_box = false } // Flush any inline boxes that we were gathering up. This allows us to handle // {ib} splits. debug!("flushing {} inline box(es) to flow A", opt_boxes_for_inline_flow.as_ref() .map_or(0, |boxes| boxes.len())); self.flush_inline_boxes_to_flow_or_list_if_necessary( opt_boxes_for_inline_flow, flow, consecutive_siblings, node); if !consecutive_siblings.is_empty() { let consecutive_siblings = mem::replace(consecutive_siblings, ~[]); self.generate_anonymous_missing_child(consecutive_siblings, flow, node); } flow.add_new_child(kid_flow); } abs_descendants.push_descendants(kid_abs_descendants); } ConstructionItemConstructionResult(InlineBoxesConstructionItem( InlineBoxesConstructionResult { splits: opt_splits, boxes: boxes, abs_descendants: kid_abs_descendants, })) => { // Add any {ib} splits. match opt_splits { None => {} Some(splits) => { for split in splits.move_iter() { // Pull apart the {ib} split object and push its predecessor boxes // onto the list. let InlineBlockSplit { predecessor_boxes: predecessor_boxes, flow: kid_flow } = split; opt_boxes_for_inline_flow.push_all_move(predecessor_boxes); // If this is the first box in flow, then strip ignorable // whitespace per CSS 2.1 § 9.2.1.1. if *first_box { strip_ignorable_whitespace_from_start( opt_boxes_for_inline_flow); *first_box = false } // Flush any inline boxes that we were gathering up. debug!("flushing {} inline box(es) to flow A", opt_boxes_for_inline_flow.as_ref() .map_or(0, |boxes| boxes.len())); self.flush_inline_boxes_to_flow_or_list_if_necessary( opt_boxes_for_inline_flow, flow, consecutive_siblings, node); // Push the flow generated by the {ib} split onto our list of // flows. if flow.need_anonymous_flow(kid_flow) { consecutive_siblings.push(kid_flow) } else { flow.add_new_child(kid_flow) } } } } // Add the boxes to the list we're maintaining. opt_boxes_for_inline_flow.push_all_move(boxes); abs_descendants.push_descendants(kid_abs_descendants); } ConstructionItemConstructionResult(WhitespaceConstructionItem(..)) => { // Nothing to do here. } ConstructionItemConstructionResult(TableColumnBoxConstructionItem(_)) => { // 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: ~Flow, node: &ThreadSafeLayoutNode) -> ConstructionResult { // Gather up boxes for the inline flows we might need to create. let mut opt_boxes_for_inline_flow = None; let mut consecutive_siblings = ~[]; let mut first_box = true; // List of absolute descendants, in tree order. let mut abs_descendants = Descendants::new(); for kid in node.children() { if kid.get_element_type() != Normal { self.process(&kid); } self.build_block_flow_using_children_construction_result( &mut flow, &mut consecutive_siblings, node, kid, &mut opt_boxes_for_inline_flow, &mut abs_descendants, &mut first_box); } // Perform a final flush of any inline boxes that we were gathering up to handle {ib} // splits, after stripping ignorable whitespace. strip_ignorable_whitespace_from_end(&mut opt_boxes_for_inline_flow); self.flush_inline_boxes_to_flow_or_list_if_necessary(&mut opt_boxes_for_inline_flow, &mut flow, &mut consecutive_siblings, 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.as_block().is_positioned(); let is_fixed_positioned = flow.as_block().is_fixed(); let is_absolutely_positioned = flow.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(Rawlink::some(flow)); } } 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 = ~BlockFlow::from_node(self, node) as ~Flow; self.build_flow_using_children(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 = ~BlockFlow::float_from_node(self, node, float_kind) as ~Flow; self.build_flow_using_children(flow, node) } /// Concatenates the boxes of kids, adding in our own borders/padding/margins if necessary. /// Returns the `InlineBoxesConstructionResult`, if any. There will be no /// `InlineBoxesConstructionResult` if this node consisted entirely of ignorable whitespace. fn build_boxes_for_nonreplaced_inline_content(&mut self, node: &ThreadSafeLayoutNode) -> ConstructionResult { let mut opt_inline_block_splits = None; let mut opt_box_accumulator = None; let mut abs_descendants = Descendants::new(); // Concatenate all the boxes of our kids, creating {ib} splits as necessary. for kid in node.children() { 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 boxes we come across. let split = InlineBlockSplit { predecessor_boxes: mem::replace(&mut opt_box_accumulator, None).to_vec(), flow: flow, }; opt_inline_block_splits.push(split); abs_descendants.push_descendants(kid_abs_descendants); } ConstructionItemConstructionResult(InlineBoxesConstructionItem( InlineBoxesConstructionResult { splits: opt_splits, boxes: boxes, abs_descendants: kid_abs_descendants, })) => { // Bubble up {ib} splits. match opt_splits { None => {} Some(splits) => { for split in splits.move_iter() { let InlineBlockSplit { predecessor_boxes: boxes, flow: kid_flow } = split; opt_box_accumulator.push_all_move(boxes); let split = InlineBlockSplit { predecessor_boxes: mem::replace(&mut opt_box_accumulator, None).to_vec(), flow: kid_flow, }; opt_inline_block_splits.push(split) } } } // Push residual boxes. opt_box_accumulator.push_all_move(boxes); abs_descendants.push_descendants(kid_abs_descendants); } ConstructionItemConstructionResult(WhitespaceConstructionItem(whitespace_node, whitespace_style)) => { // Instantiate the whitespace box. opt_box_accumulator.push(Box::from_opaque_node_and_style( whitespace_node, whitespace_style, UnscannedTextBox(UnscannedTextBoxInfo::from_text(~" ")))) } ConstructionItemConstructionResult(TableColumnBoxConstructionItem(_)) => { // TODO: Implement anonymous table objects for missing parents // CSS 2.1 § 17.2.1, step 3-2 } } } // fill inline info match opt_inline_block_splits { Some(ref splits) => { match opt_box_accumulator { Some(ref boxes) => { // Both let mut total: ~[&Box] = ~[]; for split in splits.iter() { for box_ in split.predecessor_boxes.iter() { total.push(box_); } } for box_ in boxes.iter() { total.push(box_); } self.set_inline_info_for_inline_child(total, node); }, None => { let mut total: ~[&Box] = ~[]; for split in splits.iter() { for box_ in split.predecessor_boxes.iter() { total.push(box_); } } self.set_inline_info_for_inline_child(total, node); } } }, None => { match opt_box_accumulator { Some(ref boxes) => { let mut total: ~[&Box] = ~[]; for box_ in boxes.iter() { total.push(box_); } self.set_inline_info_for_inline_child(total, node); }, None => {} } } } // Finally, make a new construction result. if opt_inline_block_splits.len() > 0 || opt_box_accumulator.len() > 0 || abs_descendants.len() > 0 { let construction_item = InlineBoxesConstructionItem(InlineBoxesConstructionResult { splits: opt_inline_block_splits, boxes: opt_box_accumulator.to_vec(), abs_descendants: abs_descendants, }); ConstructionItemConstructionResult(construction_item) } else { NoConstructionResult } } // FIXME(#1999, pcwalton): Why does this function create a box only to throw it away??? fn set_inline_info_for_inline_child(&mut self, boxes: &[&Box], parent_node: &ThreadSafeLayoutNode) { let parent_box = Box::new(self, parent_node); let font_style = parent_box.font_style(); let font_group = self.font_context().get_resolved_font_for_style(&font_style); let (font_ascent,font_descent) = { let fg = font_group.borrow(); let font = fg.fonts[0].borrow(); (font.metrics.ascent,font.metrics.descent) }; let boxes_len = boxes.len(); parent_box.compute_borders(parent_box.style()); // FIXME(#2000, pcwalton): I suspect that `Au(0)` is not correct for the containing block // width. parent_box.compute_padding(parent_box.style(), Au(0)); for (i, box_) in boxes.iter().enumerate() { let mut info = box_.inline_info.borrow_mut(); if info.is_none() { *info = Some(InlineInfo::new()); } let mut border = parent_box.border.get(); let mut padding = parent_box.padding.get(); if i != 0 { border.left = Zero::zero(); padding.left = Zero::zero() } if i != (boxes_len - 1) { border.right = Zero::zero(); padding.right = Zero::zero() } match &mut *info { &Some(ref mut info) => { // TODO(ksh8281): Compute margins. info.parent_info.push(InlineParentInfo { padding: padding, border: border, margin: Zero::zero(), style: parent_box.style.clone(), font_ascent: font_ascent, font_descent: font_descent, node: OpaqueNodeMethods::from_thread_safe_layout_node(parent_node), }) }, &None => {} } } } /// Creates an `InlineBoxesConstructionResult` for replaced content. Replaced content doesn't /// render its children, so this just nukes a child's boxes and creates a `Box`. fn build_boxes_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 opt_box_accumulator = None; opt_box_accumulator.push(Box::new(self, node)); let construction_item = InlineBoxesConstructionItem(InlineBoxesConstructionResult { splits: None, boxes: opt_box_accumulator.to_vec(), abs_descendants: Descendants::new(), }); ConstructionItemConstructionResult(construction_item) } /// Builds one or more boxes for a node with `display: inline`. This yields an /// `InlineBoxesConstructionResult`. fn build_boxes_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' boxes. self.build_boxes_for_nonreplaced_inline_content(node) } else { // Otherwise, just nuke our kids' boxes, create our box if any, and be done with it. self.build_boxes_for_replaced_inline_content(node) } } /// TableCaptionFlow is populated underneath TableWrapperFlow fn place_table_caption_under_table_wrapper(&mut self, table_wrapper_flow: &mut ~Flow, 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.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: ~[~Flow], flow: &mut ~Flow, node: &ThreadSafeLayoutNode) { let mut anonymous_flow = flow.generate_missing_child_flow(node); let mut consecutive_siblings = ~[]; for kid_flow in child_flows.move_iter() { if anonymous_flow.need_anonymous_flow(kid_flow) { consecutive_siblings.push(kid_flow); continue; } if !consecutive_siblings.is_empty() { self.generate_anonymous_missing_child(consecutive_siblings, &mut anonymous_flow, node); consecutive_siblings = ~[]; } 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 box_ = Box::new_from_specific_info(node, TableWrapperBox); let mut wrapper_flow = ~TableWrapperFlow::from_node_and_box(node, box_) as ~Flow; let table_box_ = Box::new_from_specific_info(node, TableBox); let table_flow = ~TableFlow::from_node_and_box(node, table_box_) as ~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.as_block().is_positioned(); let is_fixed_positioned = wrapper_flow.as_block().is_fixed(); let is_absolutely_positioned = wrapper_flow.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(Rawlink::some(wrapper_flow)); } 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(Rawlink::some(wrapper_flow)); } } 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 = ~TableCaptionFlow::from_node(self, node) as ~Flow; self.build_flow_using_children(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 box_ = Box::new_from_specific_info(node, TableRowBox); let flow = ~TableRowGroupFlow::from_node_and_box(node, box_) as ~Flow; self.build_flow_using_children(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 box_ = Box::new_from_specific_info(node, TableRowBox); let flow = ~TableRowFlow::from_node_and_box(node, box_) as ~Flow; self.build_flow_using_children(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 box_ = Box::new_from_specific_info(node, TableCellBox); let flow = ~TableCellFlow::from_node_and_box(node, box_) as ~Flow; self.build_flow_using_children(flow, node) } /// Creates a box for a node with `display: table-column`. fn build_boxes_for_table_column(&mut self, node: &ThreadSafeLayoutNode) -> ConstructionResult { // CSS 2.1 § 17.2.1. Treat all child boxes of a `table-column` as `display: none`. for kid in node.children() { kid.set_flow_construction_result(NoConstructionResult) } let specific = TableColumnBox(TableColumnBoxInfo::new(node)); let construction_item = TableColumnBoxConstructionItem( Box::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 box_ = Box::new_from_specific_info(node, TableColumnBox(TableColumnBoxInfo::new(node))); let mut col_boxes = ~[]; for kid in node.children() { // CSS 2.1 § 17.2.1. Treat all non-column child boxes of `table-column-group` // as `display: none`. match kid.swap_out_construction_result() { ConstructionItemConstructionResult(TableColumnBoxConstructionItem(box_)) => { col_boxes.push(box_); } _ => {} } } if col_boxes.is_empty() { debug!("add TableColumnBox for empty colgroup"); let specific = TableColumnBox(TableColumnBoxInfo::new(node)); col_boxes.push( Box::new_from_specific_info(node, specific) ); } let mut flow = ~TableColGroupFlow::from_node_and_boxes(node, box_, col_boxes) as ~Flow; flow.finish(self.layout_context); FlowConstructionResult(flow, Descendants::new()) } } impl<'a> PostorderNodeMutTraversal for FlowConstructor<'a> { // 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().get(); (display::inline, style.Box.get().float, style.Box.get().position) } Some(ElementNodeTypeId(_)) => { let style = node.style().get(); (style.Box.get().display, style.Box.get().float, style.Box.get().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() { let mut old_result = child.swap_out_construction_result(); old_result.destroy() } } // 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. // Currently, for original `display` value of 'inline', the new // `display` value is 'block'. (_, _, position::absolute) | (_, _, position::fixed) => { node.set_flow_construction_result(self.build_flow_for_block(node)) } // Inline items contribute inline box construction results. (display::inline, float::none, _) => { let construction_result = self.build_boxes_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_boxes_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; /// Returns true if this node is ignorable whitespace. fn is_ignorable_whitespace(&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, } } fn is_ignorable_whitespace(&self) -> bool { match self.type_id() { Some(TextNodeTypeId) => { unsafe { let text: JS = TextCast::to(self.get_jsmanaged()).unwrap(); if !is_whitespace(text.get().characterdata.data) { return false } // NB: See the rules for `white-space` here: // // http://www.w3.org/TR/CSS21/text.html#propdef-white-space // // If you implement other values for this property, you will almost certainly // want to update this check. match self.style().get().InheritedText.get().white_space { white_space::normal => true, _ => false, } } } _ => 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_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_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, base_url: &Url) -> Option; } 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, base_url: &Url) -> Option { match self.get_type_and_data() { (None, Some(uri)) if is_image_data(uri) => Some(parse_url(uri, Some(base_url.clone()))), _ => None } } } /// Strips ignorable whitespace from the start of a list of boxes. fn strip_ignorable_whitespace_from_start(opt_boxes: &mut Option<~[Box]>) { match mem::replace(opt_boxes, None) { None => return, Some(boxes) => { // FIXME(pcwalton): This is slow because vector shift is broken. :( let mut found_nonwhitespace = false; let mut result = ~[]; let mut last_removed_box: Option = None; for box_ in boxes.move_iter() { if !found_nonwhitespace && box_.is_whitespace_only() { debug!("stripping ignorable whitespace from start"); last_removed_box = Some(box_); continue } found_nonwhitespace = true; match last_removed_box { Some(ref last_removed_box) => { box_.merge_noncontent_inline_left(last_removed_box); }, None => {} } last_removed_box = None; result.push(box_) } *opt_boxes = Some(result) } } } /// Strips ignorable whitespace from the end of a list of boxes. fn strip_ignorable_whitespace_from_end(opt_boxes: &mut Option<~[Box]>) { match *opt_boxes { None => {} Some(ref mut boxes) => { while boxes.len() > 0 && boxes.last().get_ref().is_whitespace_only() { debug!("stripping ignorable whitespace from end"); let box_ = boxes.pop().unwrap(); if boxes.len() > 0 { boxes[boxes.len() - 1].merge_noncontent_inline_right(&box_); } } } } if opt_boxes.len() == 0 { *opt_boxes = None } }