diff --git a/src/servo/css/resolve/apply.rs b/src/servo/css/resolve/apply.rs index da2693f7607..5f741b59955 100644 --- a/src/servo/css/resolve/apply.rs +++ b/src/servo/css/resolve/apply.rs @@ -5,7 +5,7 @@ use au = gfx::geometry; use dom::node::{Node, NodeTree}; use dom::element::*; -use layout::base::{RenderBox, SpecifiedStyle, RenderBoxTree}; +use layout::box::{RenderBox, SpecifiedStyle, RenderBoxTree}; use layout::context::LayoutContext; use layout::traverse_parallel::top_down_traversal; use image::ImageHolder; diff --git a/src/servo/dom/node.rs b/src/servo/dom/node.rs index 574c39e2125..2982efbe1c0 100644 --- a/src/servo/dom/node.rs +++ b/src/servo/dom/node.rs @@ -1,10 +1,10 @@ /* The core DOM types. Defines the basic DOM hierarchy as well as all the HTML elements. */ use css::styles::SpecifiedStyle; use css::values::Stylesheet; +use dom::bindings; use dom::document::Document; use dom::element::{Attr, ElementData}; use dom::window::Window; -use dom::bindings; use geom::size::Size2D; use gfx::geometry::au; use js::crust::*; @@ -12,8 +12,8 @@ use js::glue::bindgen::RUST_OBJECT_TO_JSVAL; use js::jsapi::{JSClass, JSObject, JSPropertySpec, JSContext, jsid, jsval, JSBool}; use js::rust::{bare_compartment, compartment, methods}; use js::{JSPROP_ENUMERATE, JSPROP_SHARED}; -use layout::base::FlowContext; use layout::debug::DebugMethods; +use layout::flow::FlowContext; use ptr::null; use std::arc::ARC; use util::tree; diff --git a/src/servo/layout/block.rs b/src/servo/layout/block.rs index 76ea82f1749..d33f6788144 100644 --- a/src/servo/layout/block.rs +++ b/src/servo/layout/block.rs @@ -5,8 +5,9 @@ use geom::point::Point2D; use geom::rect::Rect; use geom::size::Size2D; use gfx::geometry::au; -use layout::base::{RenderBox, FlowContext, FlowTree, InlineBlockFlow, BlockFlow, RootFlow}; +use layout::box::{RenderBox}; use layout::context::LayoutContext; +use layout::flow::{FlowContext, FlowTree, InlineBlockFlow, BlockFlow, RootFlow}; use util::tree; struct BlockFlowData { diff --git a/src/servo/layout/base.rs b/src/servo/layout/box.rs similarity index 64% rename from src/servo/layout/base.rs rename to src/servo/layout/box.rs index aa710d8076b..e41b2c4c5e0 100644 --- a/src/servo/layout/base.rs +++ b/src/servo/layout/box.rs @@ -17,11 +17,9 @@ use geom::rect::Rect; use geom::size::Size2D; use geom::point::Point2D; use image::{Image, ImageHolder}; -use layout::block::BlockFlowData; use layout::context::LayoutContext; use layout::debug::DebugMethods; -use layout::inline::InlineFlowData; -use layout::root::RootFlowData; +use layout::flow::FlowContext; use layout::text::TextBoxData; use servo_text::text_run::TextRun; use std::net::url::Url; @@ -30,12 +28,7 @@ use util::color::Color; use util::tree; use vec::{push, push_all}; - -/** Servo's experimental layout system builds a tree of FlowContexts -and RenderBoxes, and figures out positions and display attributes of -tree nodes. Positions are computed in several tree traversals driven -by fundamental data dependencies of inline and block layout. - +/** Render boxes (`struct RenderBox`) are the leafs of the layout tree. They cannot position themselves. In general, render boxes do not have a simple correspondence with CSS boxes as in the specification: @@ -65,149 +58,8 @@ padding, backgrounds. It is analogous to a CSS nonreplaced content box. node. Split text boxes are implemented by referring to subsets of a master TextRun object. - -Flows (`struct FlowContext`) are interior nodes in the layout tree, -and correspond closely to flow contexts in the CSS -specification. Flows are responsible for positioning their child flow -contexts and render boxes. Flows have purpose-specific fields, such as -auxilliary line box structs, out-of-flow child lists, and so on. - -Currently, the important types of flows are: - - * BlockFlow: a flow that establishes a block context. It has several - child flows, each of which are positioned according to block - formatting context rules (as if child flows CSS block boxes). Block - flows also contain a single GenericBox to represent their rendered - borders, padding, etc. (In the future, this render box may be - folded into BlockFlow to save space.) - - * InlineFlow: a flow that establishes an inline context. It has a - flat list of child boxes/flows that are subject to inline layout - and line breaking, and structs to represent line breaks and mapping - to CSS boxes, for the purpose of handling `getClientRects()`. - */ -struct FlowLayoutData { - // TODO: min/pref and position are used during disjoint phases of - // layout; maybe combine into a single enum to save space. - mut min_width: au, - mut pref_width: au, - mut position: Rect, -} - -fn FlowLayoutData() -> FlowLayoutData { - FlowLayoutData { - min_width: au(0), - pref_width: au(0), - position : au::zero_rect(), - } -} - -/* The type of the formatting context, and data specific to each -context, such as linebox structures or float lists */ -enum FlowContextData { - AbsoluteFlow, - BlockFlow(BlockFlowData), - FloatFlow, - InlineBlockFlow, - InlineFlow(InlineFlowData), - RootFlow(RootFlowData), - TableFlow -} - -/* A particular kind of layout context. It manages the positioning of - render boxes within the context. */ -struct FlowContext { - kind: FlowContextData, - data: FlowLayoutData, - mut node: Option, - /* reference to parent, children flow contexts */ - tree: tree::Tree<@FlowContext>, - /* TODO: debug only */ - mut id: int -} - -fn FlowContext(id: int, kind: FlowContextData, tree: tree::Tree<@FlowContext>) -> FlowContext { - FlowContext { - kind: kind, - data: FlowLayoutData(), - node: None, - tree: tree, - id: id - } -} - -impl @FlowContext : cmp::Eq { - pure fn eq(other: &@FlowContext) -> bool { box::ptr_eq(self, *other) } - pure fn ne(other: &@FlowContext) -> bool { !box::ptr_eq(self, *other) } -} - - -/* Flow context disambiguation methods: the verbose alternative to virtual methods */ -impl @FlowContext { - fn bubble_widths(ctx: &LayoutContext) { - match self.kind { - BlockFlow(*) => self.bubble_widths_block(ctx), - InlineFlow(*) => self.bubble_widths_inline(ctx), - RootFlow(*) => self.bubble_widths_root(ctx), - _ => fail fmt!("Tried to bubble_widths of flow: %?", self.kind) - } - } - - fn assign_widths(ctx: &LayoutContext) { - match self.kind { - BlockFlow(*) => self.assign_widths_block(ctx), - InlineFlow(*) => self.assign_widths_inline(ctx), - RootFlow(*) => self.assign_widths_root(ctx), - _ => fail fmt!("Tried to assign_widths of flow: %?", self.kind) - } - } - - fn assign_height(ctx: &LayoutContext) { - match self.kind { - BlockFlow(*) => self.assign_height_block(ctx), - InlineFlow(*) => self.assign_height_inline(ctx), - RootFlow(*) => self.assign_height_root(ctx), - _ => fail fmt!("Tried to assign_height of flow: %?", self.kind) - } - } - - fn build_display_list_recurse(builder: &dl::DisplayListBuilder, dirty: &Rect, - offset: &Point2D, list: &dl::DisplayList) { - match self.kind { - RootFlow(*) => self.build_display_list_root(builder, dirty, offset, list), - BlockFlow(*) => self.build_display_list_block(builder, dirty, offset, list), - InlineFlow(*) => self.build_display_list_inline(builder, dirty, offset, list), - _ => fail fmt!("Tried to build_display_list_recurse of flow: %?", self.kind) - } - } -} - -/* The tree holding FlowContexts */ -enum FlowTree { FlowTree } - -impl FlowTree : tree::ReadMethods<@FlowContext> { - fn each_child(ctx: @FlowContext, f: fn(&&@FlowContext) -> bool) { - tree::each_child(self, ctx, f) - } - - fn with_tree_fields(&&b: @FlowContext, f: fn(tree::Tree<@FlowContext>) -> R) -> R { - f(b.tree) - } -} - -impl FlowTree : tree::WriteMethods<@FlowContext> { - fn add_child(parent: @FlowContext, child: @FlowContext) { - assert !box::ptr_eq(parent, child); - tree::add_child(self, parent, child) - } - - fn with_tree_fields(&&b: @FlowContext, f: fn(tree::Tree<@FlowContext>) -> R) -> R { - f(b.tree) - } -} - /* A box's kind influences how its styles are interpreted during layout. For example, replaced content such as images are resized @@ -418,10 +270,11 @@ impl @RenderBox { } } -// FIXME: Why do these have to be redefined for each node type? - -/* The tree holding render box relations. (This should only be used -for painting nested inlines, AFAIK-- everything else depends on Flow tree) */ +/** + * The tree holding render box relations. These are only defined for + * nested CSS boxes that are nested in an otherwise inline flow + * context. +*/ enum RenderBoxTree { RenderBoxTree } impl RenderBoxTree : tree::ReadMethods<@RenderBox> { @@ -436,7 +289,7 @@ impl RenderBoxTree : tree::ReadMethods<@RenderBox> { impl RenderBoxTree : tree::WriteMethods<@RenderBox> { fn add_child(parent: @RenderBox, child: @RenderBox) { - assert !box::ptr_eq(parent, child); + assert !core::box::ptr_eq(parent, child); tree::add_child(self, parent, child) } @@ -445,50 +298,6 @@ impl RenderBoxTree : tree::WriteMethods<@RenderBox> { } } -// Debugging - -impl @FlowContext : DebugMethods { - fn dump() { - self.dump_indent(0u); - } - - /** Dumps the flow tree, for debugging, with indentation. */ - fn dump_indent(indent: uint) { - let mut s = ~"|"; - for uint::range(0u, indent) |_i| { - s += ~"---- "; - } - - s += self.debug_str(); - debug!("%s", s); - - for FlowTree.each_child(self) |child| { - child.dump_indent(indent + 1u) - } - } - - /* TODO: we need a string builder. This is horribly inefficient */ - fn debug_str() -> ~str { - let repr = match self.kind { - InlineFlow(d) => { - let mut s = d.boxes.foldl(~"InlineFlow(children=", |s, box| { - fmt!("%s %?", s, box.id) - }); - s += ~")"; s - }, - BlockFlow(d) => { - match d.box { - Some(_b) => fmt!("BlockFlow(box=b%?)", d.box.get().id), - None => ~"BlockFlow", - } - }, - _ => fmt!("%?", self.kind) - }; - - fmt!("c%? %?", self.id, repr) - } -} - impl @RenderBox : DebugMethods { fn dump() { self.dump_indent(0u); diff --git a/src/servo/layout/box_builder.rs b/src/servo/layout/box_builder.rs index 5da7c290618..95203268dc9 100644 --- a/src/servo/layout/box_builder.rs +++ b/src/servo/layout/box_builder.rs @@ -7,17 +7,17 @@ use css::values::{Inherit, Initial, Specified}; use dom::element::*; use dom::node::{Comment, Doctype, Element, Text, Node, NodeTree, LayoutData}; use image::holder::ImageHolder; -use layout::base::{RenderBox, BoxData, GenericBox, ImageBox, TextBox, RenderBoxTree}; -use layout::base::{FlowContext, FlowContextData, BlockFlow, InlineFlow, InlineBlockFlow, RootFlow, FlowTree}; +use layout::flow::{FlowContext, FlowContextData, BlockFlow, InlineFlow, InlineBlockFlow, RootFlow, FlowTree}; +use layout::box::{RenderBox, BoxData, GenericBox, ImageBox, TextBox, RenderBoxTree}; use layout::block::BlockFlowData; use layout::context::LayoutContext; use layout::inline::InlineFlowData; use layout::root::RootFlowData; use layout::text::TextBoxData; use option::is_none; -use util::tree; -use servo_text::text_run::TextRun; use servo_text::font_cache::FontCache; +use servo_text::text_run::TextRun; +use util::tree; export LayoutTreeBuilder; diff --git a/src/servo/layout/display_list_builder.rs b/src/servo/layout/display_list_builder.rs index 3e242dd1348..c0bd78a242c 100644 --- a/src/servo/layout/display_list_builder.rs +++ b/src/servo/layout/display_list_builder.rs @@ -1,7 +1,7 @@ export DisplayListBuilder; use au = gfx::geometry; -use base::{RenderBox, RenderBoxTree}; +use au::au; use css::values::{BgColor, BgColorTransparent, Specified}; use dl = gfx::display_list; use dom::node::{Text, NodeScope}; @@ -11,9 +11,10 @@ use either::{Left, Right}; use geom::point::Point2D; use geom::rect::Rect; use geom::size::Size2D; -use gfx::geometry::au; +use layout::box::{RenderBox, RenderBoxTree, TextBox}; +use layout::context::LayoutContext; +use layout::flow::FlowContext; use layout::text::TextBoxData; -use layout::base::{LayoutContext, FlowContext, TextBox}; use servo_text::text_run::TextRun; use util::tree; use vec::push; diff --git a/src/servo/layout/flow.rs b/src/servo/layout/flow.rs new file mode 100644 index 00000000000..4d6adab607a --- /dev/null +++ b/src/servo/layout/flow.rs @@ -0,0 +1,206 @@ +use au = gfx::geometry; +use au::au; +use dl = gfx::display_list; +use dom::node::Node; +use geom::rect::Rect; +use geom::point::Point2D; +// TODO: pub-use these +use layout::block::BlockFlowData; +use layout::context::LayoutContext; +use layout::debug::DebugMethods; +use layout::inline::InlineFlowData; +use layout::root::RootFlowData; +use util::tree; + +/** Servo's experimental layout system builds a tree of FlowContexts +and RenderBoxes, and figures out positions and display attributes of +tree nodes. Positions are computed in several tree traversals driven +by fundamental data dependencies of inline and block layout. + +Flows are interior nodes in the layout tree, and correspond closely to +flow contexts in the CSS specification. Flows are responsible for +positioning their child flow contexts and render boxes. Flows have +purpose-specific fields, such as auxilliary line box structs, +out-of-flow child lists, and so on. + +Currently, the important types of flows are: + + * BlockFlow: a flow that establishes a block context. It has several + child flows, each of which are positioned according to block + formatting context rules (as if child flows CSS block boxes). Block + flows also contain a single GenericBox to represent their rendered + borders, padding, etc. (In the future, this render box may be + folded into BlockFlow to save space.) + + * InlineFlow: a flow that establishes an inline context. It has a + flat list of child boxes/flows that are subject to inline layout + and line breaking, and structs to represent line breaks and mapping + to CSS boxes, for the purpose of handling `getClientRects()`. + +*/ + + +struct FlowLayoutData { + // TODO: min/pref and position are used during disjoint phases of + // layout; maybe combine into a single enum to save space. + mut min_width: au, + mut pref_width: au, + mut position: Rect, +} + +fn FlowLayoutData() -> FlowLayoutData { + FlowLayoutData { + min_width: au(0), + pref_width: au(0), + position : au::zero_rect(), + } +} + +/* The type of the formatting context, and data specific to each +context, such as linebox structures or float lists */ +enum FlowContextData { + AbsoluteFlow, + BlockFlow(BlockFlowData), + FloatFlow, + InlineBlockFlow, + InlineFlow(InlineFlowData), + RootFlow(RootFlowData), + TableFlow +} + +/* A particular kind of layout context. It manages the positioning of + render boxes within the context. */ +struct FlowContext { + kind: FlowContextData, + data: FlowLayoutData, + mut node: Option, + /* reference to parent, children flow contexts */ + tree: tree::Tree<@FlowContext>, + /* TODO: debug only */ + mut id: int +} + + +fn FlowContext(id: int, kind: FlowContextData, tree: tree::Tree<@FlowContext>) -> FlowContext { + FlowContext { + kind: kind, + data: FlowLayoutData(), + node: None, + tree: tree, + id: id + } +} + +impl @FlowContext : cmp::Eq { + pure fn eq(other: &@FlowContext) -> bool { core::box::ptr_eq(self, *other) } + pure fn ne(other: &@FlowContext) -> bool { !core::box::ptr_eq(self, *other) } +} + + +/* Flow context disambiguation methods: the verbose alternative to virtual methods */ +impl @FlowContext { + fn bubble_widths(ctx: &LayoutContext) { + match self.kind { + BlockFlow(*) => self.bubble_widths_block(ctx), + InlineFlow(*) => self.bubble_widths_inline(ctx), + RootFlow(*) => self.bubble_widths_root(ctx), + _ => fail fmt!("Tried to bubble_widths of flow: %?", self.kind) + } + } + + fn assign_widths(ctx: &LayoutContext) { + match self.kind { + BlockFlow(*) => self.assign_widths_block(ctx), + InlineFlow(*) => self.assign_widths_inline(ctx), + RootFlow(*) => self.assign_widths_root(ctx), + _ => fail fmt!("Tried to assign_widths of flow: %?", self.kind) + } + } + + fn assign_height(ctx: &LayoutContext) { + match self.kind { + BlockFlow(*) => self.assign_height_block(ctx), + InlineFlow(*) => self.assign_height_inline(ctx), + RootFlow(*) => self.assign_height_root(ctx), + _ => fail fmt!("Tried to assign_height of flow: %?", self.kind) + } + } + + fn build_display_list_recurse(builder: &dl::DisplayListBuilder, dirty: &Rect, + offset: &Point2D, list: &dl::DisplayList) { + match self.kind { + RootFlow(*) => self.build_display_list_root(builder, dirty, offset, list), + BlockFlow(*) => self.build_display_list_block(builder, dirty, offset, list), + InlineFlow(*) => self.build_display_list_inline(builder, dirty, offset, list), + _ => fail fmt!("Tried to build_display_list_recurse of flow: %?", self.kind) + } + } +} + + +/* The tree holding FlowContexts */ +enum FlowTree { FlowTree } + +impl FlowTree : tree::ReadMethods<@FlowContext> { + fn each_child(ctx: @FlowContext, f: fn(&&@FlowContext) -> bool) { + tree::each_child(self, ctx, f) + } + + fn with_tree_fields(&&b: @FlowContext, f: fn(tree::Tree<@FlowContext>) -> R) -> R { + f(b.tree) + } +} + +impl FlowTree : tree::WriteMethods<@FlowContext> { + fn add_child(parent: @FlowContext, child: @FlowContext) { + assert !core::box::ptr_eq(parent, child); + tree::add_child(self, parent, child) + } + + fn with_tree_fields(&&b: @FlowContext, f: fn(tree::Tree<@FlowContext>) -> R) -> R { + f(b.tree) + } +} + + +impl @FlowContext : DebugMethods { + fn dump() { + self.dump_indent(0u); + } + + /** Dumps the flow tree, for debugging, with indentation. */ + fn dump_indent(indent: uint) { + let mut s = ~"|"; + for uint::range(0u, indent) |_i| { + s += ~"---- "; + } + + s += self.debug_str(); + debug!("%s", s); + + for FlowTree.each_child(self) |child| { + child.dump_indent(indent + 1u) + } + } + + /* TODO: we need a string builder. This is horribly inefficient */ + fn debug_str() -> ~str { + let repr = match self.kind { + InlineFlow(d) => { + let mut s = d.boxes.foldl(~"InlineFlow(children=", |s, box| { + fmt!("%s %?", s, box.id) + }); + s += ~")"; s + }, + BlockFlow(d) => { + match d.box { + Some(_b) => fmt!("BlockFlow(box=b%?)", d.box.get().id), + None => ~"BlockFlow", + } + }, + _ => fmt!("%?", self.kind) + }; + + fmt!("c%? %?", self.id, repr) + } +} diff --git a/src/servo/layout/inline.rs b/src/servo/layout/inline.rs index e184384824c..896e420fd8f 100644 --- a/src/servo/layout/inline.rs +++ b/src/servo/layout/inline.rs @@ -1,5 +1,4 @@ use au = gfx::geometry; -use base::RenderBox; use core::dvec::DVec; use css::values::{BoxAuto, BoxLength, Px}; use dl = gfx::display_list; @@ -8,8 +7,9 @@ use geom::point::Point2D; use geom::rect::Rect; use geom::size::Size2D; use gfx::geometry::au; +use layout::box::{RenderBox, RenderBoxTree, ImageBox, TextBox, GenericBox}; +use layout::flow::{FlowContext, InlineFlow}; use layout::context::LayoutContext; -use layout::base::{FlowContext, InlineFlow, RenderBoxTree, ImageBox, TextBox, GenericBox}; use num::Num; use util::tree; diff --git a/src/servo/layout/layout_task.rs b/src/servo/layout/layout_task.rs index 06c6ad79e77..ca28b784548 100644 --- a/src/servo/layout/layout_task.rs +++ b/src/servo/layout/layout_task.rs @@ -1,7 +1,7 @@ -#[doc = " +/** The layout task. Performs layout on the DOM, builds display lists and sends them to be rendered. -"]; +*/ use au = gfx::geometry; use au::au; @@ -10,20 +10,20 @@ use core::dvec::DVec; use css::resolve::apply::apply_style; use css::values::Stylesheet; use dl = gfx::display_list; -use dom::node::{Node, LayoutData}; use dom::event::{Event, ReflowEvent}; +use dom::node::{Node, LayoutData}; use geom::point::Point2D; use geom::rect::Rect; use geom::size::Size2D; use gfx::render_task; -use layout::base::RenderBox; +use layout::box::RenderBox; use layout::box_builder::LayoutTreeBuilder; use layout::context::LayoutContext; use render_task::RenderTask; use resource::image_cache_task::ImageCacheTask; +use servo_text::font_cache::FontCache; use std::arc::ARC; use std::net::url::Url; -use servo_text::font_cache::FontCache; use layout::traverse::*; use comm::*; diff --git a/src/servo/layout/root.rs b/src/servo/layout/root.rs index e3a0ca35cfc..b47cd7041d9 100644 --- a/src/servo/layout/root.rs +++ b/src/servo/layout/root.rs @@ -4,8 +4,9 @@ use dl = gfx::display_list; use geom::point::Point2D; use geom::rect::Rect; use gfx::geometry::au; -use layout::base::{RenderBox, FlowContext, FlowTree, InlineBlockFlow, BlockFlow, RootFlow}; +use layout::box::RenderBox; use layout::context::LayoutContext; +use layout::flow::{FlowContext, FlowTree, InlineBlockFlow, BlockFlow, RootFlow}; use util::tree; struct RootFlowData { diff --git a/src/servo/layout/text.rs b/src/servo/layout/text.rs index ca39b48836c..c15b9382b59 100644 --- a/src/servo/layout/text.rs +++ b/src/servo/layout/text.rs @@ -5,7 +5,7 @@ use geom::size::Size2D; use gfx::geometry::au; use servo_text::text_run::TextRun; use servo_text::font_cache::FontCache; -use layout::base::{TextBox, RenderBox}; +use layout::box::{TextBox, RenderBox}; use layout::context::LayoutContext; struct TextBoxData { diff --git a/src/servo/layout/traverse.rs b/src/servo/layout/traverse.rs index a92564c4944..45763cfa8f9 100644 --- a/src/servo/layout/traverse.rs +++ b/src/servo/layout/traverse.rs @@ -1,7 +1,7 @@ /** Interface for running tree-based traversals over layout boxes and contextsg */ -use layout::base::{RenderBox, RenderBoxTree}; -use layout::base::{FlowContext, FlowTree}; +use layout::box::{RenderBox, RenderBoxTree}; +use layout::flow::{FlowContext, FlowTree}; /* TODO: we shouldn't need render box traversals */ trait RenderBoxTraversals { diff --git a/src/servo/layout/traverse_parallel.rs b/src/servo/layout/traverse_parallel.rs index bde84aa05b8..faad6a04b43 100644 --- a/src/servo/layout/traverse_parallel.rs +++ b/src/servo/layout/traverse_parallel.rs @@ -1,6 +1,5 @@ - -#[doc = "Interface for running tree-based traversals over layout boxes"] -use base::{RenderBox, RenderBoxTree}; +/* Interface for running tree-based traversals over layout boxes */ +use layout::box::{RenderBox, RenderBoxTree}; use intrinsic::TyDesc; export full_traversal; @@ -21,19 +20,23 @@ type shared_box = { payload : T }; -#[doc="Transform and @ into its underlying representation. The reference count stays constant."] +/** +Transform and @ into its underlying representation. The reference count stays constant. +*/ fn unwrap_box(-b : @RenderBox) -> *shared_box unsafe { let new_box : *shared_box = cast::transmute(b); return new_box; } -#[doc="Transform an underlying representation back to an @. The reference count stays constant."] +/** +Transform an underlying representation back to an @. The reference count stays constant. +*/ fn rewrap_box(-b : *shared_box) -> @RenderBox unsafe { let new_box : @RenderBox = cast::transmute(b); return new_box; } -#[doc=" +/** Iterate down and then up a tree of layout boxes in parallel and apply the given functions to each box. Each box applies the first function, @@ -52,7 +55,7 @@ finish, and then applies the second function to the current box. * `bottom_up` - A function that is applied to each node after it is applied to that node's children -"] +*/ fn traverse_helper(-root : @RenderBox, returned : T, -top_down : fn~(+T, @RenderBox) -> T, -bottom_up : fn~(@RenderBox)) { let returned = top_down(returned, root); @@ -96,61 +99,63 @@ fn traverse_helper(-root : @RenderBox, returned : T, -top_down : bottom_up(root); } -#[doc="A noneffectful function to be used if only one pass is required."] +/** +A noneffectful function to be used if only one pass is required. +*/ fn nop(_box : @RenderBox) { return; } -#[doc= " +/** A wrapper to change a function that only acts on a box to one that threasds a unit through to match travserse_helper -"] +*/ fn unit_wrapper(-fun : fn~(@RenderBox)) -> fn~(+(), @RenderBox) { fn~(+_u : (), box : @RenderBox) { fun(box); } } -#[doc=" +/** Iterate in parallel over the boxes in a tree, applying one function to a parent before recursing on its children and one after. -"] +*/ fn full_traversal(+root : @RenderBox, -top_down : fn~(@RenderBox), -bottom_up : fn~(@RenderBox)) { traverse_helper(root, (), unit_wrapper(top_down), bottom_up); } -#[doc=" +/** Iterate in parallel over the boxes in a tree, applying the given function to a parent before its children. -"] +*/ fn top_down_traversal(+root : @RenderBox, -top_down : fn~(@RenderBox)) { traverse_helper(root, (), unit_wrapper(top_down), nop); } -#[doc=" +/** Iterate in parallel over the boxes in a tree, applying the given function to a parent after its children. -"] +*/ fn bottom_up_traversal(+root : @RenderBox, -bottom_up : fn~(@RenderBox)) { traverse_helper(root, (), unit_wrapper(nop), bottom_up); } -#[doc=" +/** Iterate in parallel over the boxes in a tree, applying the given function to a parent before its children, the value returned by the function is passed to each child when they are recursed upon. As the recursion unwinds, the second function is applied to first the children in parallel, and then the parent. -"] +*/ fn extended_full_traversal(+root : @RenderBox, first_val : T, -top_down : fn~(+T, @RenderBox) -> T, -bottom_up : fn~(@RenderBox)) { traverse_helper(root, first_val, top_down, bottom_up); } -#[doc=" +/** Iterate in parallel over the boxes in a tree, applying the given function to a parent before its children, the value returned by the function is passed to each child when they are recursed upon. -"] +*/ fn extended_top_down_traversal(+root : @RenderBox, first_val : T, -top_down : fn~(+T, @RenderBox) -> T) { traverse_helper(root, first_val, top_down, nop); diff --git a/src/servo/servo.rc b/src/servo/servo.rc index 88040e64f5e..7eb861d4284 100755 --- a/src/servo/servo.rc +++ b/src/servo/servo.rc @@ -58,14 +58,15 @@ mod css { } mod layout { - mod base; mod block; + mod box; mod box_builder; mod context; mod debug; mod display_list_builder; - mod inline; + mod flow; mod layout_task; + mod inline; mod root; mod text; mod traverse;