script: Eliminate the phantom type in favor of just whitelisting methods

that layout can safely call.

This is simpler. Currently, the set of methods is not safe, but I plan
to lock it down more soon.
This commit is contained in:
Patrick Walton 2013-12-16 20:29:20 -08:00
parent da4cff034b
commit be69a503fe
96 changed files with 646 additions and 522 deletions

View file

@ -15,20 +15,20 @@ use css::node_style::StyledNode;
use layout::incremental; use layout::incremental;
use layout::util::LayoutDataAccess; use layout::util::LayoutDataAccess;
use script::dom::node::{AbstractNode, LayoutView}; use script::dom::node::LayoutNode;
use style::{TNode, Stylist, cascade}; use style::{TNode, Stylist, cascade};
pub trait MatchMethods { pub trait MatchMethods {
fn match_node(&self, stylist: &Stylist); fn match_node(&self, stylist: &Stylist);
fn match_subtree(&self, stylist: RWArc<Stylist>); fn match_subtree(&self, stylist: RWArc<Stylist>);
fn cascade_node(&self, parent: Option<AbstractNode<LayoutView>>); fn cascade_node(&self, parent: Option<LayoutNode>);
fn cascade_subtree(&self, parent: Option<AbstractNode<LayoutView>>); fn cascade_subtree(&self, parent: Option<LayoutNode>);
} }
impl MatchMethods for AbstractNode<LayoutView> { impl MatchMethods for LayoutNode {
fn match_node(&self, stylist: &Stylist) { fn match_node(&self, stylist: &Stylist) {
let applicable_declarations = do self.with_imm_element |element| { let applicable_declarations = do self.with_element |element| {
let style_attribute = match element.style_attribute { let style_attribute = match element.style_attribute {
None => None, None => None,
Some(ref style_attribute) => Some(style_attribute) Some(ref style_attribute) => Some(style_attribute)
@ -80,7 +80,7 @@ impl MatchMethods for AbstractNode<LayoutView> {
} }
} }
fn cascade_node(&self, parent: Option<AbstractNode<LayoutView>>) { fn cascade_node(&self, parent: Option<LayoutNode>) {
let parent_style = match parent { let parent_style = match parent {
Some(ref parent) => Some(parent.style()), Some(ref parent) => Some(parent.style()),
None => None None => None
@ -111,7 +111,7 @@ impl MatchMethods for AbstractNode<LayoutView> {
} }
} }
fn cascade_subtree(&self, parent: Option<AbstractNode<LayoutView>>) { fn cascade_subtree(&self, parent: Option<LayoutNode>) {
self.cascade_node(parent); self.cascade_node(parent);
for kid in self.children() { for kid in self.children() {

View file

@ -9,7 +9,7 @@ use layout::incremental::RestyleDamage;
use extra::arc::Arc; use extra::arc::Arc;
use style::ComputedValues; use style::ComputedValues;
use script::dom::node::{AbstractNode, LayoutView}; use script::dom::node::LayoutNode;
/// Node mixin providing `style` method that returns a `NodeStyle` /// Node mixin providing `style` method that returns a `NodeStyle`
pub trait StyledNode { pub trait StyledNode {
@ -17,7 +17,7 @@ pub trait StyledNode {
fn restyle_damage(&self) -> RestyleDamage; fn restyle_damage(&self) -> RestyleDamage;
} }
impl StyledNode for AbstractNode<LayoutView> { impl StyledNode for LayoutNode {
#[inline] #[inline]
fn style<'a>(&'a self) -> &'a Arc<ComputedValues> { fn style<'a>(&'a self) -> &'a Arc<ComputedValues> {
self.get_css_select_results() self.get_css_select_results()

View file

@ -8,7 +8,7 @@ use layout::util::LayoutDataAccess;
use extra::arc::Arc; use extra::arc::Arc;
use std::cast; use std::cast;
use style::{ComputedValues, TNode}; use style::{ComputedValues, TNode};
use script::dom::node::{AbstractNode, LayoutView}; use script::dom::node::LayoutNode;
pub trait NodeUtil { pub trait NodeUtil {
fn get_css_select_results<'a>(&'a self) -> &'a Arc<ComputedValues>; fn get_css_select_results<'a>(&'a self) -> &'a Arc<ComputedValues>;
@ -18,7 +18,7 @@ pub trait NodeUtil {
fn set_restyle_damage(self, damage: RestyleDamage); fn set_restyle_damage(self, damage: RestyleDamage);
} }
impl NodeUtil for AbstractNode<LayoutView> { impl NodeUtil for LayoutNode {
/** /**
* Provides the computed style for the given node. If CSS selector * Provides the computed style for the given node. If CSS selector
* Returns the style results for the given node. If CSS selector * Returns the style results for the given node. If CSS selector

View file

@ -15,7 +15,7 @@ use gfx::display_list::{TextDisplayItemClass, TextDisplayItemFlags, ClipDisplayI
use gfx::display_list::{ClipDisplayItemClass}; use gfx::display_list::{ClipDisplayItemClass};
use gfx::font::{FontStyle, FontWeight300}; use gfx::font::{FontStyle, FontWeight300};
use gfx::text::text_run::TextRun; use gfx::text::text_run::TextRun;
use script::dom::node::{AbstractNode, LayoutView}; use script::dom::node::LayoutNode;
use servo_msg::constellation_msg::{FrameRectMsg, PipelineId, SubpageId}; use servo_msg::constellation_msg::{FrameRectMsg, PipelineId, SubpageId};
use servo_net::image::holder::ImageHolder; use servo_net::image::holder::ImageHolder;
use servo_net::local_image_cache::LocalImageCache; use servo_net::local_image_cache::LocalImageCache;
@ -116,12 +116,10 @@ impl ImageBoxInfo {
/// ///
/// FIXME(pcwalton): The fact that image boxes store the cache in the box makes little sense to /// FIXME(pcwalton): The fact that image boxes store the cache in the box makes little sense to
/// me. /// me.
pub fn new(node: &AbstractNode<LayoutView>, pub fn new(node: &LayoutNode, image_url: Url, local_image_cache: MutexArc<LocalImageCache>)
image_url: Url,
local_image_cache: MutexArc<LocalImageCache>)
-> ImageBoxInfo { -> ImageBoxInfo {
fn convert_length(node: &AbstractNode<LayoutView>, name: &str) -> Option<Au> { fn convert_length(node: &LayoutNode, name: &str) -> Option<Au> {
node.with_imm_element(|element| { node.with_element(|element| {
element.get_attr(None, name).and_then(|string| { element.get_attr(None, name).and_then(|string| {
let n: Option<int> = FromStr::from_str(string); let n: Option<int> = FromStr::from_str(string);
n n
@ -165,8 +163,8 @@ pub struct IframeBoxInfo {
impl IframeBoxInfo { impl IframeBoxInfo {
/// Creates the information specific to an iframe box. /// Creates the information specific to an iframe box.
pub fn new(node: &AbstractNode<LayoutView>) -> IframeBoxInfo { pub fn new(node: &LayoutNode) -> IframeBoxInfo {
node.with_imm_iframe_element(|iframe_element| { node.with_iframe_element(|iframe_element| {
let size = iframe_element.size.unwrap(); let size = iframe_element.size.unwrap();
IframeBoxInfo { IframeBoxInfo {
pipeline_id: size.pipeline_id, pipeline_id: size.pipeline_id,
@ -209,8 +207,8 @@ pub struct UnscannedTextBoxInfo {
impl UnscannedTextBoxInfo { impl UnscannedTextBoxInfo {
/// Creates a new instance of `UnscannedTextBoxInfo` from the given DOM node. /// Creates a new instance of `UnscannedTextBoxInfo` from the given DOM node.
pub fn new(node: &AbstractNode<LayoutView>) -> UnscannedTextBoxInfo { pub fn new(node: &LayoutNode) -> UnscannedTextBoxInfo {
node.with_imm_text(|text_node| { node.with_text(|text_node| {
// FIXME(pcwalton): Don't copy text; atomically reference count it instead. // FIXME(pcwalton): Don't copy text; atomically reference count it instead.
UnscannedTextBoxInfo { UnscannedTextBoxInfo {
text: text_node.element.data.to_str(), text: text_node.element.data.to_str(),
@ -230,7 +228,7 @@ pub enum SplitBoxResult {
impl Box { impl Box {
/// Constructs a new `Box` instance. /// Constructs a new `Box` instance.
pub fn new(node: AbstractNode<LayoutView>, specific: SpecificBoxInfo) -> Box { pub fn new(node: LayoutNode, specific: SpecificBoxInfo) -> Box {
// Find the nearest ancestor element and take its style. (It should be either that node or // Find the nearest ancestor element and take its style. (It should be either that node or
// its immediate parent.) // its immediate parent.)
// //
@ -250,7 +248,7 @@ impl Box {
} }
Box { Box {
node: OpaqueNode::from_node(&node), node: OpaqueNode::from_layout_node(&node),
style: (*nearest_ancestor_element.style()).clone(), style: (*nearest_ancestor_element.style()).clone(),
position: Slot::init(Au::zero_rect()), position: Slot::init(Au::zero_rect()),
border: Slot::init(Zero::zero()), border: Slot::init(Zero::zero()),

View file

@ -32,9 +32,9 @@ use layout::text::TextRunScanner;
use layout::util::LayoutDataAccess; use layout::util::LayoutDataAccess;
use script::dom::element::{HTMLIframeElementTypeId, HTMLImageElementTypeId}; use script::dom::element::{HTMLIframeElementTypeId, HTMLImageElementTypeId};
use script::dom::node::{AbstractNode, CommentNodeTypeId, DoctypeNodeTypeId}; use script::dom::node::{CommentNodeTypeId, DoctypeNodeTypeId, DocumentFragmentNodeTypeId};
use script::dom::node::{DocumentFragmentNodeTypeId, DocumentNodeTypeId, ElementNodeTypeId}; use script::dom::node::{DocumentNodeTypeId, ElementNodeTypeId, LayoutNode};
use script::dom::node::{LayoutView, PostorderNodeMutTraversal, TextNodeTypeId}; use script::dom::node::{PostorderNodeMutTraversal, TextNodeTypeId};
use servo_util::slot::Slot; use servo_util::slot::Slot;
use std::util; use std::util;
use style::computed_values::{display, float}; use style::computed_values::{display, float};
@ -198,9 +198,9 @@ impl<'self> FlowConstructor<'self> {
} }
/// Builds the `ImageBoxInfo` for the given image. This is out of line to guide inlining. /// Builds the `ImageBoxInfo` for the given image. This is out of line to guide inlining.
fn build_box_info_for_image(&mut self, node: AbstractNode<LayoutView>) -> Option<ImageBoxInfo> { fn build_box_info_for_image(&mut self, node: LayoutNode) -> Option<ImageBoxInfo> {
// FIXME(pcwalton): Don't copy URLs. // FIXME(pcwalton): Don't copy URLs.
let url = node.with_imm_image_element(|image_element| { let url = node.with_image_element(|image_element| {
image_element.image.as_ref().map(|url| (*url).clone()) image_element.image.as_ref().map(|url| (*url).clone())
}); });
@ -215,7 +215,7 @@ impl<'self> FlowConstructor<'self> {
} }
/// Builds a `Box` for the given node. /// Builds a `Box` for the given node.
fn build_box_for_node(&mut self, node: AbstractNode<LayoutView>) -> Box { fn build_box_for_node(&mut self, node: LayoutNode) -> Box {
let specific = match node.type_id() { let specific = match node.type_id() {
ElementNodeTypeId(HTMLImageElementTypeId) => { ElementNodeTypeId(HTMLImageElementTypeId) => {
match self.build_box_info_for_image(node) { match self.build_box_info_for_image(node) {
@ -235,10 +235,7 @@ impl<'self> FlowConstructor<'self> {
/// `#[inline(always)]` because this is performance critical and LLVM will not inline it /// `#[inline(always)]` because this is performance critical and LLVM will not inline it
/// otherwise. /// otherwise.
#[inline(always)] #[inline(always)]
fn flush_inline_boxes_to_flow(&mut self, fn flush_inline_boxes_to_flow(&mut self, boxes: ~[Box], flow: &mut ~Flow:, node: LayoutNode) {
boxes: ~[Box],
flow: &mut ~Flow:,
node: AbstractNode<LayoutView>) {
if boxes.len() > 0 { if boxes.len() > 0 {
let inline_base = FlowData::new(self.next_flow_id(), node); let inline_base = FlowData::new(self.next_flow_id(), node);
let mut inline_flow = ~InlineFlow::from_boxes(inline_base, boxes) as ~Flow:; let mut inline_flow = ~InlineFlow::from_boxes(inline_base, boxes) as ~Flow:;
@ -252,7 +249,7 @@ impl<'self> FlowConstructor<'self> {
fn flush_inline_boxes_to_flow_if_necessary(&mut self, fn flush_inline_boxes_to_flow_if_necessary(&mut self,
opt_boxes: &mut Option<~[Box]>, opt_boxes: &mut Option<~[Box]>,
flow: &mut ~Flow:, flow: &mut ~Flow:,
node: AbstractNode<LayoutView>) { node: LayoutNode) {
let opt_boxes = util::replace(opt_boxes, None); let opt_boxes = util::replace(opt_boxes, None);
if opt_boxes.len() > 0 { if opt_boxes.len() > 0 {
self.flush_inline_boxes_to_flow(opt_boxes.to_vec(), flow, node) self.flush_inline_boxes_to_flow(opt_boxes.to_vec(), flow, node)
@ -264,7 +261,7 @@ impl<'self> FlowConstructor<'self> {
/// whether {ib} splits needed to happen. /// whether {ib} splits needed to happen.
fn build_children_of_block_flow(&mut self, fn build_children_of_block_flow(&mut self,
flow: &mut ~Flow:, flow: &mut ~Flow:,
node: AbstractNode<LayoutView>) { node: LayoutNode) {
// Gather up boxes for the inline flows we might need to create. // Gather up boxes for the inline flows we might need to create.
let mut opt_boxes_for_inline_flow = None; let mut opt_boxes_for_inline_flow = None;
let mut first_box = true; let mut first_box = true;
@ -349,7 +346,7 @@ impl<'self> FlowConstructor<'self> {
/// Builds a flow for a node with `display: block`. This yields a `BlockFlow` with possibly /// 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 /// other `BlockFlow`s or `InlineFlow`s underneath it, depending on whether {ib} splits needed
/// to happen. /// to happen.
fn build_flow_for_block(&mut self, node: AbstractNode<LayoutView>) -> ~Flow: { fn build_flow_for_block(&mut self, node: LayoutNode) -> ~Flow: {
let base = FlowData::new(self.next_flow_id(), node); let base = FlowData::new(self.next_flow_id(), node);
let box = self.build_box_for_node(node); let box = self.build_box_for_node(node);
let mut flow = ~BlockFlow::from_box(base, box) as ~Flow:; let mut flow = ~BlockFlow::from_box(base, box) as ~Flow:;
@ -359,7 +356,7 @@ impl<'self> FlowConstructor<'self> {
/// Builds the flow for a node with `float: {left|right}`. This yields a float `BlockFlow` with /// Builds the flow for a node with `float: {left|right}`. This yields a float `BlockFlow` with
/// a `BlockFlow` underneath it. /// a `BlockFlow` underneath it.
fn build_flow_for_floated_block(&mut self, node: AbstractNode<LayoutView>, float_type: FloatType) fn build_flow_for_floated_block(&mut self, node: LayoutNode, float_type: FloatType)
-> ~Flow: { -> ~Flow: {
let base = FlowData::new(self.next_flow_id(), node); let base = FlowData::new(self.next_flow_id(), node);
let box = self.build_box_for_node(node); let box = self.build_box_for_node(node);
@ -371,7 +368,7 @@ impl<'self> FlowConstructor<'self> {
/// Concatenates the boxes of kids, adding in our own borders/padding/margins if necessary. /// Concatenates the boxes of kids, adding in our own borders/padding/margins if necessary.
/// Returns the `InlineBoxesConstructionResult`, if any. There will be no /// Returns the `InlineBoxesConstructionResult`, if any. There will be no
/// `InlineBoxesConstructionResult` if this node consisted entirely of ignorable whitespace. /// `InlineBoxesConstructionResult` if this node consisted entirely of ignorable whitespace.
fn build_boxes_for_nonreplaced_inline_content(&mut self, node: AbstractNode<LayoutView>) fn build_boxes_for_nonreplaced_inline_content(&mut self, node: LayoutNode)
-> ConstructionResult { -> ConstructionResult {
let mut opt_inline_block_splits = None; let mut opt_inline_block_splits = None;
let mut opt_box_accumulator = None; let mut opt_box_accumulator = None;
@ -437,8 +434,7 @@ impl<'self> FlowConstructor<'self> {
/// Creates an `InlineBoxesConstructionResult` for replaced content. Replaced content doesn't /// 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`. /// 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: AbstractNode<LayoutView>) fn build_boxes_for_replaced_inline_content(&mut self, node: LayoutNode) -> ConstructionResult {
-> ConstructionResult {
for kid in node.children() { for kid in node.children() {
kid.set_flow_construction_result(NoConstructionResult) kid.set_flow_construction_result(NoConstructionResult)
} }
@ -454,7 +450,7 @@ impl<'self> FlowConstructor<'self> {
/// Builds one or more boxes for a node with `display: inline`. This yields an /// Builds one or more boxes for a node with `display: inline`. This yields an
/// `InlineBoxesConstructionResult`. /// `InlineBoxesConstructionResult`.
fn build_boxes_for_inline(&mut self, node: AbstractNode<LayoutView>) -> ConstructionResult { fn build_boxes_for_inline(&mut self, node: LayoutNode) -> ConstructionResult {
// Is this node replaced content? // Is this node replaced content?
if !node.is_replaced_content() { if !node.is_replaced_content() {
// Go to a path that concatenates our kids' boxes. // Go to a path that concatenates our kids' boxes.
@ -470,7 +466,7 @@ impl<'self> PostorderNodeMutTraversal for FlowConstructor<'self> {
// `#[inline(always)]` because this is always called from the traversal function and for some // `#[inline(always)]` because this is always called from the traversal function and for some
// reason LLVM's inlining heuristics go awry here. // reason LLVM's inlining heuristics go awry here.
#[inline(always)] #[inline(always)]
fn process(&mut self, node: AbstractNode<LayoutView>) -> bool { fn process(&mut self, node: LayoutNode) -> bool {
// Get the `display` property for this node, and determine whether this node is floated. // Get the `display` property for this node, and determine whether this node is floated.
let (display, float) = match node.type_id() { let (display, float) = match node.type_id() {
ElementNodeTypeId(_) => { ElementNodeTypeId(_) => {
@ -540,7 +536,7 @@ trait NodeUtils {
fn is_ignorable_whitespace(self) -> bool; fn is_ignorable_whitespace(self) -> bool;
} }
impl NodeUtils for AbstractNode<LayoutView> { impl NodeUtils for LayoutNode {
fn is_replaced_content(self) -> bool { fn is_replaced_content(self) -> bool {
match self.type_id() { match self.type_id() {
TextNodeTypeId | TextNodeTypeId |
@ -572,7 +568,7 @@ impl NodeUtils for AbstractNode<LayoutView> {
} }
fn is_ignorable_whitespace(self) -> bool { fn is_ignorable_whitespace(self) -> bool {
self.is_text() && self.with_imm_text(|text| text.element.data.is_whitespace()) self.is_text() && self.with_text(|text| text.element.data.is_whitespace())
} }
} }

View file

@ -6,7 +6,7 @@
use layout::util::{LayoutData, LayoutDataAccess}; use layout::util::{LayoutData, LayoutDataAccess};
use script::dom::node::{AbstractNode, LayoutView}; use script::dom::node::LayoutNode;
/// Functionality useful for querying the layout-specific data on DOM nodes. /// Functionality useful for querying the layout-specific data on DOM nodes.
pub trait LayoutAuxMethods { pub trait LayoutAuxMethods {
@ -14,7 +14,7 @@ pub trait LayoutAuxMethods {
fn initialize_style_for_subtree(self); fn initialize_style_for_subtree(self);
} }
impl LayoutAuxMethods for AbstractNode<LayoutView> { impl LayoutAuxMethods for LayoutNode {
/// Resets layout data and styles for the node. /// Resets layout data and styles for the node.
/// ///
/// FIXME(pcwalton): Do this as part of box building instead of in a traversal. /// FIXME(pcwalton): Do this as part of box building instead of in a traversal.

View file

@ -39,7 +39,7 @@ use extra::container::Deque;
use geom::point::Point2D; use geom::point::Point2D;
use geom::rect::Rect; use geom::rect::Rect;
use gfx::display_list::{ClipDisplayItemClass, DisplayList}; use gfx::display_list::{ClipDisplayItemClass, DisplayList};
use script::dom::node::{AbstractNode, LayoutView}; use script::dom::node::LayoutNode;
use servo_util::geometry::Au; use servo_util::geometry::Au;
use std::cast; use std::cast;
use std::cell::Cell; use std::cell::Cell;
@ -382,7 +382,6 @@ impl FlowFlags {
/// FIXME: We need a naming convention for pseudo-inheritance like this. How about /// FIXME: We need a naming convention for pseudo-inheritance like this. How about
/// `CommonFlowInfo`? /// `CommonFlowInfo`?
pub struct FlowData { pub struct FlowData {
node: AbstractNode<LayoutView>,
restyle_damage: RestyleDamage, restyle_damage: RestyleDamage,
/// The children of this flow. /// The children of this flow.
@ -433,10 +432,9 @@ impl Iterator<@Box> for BoxIterator {
impl FlowData { impl FlowData {
#[inline] #[inline]
pub fn new(id: int, node: AbstractNode<LayoutView>) -> FlowData { pub fn new(id: int, node: LayoutNode) -> FlowData {
let style = node.style(); let style = node.style();
FlowData { FlowData {
node: node,
restyle_damage: node.restyle_damage(), restyle_damage: node.restyle_damage(),
children: DList::new(), children: DList::new(),

View file

@ -28,7 +28,7 @@ use gfx::opts::Opts;
use gfx::render_task::{RenderMsg, RenderChan, RenderLayer}; use gfx::render_task::{RenderMsg, RenderChan, RenderLayer};
use gfx::{render_task, color}; use gfx::{render_task, color};
use script::dom::event::ReflowEvent; use script::dom::event::ReflowEvent;
use script::dom::node::{AbstractNode, LayoutDataRef, LayoutView, ElementNodeTypeId}; use script::dom::node::{AbstractNode, ElementNodeTypeId, LayoutDataRef, LayoutNode};
use script::dom::element::{HTMLBodyElementTypeId, HTMLHtmlElementTypeId}; use script::dom::element::{HTMLBodyElementTypeId, HTMLHtmlElementTypeId};
use script::layout_interface::{AddStylesheetMsg, ContentBoxQuery}; use script::layout_interface::{AddStylesheetMsg, ContentBoxQuery};
use script::layout_interface::{ContentBoxesQuery, ContentBoxesResponse, ExitNowMsg, LayoutQuery}; use script::layout_interface::{ContentBoxesQuery, ContentBoxesResponse, ExitNowMsg, LayoutQuery};
@ -358,8 +358,7 @@ impl LayoutTask {
/// is intertwined with selector matching, making it difficult to compare directly. It is /// is intertwined with selector matching, making it difficult to compare directly. It is
/// marked `#[inline(never)]` to aid benchmarking in sampling profilers. /// marked `#[inline(never)]` to aid benchmarking in sampling profilers.
#[inline(never)] #[inline(never)]
fn construct_flow_tree(&self, layout_context: &mut LayoutContext, node: AbstractNode<LayoutView>) fn construct_flow_tree(&self, layout_context: &mut LayoutContext, node: LayoutNode) -> ~Flow: {
-> ~Flow: {
node.traverse_postorder_mut(&mut FlowConstructor::init(layout_context)); node.traverse_postorder_mut(&mut FlowConstructor::init(layout_context));
let result = match *node.mutate_layout_data().ptr { let result = match *node.mutate_layout_data().ptr {
@ -401,7 +400,7 @@ impl LayoutTask {
/// The high-level routine that performs layout tasks. /// The high-level routine that performs layout tasks.
fn handle_reflow(&mut self, data: &Reflow) { fn handle_reflow(&mut self, data: &Reflow) {
// FIXME: Isolate this transmutation into a "bridge" module. // FIXME: Isolate this transmutation into a "bridge" module.
let node: &AbstractNode<LayoutView> = unsafe { let node: &LayoutNode = unsafe {
transmute(&data.document_root) transmute(&data.document_root)
}; };
@ -534,7 +533,7 @@ impl LayoutTask {
// The neat thing here is that in order to answer the following two queries we only // The neat thing here is that in order to answer the following two queries we only
// need to compare nodes for equality. Thus we can safely work only with `OpaqueNode`. // need to compare nodes for equality. Thus we can safely work only with `OpaqueNode`.
ContentBoxQuery(node, reply_chan) => { ContentBoxQuery(node, reply_chan) => {
let node = OpaqueNode::from_node(&node); let node = OpaqueNode::from_script_node(&node);
fn union_boxes_for_node<'a>( fn union_boxes_for_node<'a>(
accumulator: &mut Option<Rect<Au>>, accumulator: &mut Option<Rect<Au>>,
@ -557,7 +556,7 @@ impl LayoutTask {
reply_chan.send(ContentBoxResponse(rect.unwrap_or(Au::zero_rect()))) reply_chan.send(ContentBoxResponse(rect.unwrap_or(Au::zero_rect())))
} }
ContentBoxesQuery(node, reply_chan) => { ContentBoxesQuery(node, reply_chan) => {
let node = OpaqueNode::from_node(&node); let node = OpaqueNode::from_script_node(&node);
fn add_boxes_for_node<'a>( fn add_boxes_for_node<'a>(
accumulator: &mut ~[Rect<Au>], accumulator: &mut ~[Rect<Au>],
@ -608,8 +607,8 @@ impl LayoutTask {
// incremental flow construction could create this. Paranoid validation // incremental flow construction could create this. Paranoid validation
// against the set of valid nodes should occur in the script task to // against the set of valid nodes should occur in the script task to
// ensure that this is a valid address instead of transmuting here. // ensure that this is a valid address instead of transmuting here.
let node: AbstractNode<LayoutView> = unsafe { let node: AbstractNode = unsafe {
item.base().extra.to_node() item.base().extra.to_script_node()
}; };
let resp = Some(HitTestResponse(node)); let resp = Some(HitTestResponse(node));
return resp; return resp;

View file

@ -6,7 +6,7 @@ use layout::box::Box;
use layout::construct::{ConstructionResult, NoConstructionResult}; use layout::construct::{ConstructionResult, NoConstructionResult};
use extra::arc::Arc; use extra::arc::Arc;
use script::dom::node::{AbstractNode, LayoutView}; use script::dom::node::{AbstractNode, LayoutNode};
use servo_util::range::Range; use servo_util::range::Range;
use servo_util::slot::{MutSlotRef, SlotRef}; use servo_util::slot::{MutSlotRef, SlotRef};
use std::cast; use std::cast;
@ -163,23 +163,23 @@ pub trait LayoutDataAccess {
fn mutate_layout_data<'a>(&'a self) -> MutSlotRef<'a,Option<~LayoutData>>; fn mutate_layout_data<'a>(&'a self) -> MutSlotRef<'a,Option<~LayoutData>>;
} }
impl LayoutDataAccess for AbstractNode<LayoutView> { impl LayoutDataAccess for LayoutNode {
#[inline(always)] #[inline(always)]
unsafe fn borrow_layout_data_unchecked<'a>(&'a self) -> &'a Option<~LayoutData> { unsafe fn borrow_layout_data_unchecked<'a>(&'a self) -> &'a Option<~LayoutData> {
cast::transmute(self.node().layout_data.borrow_unchecked()) cast::transmute(self.get().layout_data.borrow_unchecked())
} }
#[inline(always)] #[inline(always)]
fn borrow_layout_data<'a>(&'a self) -> SlotRef<'a,Option<~LayoutData>> { fn borrow_layout_data<'a>(&'a self) -> SlotRef<'a,Option<~LayoutData>> {
unsafe { unsafe {
cast::transmute(self.node().layout_data.borrow()) cast::transmute(self.get().layout_data.borrow())
} }
} }
#[inline(always)] #[inline(always)]
fn mutate_layout_data<'a>(&'a self) -> MutSlotRef<'a,Option<~LayoutData>> { fn mutate_layout_data<'a>(&'a self) -> MutSlotRef<'a,Option<~LayoutData>> {
unsafe { unsafe {
cast::transmute(self.node().layout_data.mutate()) cast::transmute(self.get().layout_data.mutate())
} }
} }
} }
@ -193,25 +193,24 @@ impl LayoutDataAccess for AbstractNode<LayoutView> {
#[deriving(Clone, Eq)] #[deriving(Clone, Eq)]
pub struct OpaqueNode(uintptr_t); pub struct OpaqueNode(uintptr_t);
impl<T> Equiv<AbstractNode<T>> for OpaqueNode {
fn equiv(&self, node: &AbstractNode<T>) -> bool {
unsafe {
**self == cast::transmute_copy::<AbstractNode<T>,uintptr_t>(node)
}
}
}
impl OpaqueNode { impl OpaqueNode {
/// Converts a DOM node to an `OpaqueNode`. /// Converts a DOM node (layout view) to an `OpaqueNode`.
pub fn from_node<T>(node: &AbstractNode<T>) -> OpaqueNode { pub fn from_layout_node(node: &LayoutNode) -> OpaqueNode {
unsafe { unsafe {
OpaqueNode(cast::transmute_copy(node)) OpaqueNode(cast::transmute_copy(node))
} }
} }
/// Unsafely converts an `OpaqueNode` to a DOM node. Use this only if you absolutely know what /// Converts a DOM node (script view) to an `OpaqueNode`.
/// you're doing. pub fn from_script_node(node: &AbstractNode) -> OpaqueNode {
pub unsafe fn to_node<T>(&self) -> AbstractNode<T> { unsafe {
OpaqueNode(cast::transmute_copy(node))
}
}
/// Unsafely converts an `OpaqueNode` to a DOM node (script view). Use this only if you
/// absolutely know what you're doing.
pub unsafe fn to_script_node(&self) -> AbstractNode {
cast::transmute(**self) cast::transmute(**self)
} }

View file

@ -5,18 +5,17 @@
use dom::attr::Attr; use dom::attr::Attr;
use dom::bindings::codegen::AttrListBinding; use dom::bindings::codegen::AttrListBinding;
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object}; use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::node::{AbstractNode, ScriptView}; use dom::node::{AbstractNode};
use dom::window::Window; use dom::window::Window;
pub struct AttrList { pub struct AttrList {
reflector_: Reflector, reflector_: Reflector,
window: @mut Window, window: @mut Window,
owner: AbstractNode<ScriptView> owner: AbstractNode,
} }
impl AttrList { impl AttrList {
pub fn new_inherited(window: @mut Window, pub fn new_inherited(window: @mut Window, elem: AbstractNode) -> AttrList {
elem: AbstractNode<ScriptView>) -> AttrList {
AttrList { AttrList {
reflector_: Reflector::new(), reflector_: Reflector::new(),
window: window, window: window,
@ -24,7 +23,7 @@ impl AttrList {
} }
} }
pub fn new(window: @mut Window, elem: AbstractNode<ScriptView>) -> @mut AttrList { pub fn new(window: @mut Window, elem: AbstractNode) -> @mut AttrList {
reflect_dom_object(@mut AttrList::new_inherited(window, elem), reflect_dom_object(@mut AttrList::new_inherited(window, elem),
window, AttrListBinding::Wrap) window, AttrListBinding::Wrap)
} }

View file

@ -121,7 +121,7 @@ DOMInterfaces = {
}], }],
'CharacterData': { 'CharacterData': {
'nativeType': 'AbstractNode<ScriptView>', 'nativeType': 'AbstractNode',
'concreteType': 'CharacterData', 'concreteType': 'CharacterData',
'pointerType': '' 'pointerType': ''
}, },
@ -182,7 +182,7 @@ DOMInterfaces = {
}], }],
'Element': { 'Element': {
'nativeType': 'AbstractNode<ScriptView>', 'nativeType': 'AbstractNode',
'pointerType': '', 'pointerType': '',
'needsAbstract': ['getClientRects', 'getBoundingClientRect', 'setAttribute', 'setAttributeNS', 'id', 'attributes'] 'needsAbstract': ['getClientRects', 'getBoundingClientRect', 'setAttribute', 'setAttributeNS', 'id', 'attributes']
}, },
@ -239,7 +239,7 @@ DOMInterfaces = {
}, },
'HTMLFormElement': { 'HTMLFormElement': {
'nativeType': 'AbstractNode<ScriptView>', 'nativeType': 'AbstractNode',
'pointerType': '', 'pointerType': '',
'register': False 'register': False
}, },
@ -302,7 +302,7 @@ DOMInterfaces = {
}, },
'Node': { 'Node': {
'nativeType': 'AbstractNode<ScriptView>', 'nativeType': 'AbstractNode',
'concreteType': 'Node<ScriptView>', 'concreteType': 'Node<ScriptView>',
'pointerType': '', 'pointerType': '',
'needsAbstract': [ 'needsAbstract': [
@ -574,7 +574,7 @@ def addExternalIface(iface, nativeType=None, headerFile=None, pointerType=None):
def addHTMLElement(element, concrete=None, needsAbstract=[]): def addHTMLElement(element, concrete=None, needsAbstract=[]):
DOMInterfaces[element] = { DOMInterfaces[element] = {
'nativeType': 'AbstractNode<ScriptView>', 'nativeType': 'AbstractNode',
'pointerType': '', 'pointerType': '',
'concreteType': concrete if concrete else element, 'concreteType': concrete if concrete else element,
'customTrace': 'trace', 'customTrace': 'trace',

View file

@ -11,7 +11,7 @@ use std::libc;
use std::ptr; use std::ptr;
use js::jsapi::{JSTracer, JSTRACE_OBJECT, JS_CallTracer}; use js::jsapi::{JSTracer, JSTRACE_OBJECT, JS_CallTracer};
impl Reflectable for AbstractNode<ScriptView> { impl Reflectable for AbstractNode {
fn reflector<'a>(&'a self) -> &'a Reflector { fn reflector<'a>(&'a self) -> &'a Reflector {
self.node().reflector() self.node().reflector()
} }
@ -24,7 +24,7 @@ impl Reflectable for AbstractNode<ScriptView> {
impl Traceable for Node<ScriptView> { impl Traceable for Node<ScriptView> {
fn trace(&self, tracer: *mut JSTracer) { fn trace(&self, tracer: *mut JSTracer) {
#[fixed_stack_segment] #[fixed_stack_segment]
fn trace_node(tracer: *mut JSTracer, node: Option<AbstractNode<ScriptView>>, name: &str) { fn trace_node(tracer: *mut JSTracer, node: Option<AbstractNode>, name: &str) {
if node.is_none() { if node.is_none() {
return; return;
} }

View file

@ -6,7 +6,7 @@ use dom::bindings::codegen::CommentBinding;
use dom::bindings::utils::{DOMString, Fallible}; use dom::bindings::utils::{DOMString, Fallible};
use dom::characterdata::CharacterData; use dom::characterdata::CharacterData;
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::node::{AbstractNode, ScriptView, CommentNodeTypeId, Node}; use dom::node::{AbstractNode, CommentNodeTypeId, Node};
use dom::window::Window; use dom::window::Window;
/// An HTML comment. /// An HTML comment.
@ -21,12 +21,12 @@ impl Comment {
} }
} }
pub fn new(text: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(text: ~str, document: AbstractDocument) -> AbstractNode {
let node = Comment::new_inherited(text, document); let node = Comment::new_inherited(text, document);
Node::reflect_node(@mut node, document, CommentBinding::Wrap) Node::reflect_node(@mut node, document, CommentBinding::Wrap)
} }
pub fn Constructor(owner: @mut Window, data: DOMString) -> Fallible<AbstractNode<ScriptView>> { pub fn Constructor(owner: @mut Window, data: DOMString) -> Fallible<AbstractNode> {
Ok(Comment::new(data, owner.Document())) Ok(Comment::new(data, owner.Document()))
} }
} }

View file

@ -92,7 +92,7 @@ pub struct Document {
window: @mut Window, window: @mut Window,
doctype: DocumentType, doctype: DocumentType,
title: ~str, title: ~str,
idmap: HashMap<DOMString, AbstractNode<ScriptView>> idmap: HashMap<DOMString, AbstractNode>
} }
impl Document { impl Document {
@ -161,7 +161,7 @@ impl Reflectable for Document {
} }
impl Document { impl Document {
pub fn GetDocumentElement(&self) -> Option<AbstractNode<ScriptView>> { pub fn GetDocumentElement(&self) -> Option<AbstractNode> {
do self.node.children().find |c| { do self.node.children().find |c| {
c.is_element() c.is_element()
} }
@ -183,7 +183,7 @@ impl Document {
HTMLCollection::new(self.window, ~[]) HTMLCollection::new(self.window, ~[])
} }
pub fn GetElementById(&self, id: DOMString) -> Option<AbstractNode<ScriptView>> { pub fn GetElementById(&self, id: DOMString) -> Option<AbstractNode> {
// TODO: "in tree order, within the context object's tree" // TODO: "in tree order, within the context object's tree"
// http://dom.spec.whatwg.org/#dom-document-getelementbyid. // http://dom.spec.whatwg.org/#dom-document-getelementbyid.
match self.idmap.find_equiv(&id) { match self.idmap.find_equiv(&id) {
@ -192,7 +192,8 @@ impl Document {
} }
} }
pub fn CreateElement(&self, abstract_self: AbstractDocument, local_name: DOMString) -> Fallible<AbstractNode<ScriptView>> { pub fn CreateElement(&self, abstract_self: AbstractDocument, local_name: DOMString)
-> Fallible<AbstractNode> {
if xml_name_type(local_name) == InvalidXMLName { if xml_name_type(local_name) == InvalidXMLName {
debug!("Not a valid element name"); debug!("Not a valid element name");
return Err(InvalidCharacter); return Err(InvalidCharacter);
@ -201,15 +202,16 @@ impl Document {
Ok(build_element_from_tag(local_name, abstract_self)) Ok(build_element_from_tag(local_name, abstract_self))
} }
pub fn CreateDocumentFragment(&self, abstract_self: AbstractDocument) -> AbstractNode<ScriptView> { pub fn CreateDocumentFragment(&self, abstract_self: AbstractDocument) -> AbstractNode {
DocumentFragment::new(abstract_self) DocumentFragment::new(abstract_self)
} }
pub fn CreateTextNode(&self, abstract_self: AbstractDocument, data: DOMString) -> AbstractNode<ScriptView> { pub fn CreateTextNode(&self, abstract_self: AbstractDocument, data: DOMString)
-> AbstractNode {
Text::new(data, abstract_self) Text::new(data, abstract_self)
} }
pub fn CreateComment(&self, abstract_self: AbstractDocument, data: DOMString) -> AbstractNode<ScriptView> { pub fn CreateComment(&self, abstract_self: AbstractDocument, data: DOMString) -> AbstractNode {
Comment::new(data, abstract_self) Comment::new(data, abstract_self)
} }
@ -330,15 +332,15 @@ impl Document {
self.window.wait_until_safe_to_modify_dom(); self.window.wait_until_safe_to_modify_dom();
} }
pub fn register_nodes_with_id(&mut self, root: &AbstractNode<ScriptView>) { pub fn register_nodes_with_id(&mut self, root: &AbstractNode) {
foreach_ided_elements(root, |id: &DOMString, abstract_node: &AbstractNode<ScriptView>| { foreach_ided_elements(root, |id: &DOMString, abstract_node: &AbstractNode| {
// TODO: "in tree order, within the context object's tree" // TODO: "in tree order, within the context object's tree"
// http://dom.spec.whatwg.org/#dom-document-getelementbyid. // http://dom.spec.whatwg.org/#dom-document-getelementbyid.
self.idmap.find_or_insert(id.clone(), *abstract_node); self.idmap.find_or_insert(id.clone(), *abstract_node);
}); });
} }
pub fn unregister_nodes_with_id(&mut self, root: &AbstractNode<ScriptView>) { pub fn unregister_nodes_with_id(&mut self, root: &AbstractNode) {
foreach_ided_elements(root, |id: &DOMString, _| { foreach_ided_elements(root, |id: &DOMString, _| {
// TODO: "in tree order, within the context object's tree" // TODO: "in tree order, within the context object's tree"
// http://dom.spec.whatwg.org/#dom-document-getelementbyid. // http://dom.spec.whatwg.org/#dom-document-getelementbyid.
@ -347,7 +349,7 @@ impl Document {
} }
pub fn update_idmap(&mut self, pub fn update_idmap(&mut self,
abstract_self: AbstractNode<ScriptView>, abstract_self: AbstractNode,
new_id: DOMString, new_id: DOMString,
old_id: Option<DOMString>) { old_id: Option<DOMString>) {
// remove old ids if the old ones are not same as the new one. // remove old ids if the old ones are not same as the new one.
@ -359,19 +361,17 @@ impl Document {
} }
// TODO: support the case if multiple elements which haves same id are in the same document. // TODO: support the case if multiple elements which haves same id are in the same document.
self.idmap.mangle(new_id, abstract_self, self.idmap.mangle(new_id, abstract_self, |_, new_node: AbstractNode| -> AbstractNode {
|_, new_node: AbstractNode<ScriptView>| -> AbstractNode<ScriptView> {
new_node new_node
}, },
|_, old_node: &mut AbstractNode<ScriptView>, new_node: AbstractNode<ScriptView>| { |_, old_node: &mut AbstractNode, new_node: AbstractNode| {
*old_node = new_node; *old_node = new_node;
}); });
} }
} }
#[inline(always)] #[inline(always)]
fn foreach_ided_elements(root: &AbstractNode<ScriptView>, fn foreach_ided_elements(root: &AbstractNode, callback: &fn(&DOMString, &AbstractNode)) {
callback: &fn(&DOMString, &AbstractNode<ScriptView>)) {
for node in root.traverse_preorder() { for node in root.traverse_preorder() {
if !node.is_element() { if !node.is_element() {
continue; continue;

View file

@ -21,14 +21,14 @@ impl DocumentFragment {
} }
} }
pub fn new(document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(document: AbstractDocument) -> AbstractNode {
let node = DocumentFragment::new_inherited(document); let node = DocumentFragment::new_inherited(document);
Node::reflect_node(@mut node, document, DocumentFragmentBinding::Wrap) Node::reflect_node(@mut node, document, DocumentFragmentBinding::Wrap)
} }
} }
impl DocumentFragment { impl DocumentFragment {
pub fn Constructor(owner: @mut Window) -> Fallible<AbstractNode<ScriptView>> { pub fn Constructor(owner: @mut Window) -> Fallible<AbstractNode> {
Ok(DocumentFragment::new(owner.Document())) Ok(DocumentFragment::new(owner.Document()))
} }
} }

View file

@ -36,7 +36,8 @@ impl DocumentType {
public_id: Option<~str>, public_id: Option<~str>,
system_id: Option<~str>, system_id: Option<~str>,
force_quirks: bool, force_quirks: bool,
document: AbstractDocument) -> AbstractNode<ScriptView> { document: AbstractDocument)
-> AbstractNode {
let documenttype = DocumentType::new_inherited(name, let documenttype = DocumentType::new_inherited(name,
public_id, public_id,
system_id, system_id,

View file

@ -187,15 +187,13 @@ impl<'self> Element {
}) })
} }
pub fn set_attr(&mut self, pub fn set_attr(&mut self, abstract_self: AbstractNode, name: DOMString, value: DOMString)
abstract_self: AbstractNode<ScriptView>, -> ErrorResult {
name: DOMString,
value: DOMString) -> ErrorResult {
self.set_attribute(abstract_self, namespace::Null, name, value) self.set_attribute(abstract_self, namespace::Null, name, value)
} }
pub fn set_attribute(&mut self, pub fn set_attribute(&mut self,
abstract_self: AbstractNode<ScriptView>, abstract_self: AbstractNode,
namespace: Namespace, namespace: Namespace,
raw_name: DOMString, raw_name: DOMString,
value: DOMString) -> ErrorResult { value: DOMString) -> ErrorResult {
@ -260,7 +258,7 @@ impl<'self> Element {
} }
fn after_set_attr(&mut self, fn after_set_attr(&mut self,
abstract_self: AbstractNode<ScriptView>, abstract_self: AbstractNode,
local_name: DOMString, local_name: DOMString,
value: DOMString, value: DOMString,
old_value: Option<DOMString>) { old_value: Option<DOMString>) {
@ -309,18 +307,18 @@ impl Element {
self.tag_name.to_ascii_upper() self.tag_name.to_ascii_upper()
} }
pub fn Id(&self, _abstract_self: AbstractNode<ScriptView>) -> DOMString { pub fn Id(&self, _abstract_self: AbstractNode) -> DOMString {
match self.get_attr(None, "id") { match self.get_attr(None, "id") {
Some(x) => x, Some(x) => x,
None => ~"" None => ~""
} }
} }
pub fn SetId(&mut self, abstract_self: AbstractNode<ScriptView>, id: DOMString) { pub fn SetId(&mut self, abstract_self: AbstractNode, id: DOMString) {
self.set_attribute(abstract_self, namespace::Null, ~"id", id); self.set_attribute(abstract_self, namespace::Null, ~"id", id);
} }
pub fn Attributes(&mut self, abstract_self: AbstractNode<ScriptView>) -> @mut AttrList { pub fn Attributes(&mut self, abstract_self: AbstractNode) -> @mut AttrList {
match self.attr_list { match self.attr_list {
None => { None => {
let window = self.node.owner_doc().document().window; let window = self.node.owner_doc().document().window;
@ -341,16 +339,14 @@ impl Element {
.map(|attr| attr.value.clone()) .map(|attr| attr.value.clone())
} }
pub fn SetAttribute(&mut self, pub fn SetAttribute(&mut self, abstract_self: AbstractNode, name: DOMString, value: DOMString)
abstract_self: AbstractNode<ScriptView>, -> ErrorResult {
name: DOMString,
value: DOMString) -> ErrorResult {
self.set_attr(abstract_self, name, value); self.set_attr(abstract_self, name, value);
Ok(()) Ok(())
} }
pub fn SetAttributeNS(&mut self, pub fn SetAttributeNS(&mut self,
abstract_self: AbstractNode<ScriptView>, abstract_self: AbstractNode,
namespace_url: Option<DOMString>, namespace_url: Option<DOMString>,
name: DOMString, name: DOMString,
value: DOMString) -> ErrorResult { value: DOMString) -> ErrorResult {
@ -409,7 +405,7 @@ impl Element {
pub fn MozRequestPointerLock(&self) { pub fn MozRequestPointerLock(&self) {
} }
pub fn GetClientRects(&self, abstract_self: AbstractNode<ScriptView>) -> @mut ClientRectList { pub fn GetClientRects(&self, abstract_self: AbstractNode) -> @mut ClientRectList {
let win = self.node.owner_doc().document().window; let win = self.node.owner_doc().document().window;
let node = abstract_self; let node = abstract_self;
assert!(node.is_element()); assert!(node.is_element());
@ -431,7 +427,7 @@ impl Element {
ClientRectList::new(win, rects) ClientRectList::new(win, rects)
} }
pub fn GetBoundingClientRect(&self, abstract_self: AbstractNode<ScriptView>) -> @mut ClientRect { pub fn GetBoundingClientRect(&self, abstract_self: AbstractNode) -> @mut ClientRect {
let win = self.node.owner_doc().document().window; let win = self.node.owner_doc().document().window;
let node = abstract_self; let node = abstract_self;
assert!(node.is_element()); assert!(node.is_element());
@ -509,7 +505,7 @@ impl Element {
Ok(()) Ok(())
} }
pub fn QuerySelector(&self, _selectors: DOMString) -> Fallible<Option<AbstractNode<ScriptView>>> { pub fn QuerySelector(&self, _selectors: DOMString) -> Fallible<Option<AbstractNode>> {
Ok(None) Ok(None)
} }
} }

View file

@ -8,7 +8,7 @@ use dom::bindings::codegen::EventListenerBinding::EventListener;
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::event::AbstractEvent; use dom::event::AbstractEvent;
use dom::eventdispatcher::dispatch_event; use dom::eventdispatcher::dispatch_event;
use dom::node::{AbstractNode, ScriptView}; use dom::node::AbstractNode;
use dom::window::Window; use dom::window::Window;
use std::cast; use std::cast;
@ -50,7 +50,7 @@ impl AbstractEventTarget {
} }
} }
pub fn from_node(node: AbstractNode<ScriptView>) -> AbstractEventTarget { pub fn from_node(node: AbstractNode) -> AbstractEventTarget {
unsafe { unsafe {
cast::transmute(node) cast::transmute(node)
} }

View file

@ -6,7 +6,7 @@ use dom::bindings::utils::{Fallible, Reflectable, Reflector, reflect_dom_object}
use dom::bindings::utils::DOMString; use dom::bindings::utils::DOMString;
use dom::bindings::codegen::FormDataBinding; use dom::bindings::codegen::FormDataBinding;
use dom::blob::Blob; use dom::blob::Blob;
use dom::node::{AbstractNode, ScriptView}; use dom::node::AbstractNode;
use dom::window::Window; use dom::window::Window;
use std::hashmap::HashMap; use std::hashmap::HashMap;
@ -20,11 +20,11 @@ pub struct FormData {
data: HashMap<~str, FormDatum>, data: HashMap<~str, FormDatum>,
reflector_: Reflector, reflector_: Reflector,
window: @mut Window, window: @mut Window,
form: Option<AbstractNode<ScriptView>> form: Option<AbstractNode>
} }
impl FormData { impl FormData {
pub fn new_inherited(form: Option<AbstractNode<ScriptView>>, window: @mut Window) -> FormData { pub fn new_inherited(form: Option<AbstractNode>, window: @mut Window) -> FormData {
FormData { FormData {
data: HashMap::new(), data: HashMap::new(),
reflector_: Reflector::new(), reflector_: Reflector::new(),
@ -33,12 +33,12 @@ impl FormData {
} }
} }
pub fn new(form: Option<AbstractNode<ScriptView>>, window: @mut Window) -> @mut FormData { pub fn new(form: Option<AbstractNode>, window: @mut Window) -> @mut FormData {
reflect_dom_object(@mut FormData::new_inherited(form, window), window, FormDataBinding::Wrap) reflect_dom_object(@mut FormData::new_inherited(form, window), window, FormDataBinding::Wrap)
} }
pub fn Constructor(window: @mut Window, pub fn Constructor(window: @mut Window, form: Option<AbstractNode>)
form: Option<AbstractNode<ScriptView>>) -> Fallible<@mut FormData> { -> Fallible<@mut FormData> {
Ok(FormData::new(form, window)) Ok(FormData::new(form, window))
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLAnchorElementTypeId; use dom::element::HTMLAnchorElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLAnchorElement { pub struct HTMLAnchorElement {
htmlelement: HTMLElement htmlelement: HTMLElement
@ -20,7 +20,7 @@ impl HTMLAnchorElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLAnchorElement::new_inherited(localName, document); let element = HTMLAnchorElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLAnchorElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLAnchorElementBinding::Wrap)
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLAppletElementTypeId; use dom::element::HTMLAppletElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLAppletElement { pub struct HTMLAppletElement {
htmlelement: HTMLElement htmlelement: HTMLElement
@ -20,7 +20,7 @@ impl HTMLAppletElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLAppletElement::new_inherited(localName, document); let element = HTMLAppletElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLAppletElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLAppletElementBinding::Wrap)
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLAreaElementTypeId; use dom::element::HTMLAreaElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLAreaElement { pub struct HTMLAreaElement {
htmlelement: HTMLElement htmlelement: HTMLElement
@ -20,7 +20,7 @@ impl HTMLAreaElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLAreaElement::new_inherited(localName, document); let element = HTMLAreaElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLAreaElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLAreaElementBinding::Wrap)
} }

View file

@ -6,7 +6,7 @@ use dom::bindings::codegen::HTMLAudioElementBinding;
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLAudioElementTypeId; use dom::element::HTMLAudioElementTypeId;
use dom::htmlmediaelement::HTMLMediaElement; use dom::htmlmediaelement::HTMLMediaElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLAudioElement { pub struct HTMLAudioElement {
htmlmediaelement: HTMLMediaElement htmlmediaelement: HTMLMediaElement
@ -19,7 +19,7 @@ impl HTMLAudioElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLAudioElement::new_inherited(localName, document); let element = HTMLAudioElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLAudioElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLAudioElementBinding::Wrap)
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLBaseElementTypeId; use dom::element::HTMLBaseElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLBaseElement { pub struct HTMLBaseElement {
htmlelement: HTMLElement htmlelement: HTMLElement
@ -20,7 +20,7 @@ impl HTMLBaseElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLBaseElement::new_inherited(localName, document); let element = HTMLBaseElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLBaseElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLBaseElementBinding::Wrap)
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLBodyElementTypeId; use dom::element::HTMLBodyElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLBodyElement { pub struct HTMLBodyElement {
htmlelement: HTMLElement htmlelement: HTMLElement
@ -20,7 +20,7 @@ impl HTMLBodyElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLBodyElement::new_inherited(localName, document); let element = HTMLBodyElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLBodyElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLBodyElementBinding::Wrap)
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLBRElementTypeId; use dom::element::HTMLBRElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLBRElement { pub struct HTMLBRElement {
htmlelement: HTMLElement, htmlelement: HTMLElement,
@ -20,7 +20,7 @@ impl HTMLBRElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLBRElement::new_inherited(localName, document); let element = HTMLBRElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLBRElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLBRElementBinding::Wrap)
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLButtonElementTypeId; use dom::element::HTMLButtonElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
use dom::validitystate::ValidityState; use dom::validitystate::ValidityState;
pub struct HTMLButtonElement { pub struct HTMLButtonElement {
@ -21,7 +21,7 @@ impl HTMLButtonElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLButtonElement::new_inherited(localName, document); let element = HTMLButtonElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLButtonElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLButtonElementBinding::Wrap)
} }
@ -44,7 +44,7 @@ impl HTMLButtonElement {
Ok(()) Ok(())
} }
pub fn GetForm(&self) -> Option<AbstractNode<ScriptView>> { pub fn GetForm(&self) -> Option<AbstractNode> {
None None
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::{ErrorResult};
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLCanvasElementTypeId; use dom::element::HTMLCanvasElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLCanvasElement { pub struct HTMLCanvasElement {
htmlelement: HTMLElement, htmlelement: HTMLElement,
@ -20,7 +20,7 @@ impl HTMLCanvasElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLCanvasElement::new_inherited(localName, document); let element = HTMLCanvasElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLCanvasElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLCanvasElementBinding::Wrap)
} }

View file

@ -5,7 +5,7 @@
use dom::bindings::codegen::HTMLCollectionBinding; use dom::bindings::codegen::HTMLCollectionBinding;
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object}; use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::bindings::utils::{DOMString, Fallible}; use dom::bindings::utils::{DOMString, Fallible};
use dom::node::{AbstractNode, ScriptView}; use dom::node::AbstractNode;
use dom::window::Window; use dom::window::Window;
use js::jsapi::{JSObject, JSContext}; use js::jsapi::{JSObject, JSContext};
@ -13,14 +13,13 @@ use js::jsapi::{JSObject, JSContext};
use std::ptr; use std::ptr;
pub struct HTMLCollection { pub struct HTMLCollection {
elements: ~[AbstractNode<ScriptView>], elements: ~[AbstractNode],
reflector_: Reflector, reflector_: Reflector,
window: @mut Window, window: @mut Window,
} }
impl HTMLCollection { impl HTMLCollection {
pub fn new_inherited(window: @mut Window, pub fn new_inherited(window: @mut Window, elements: ~[AbstractNode]) -> HTMLCollection {
elements: ~[AbstractNode<ScriptView>]) -> HTMLCollection {
HTMLCollection { HTMLCollection {
elements: elements, elements: elements,
reflector_: Reflector::new(), reflector_: Reflector::new(),
@ -28,8 +27,7 @@ impl HTMLCollection {
} }
} }
pub fn new(window: @mut Window, pub fn new(window: @mut Window, elements: ~[AbstractNode]) -> @mut HTMLCollection {
elements: ~[AbstractNode<ScriptView>]) -> @mut HTMLCollection {
reflect_dom_object(@mut HTMLCollection::new_inherited(window, elements), reflect_dom_object(@mut HTMLCollection::new_inherited(window, elements),
window, HTMLCollectionBinding::Wrap) window, HTMLCollectionBinding::Wrap)
} }
@ -38,7 +36,7 @@ impl HTMLCollection {
self.elements.len() as u32 self.elements.len() as u32
} }
pub fn Item(&self, index: u32) -> Option<AbstractNode<ScriptView>> { pub fn Item(&self, index: u32) -> Option<AbstractNode> {
if index < self.Length() { if index < self.Length() {
Some(self.elements[index]) Some(self.elements[index])
} else { } else {
@ -50,7 +48,7 @@ impl HTMLCollection {
Ok(ptr::null()) Ok(ptr::null())
} }
pub fn IndexedGetter(&self, index: u32, found: &mut bool) -> Option<AbstractNode<ScriptView>> { pub fn IndexedGetter(&self, index: u32, found: &mut bool) -> Option<AbstractNode> {
*found = true; *found = true;
self.Item(index) self.Item(index)
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLDataElementTypeId; use dom::element::HTMLDataElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLDataElement { pub struct HTMLDataElement {
htmlelement: HTMLElement htmlelement: HTMLElement
@ -20,7 +20,7 @@ impl HTMLDataElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLDataElement::new_inherited(localName, document); let element = HTMLDataElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLDataElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLDataElementBinding::Wrap)
} }

View file

@ -7,7 +7,7 @@ use dom::document::AbstractDocument;
use dom::element::HTMLDataListElementTypeId; use dom::element::HTMLDataListElementTypeId;
use dom::htmlcollection::HTMLCollection; use dom::htmlcollection::HTMLCollection;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLDataListElement { pub struct HTMLDataListElement {
htmlelement: HTMLElement htmlelement: HTMLElement
@ -20,7 +20,7 @@ impl HTMLDataListElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLDataListElement::new_inherited(localName, document); let element = HTMLDataListElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLDataListElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLDataListElementBinding::Wrap)
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::ErrorResult;
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLDirectoryElementTypeId; use dom::element::HTMLDirectoryElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLDirectoryElement { pub struct HTMLDirectoryElement {
htmlelement: HTMLElement htmlelement: HTMLElement
@ -20,7 +20,7 @@ impl HTMLDirectoryElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLDirectoryElement::new_inherited(localName, document); let element = HTMLDirectoryElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLDirectoryElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLDirectoryElementBinding::Wrap)
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLDivElementTypeId; use dom::element::HTMLDivElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLDivElement { pub struct HTMLDivElement {
htmlelement: HTMLElement htmlelement: HTMLElement
@ -20,7 +20,7 @@ impl HTMLDivElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLDivElement::new_inherited(localName, document); let element = HTMLDivElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLDivElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLDivElementBinding::Wrap)
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLDListElementTypeId; use dom::element::HTMLDListElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLDListElement { pub struct HTMLDListElement {
htmlelement: HTMLElement htmlelement: HTMLElement
@ -20,7 +20,7 @@ impl HTMLDListElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLDListElement::new_inherited(localName, document); let element = HTMLDListElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLDListElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLDListElementBinding::Wrap)
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::{Reflectable, Reflector, Traceable};
use dom::document::{AbstractDocument, Document, HTML}; use dom::document::{AbstractDocument, Document, HTML};
use dom::element::HTMLHeadElementTypeId; use dom::element::HTMLHeadElementTypeId;
use dom::htmlcollection::HTMLCollection; use dom::htmlcollection::HTMLCollection;
use dom::node::{AbstractNode, ScriptView, ElementNodeTypeId}; use dom::node::{AbstractNode, ElementNodeTypeId};
use dom::window::Window; use dom::window::Window;
use js::jsapi::JSTracer; use js::jsapi::JSTracer;
@ -32,7 +32,7 @@ impl HTMLDocument {
} }
impl HTMLDocument { impl HTMLDocument {
pub fn GetHead(&self) -> Option<AbstractNode<ScriptView>> { pub fn GetHead(&self) -> Option<AbstractNode> {
match self.parent.GetDocumentElement() { match self.parent.GetDocumentElement() {
None => None, None => None,
Some(root) => root.traverse_preorder().find(|child| { Some(root) => root.traverse_preorder().find(|child| {

View file

@ -6,7 +6,7 @@ use dom::bindings::codegen::HTMLElementBinding;
use dom::bindings::utils::{DOMString, ErrorResult, Fallible}; use dom::bindings::utils::{DOMString, ErrorResult, Fallible};
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::{Element, ElementTypeId, HTMLElementTypeId}; use dom::element::{Element, ElementTypeId, HTMLElementTypeId};
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
use js::jsapi::{JSContext, JSVal}; use js::jsapi::{JSContext, JSVal};
use js::JSVAL_NULL; use js::JSVAL_NULL;
use dom::namespace; use dom::namespace;
@ -22,7 +22,7 @@ impl HTMLElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLElement::new_inherited(HTMLElementTypeId, localName, document); let element = HTMLElement::new_inherited(HTMLElementTypeId, localName, document);
Node::reflect_node(@mut element, document, HTMLElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLElementBinding::Wrap)
} }
@ -133,7 +133,7 @@ impl HTMLElement {
pub fn SetClassName(&self, _class: DOMString) { pub fn SetClassName(&self, _class: DOMString) {
} }
pub fn GetOffsetParent(&self) -> Option<AbstractNode<ScriptView>> { pub fn GetOffsetParent(&self) -> Option<AbstractNode> {
None None
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLEmbedElementTypeId; use dom::element::HTMLEmbedElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLEmbedElement { pub struct HTMLEmbedElement {
htmlelement: HTMLElement htmlelement: HTMLElement
@ -20,7 +20,7 @@ impl HTMLEmbedElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLEmbedElement::new_inherited(localName, document); let element = HTMLEmbedElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLEmbedElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLEmbedElementBinding::Wrap)
} }

View file

@ -8,7 +8,7 @@ use dom::document::AbstractDocument;
use dom::element::HTMLFieldSetElementTypeId; use dom::element::HTMLFieldSetElementTypeId;
use dom::htmlcollection::HTMLCollection; use dom::htmlcollection::HTMLCollection;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
use dom::validitystate::ValidityState; use dom::validitystate::ValidityState;
pub struct HTMLFieldSetElement { pub struct HTMLFieldSetElement {
@ -22,7 +22,7 @@ impl HTMLFieldSetElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLFieldSetElement::new_inherited(localName, document); let element = HTMLFieldSetElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLFieldSetElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLFieldSetElementBinding::Wrap)
} }
@ -37,7 +37,7 @@ impl HTMLFieldSetElement {
Ok(()) Ok(())
} }
pub fn GetForm(&self) -> Option<AbstractNode<ScriptView>> { pub fn GetForm(&self) -> Option<AbstractNode> {
None None
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLFontElementTypeId; use dom::element::HTMLFontElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLFontElement { pub struct HTMLFontElement {
htmlelement: HTMLElement htmlelement: HTMLElement
@ -20,7 +20,7 @@ impl HTMLFontElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLFontElement::new_inherited(localName, document); let element = HTMLFontElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLFontElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLFontElementBinding::Wrap)
} }

View file

@ -8,7 +8,7 @@ use dom::document::AbstractDocument;
use dom::element::HTMLFormElementTypeId; use dom::element::HTMLFormElementTypeId;
use dom::htmlcollection::HTMLCollection; use dom::htmlcollection::HTMLCollection;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLFormElement { pub struct HTMLFormElement {
htmlelement: HTMLElement htmlelement: HTMLElement
@ -21,7 +21,7 @@ impl HTMLFormElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLFormElement::new_inherited(localName, document); let element = HTMLFormElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLFormElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLFormElementBinding::Wrap)
} }
@ -120,7 +120,7 @@ impl HTMLFormElement {
false false
} }
pub fn IndexedGetter(&self, _index: u32, _found: &mut bool) -> AbstractNode<ScriptView> { pub fn IndexedGetter(&self, _index: u32, _found: &mut bool) -> AbstractNode {
fail!("Not implemented.") fail!("Not implemented.")
} }
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLFrameElementTypeId; use dom::element::HTMLFrameElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
use dom::windowproxy::WindowProxy; use dom::windowproxy::WindowProxy;
pub struct HTMLFrameElement { pub struct HTMLFrameElement {
@ -21,7 +21,7 @@ impl HTMLFrameElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLFrameElement::new_inherited(localName, document); let element = HTMLFrameElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLFrameElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLFrameElementBinding::Wrap)
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLFrameSetElementTypeId; use dom::element::HTMLFrameSetElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLFrameSetElement { pub struct HTMLFrameSetElement {
htmlelement: HTMLElement htmlelement: HTMLElement
@ -20,7 +20,7 @@ impl HTMLFrameSetElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLFrameSetElement::new_inherited(localName, document); let element = HTMLFrameSetElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLFrameSetElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLFrameSetElementBinding::Wrap)
} }

View file

@ -6,7 +6,7 @@ use dom::bindings::codegen::HTMLHeadElementBinding;
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLHeadElementTypeId; use dom::element::HTMLHeadElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLHeadElement { pub struct HTMLHeadElement {
htmlelement: HTMLElement htmlelement: HTMLElement
@ -19,7 +19,7 @@ impl HTMLHeadElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLHeadElement::new_inherited(localName, document); let element = HTMLHeadElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLHeadElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLHeadElementBinding::Wrap)
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::DOMString;
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLHeadingElementTypeId; use dom::element::HTMLHeadingElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub enum HeadingLevel { pub enum HeadingLevel {
Heading1, Heading1,
@ -31,7 +31,7 @@ impl HTMLHeadingElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument, level: HeadingLevel) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument, level: HeadingLevel) -> AbstractNode {
let element = HTMLHeadingElement::new_inherited(localName, document, level); let element = HTMLHeadingElement::new_inherited(localName, document, level);
Node::reflect_node(@mut element, document, HTMLHeadingElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLHeadingElementBinding::Wrap)
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLHRElementTypeId; use dom::element::HTMLHRElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLHRElement { pub struct HTMLHRElement {
htmlelement: HTMLElement, htmlelement: HTMLElement,
@ -20,7 +20,7 @@ impl HTMLHRElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLHRElement::new_inherited(localName, document); let element = HTMLHRElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLHRElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLHRElementBinding::Wrap)
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLHtmlElementTypeId; use dom::element::HTMLHtmlElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLHtmlElement { pub struct HTMLHtmlElement {
htmlelement: HTMLElement htmlelement: HTMLElement
@ -20,7 +20,7 @@ impl HTMLHtmlElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLHtmlElement::new_inherited(localName, document); let element = HTMLHtmlElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLHtmlElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLHtmlElementBinding::Wrap)
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLIframeElementTypeId; use dom::element::HTMLIframeElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
use dom::windowproxy::WindowProxy; use dom::windowproxy::WindowProxy;
use extra::url::Url; use extra::url::Url;
@ -52,7 +52,7 @@ impl HTMLIFrameElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLIFrameElement::new_inherited(localName, document); let element = HTMLIFrameElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLIFrameElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLIFrameElementBinding::Wrap)
} }
@ -83,14 +83,14 @@ impl HTMLIFrameElement {
Ok(()) Ok(())
} }
pub fn Sandbox(&self, _abstract_self: AbstractNode<ScriptView>) -> DOMString { pub fn Sandbox(&self, _abstract_self: AbstractNode) -> DOMString {
match self.htmlelement.element.GetAttribute(~"sandbox") { match self.htmlelement.element.GetAttribute(~"sandbox") {
Some(s) => s.to_owned(), Some(s) => s.to_owned(),
None => ~"", None => ~"",
} }
} }
pub fn SetSandbox(&mut self, abstract_self: AbstractNode<ScriptView>, sandbox: DOMString) { pub fn SetSandbox(&mut self, abstract_self: AbstractNode, sandbox: DOMString) {
self.htmlelement.element.SetAttribute(abstract_self, ~"sandbox", sandbox); self.htmlelement.element.SetAttribute(abstract_self, ~"sandbox", sandbox);
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLImageElementTypeId; use dom::element::HTMLImageElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
use extra::url::Url; use extra::url::Url;
use servo_util::geometry::to_px; use servo_util::geometry::to_px;
use layout_interface::{ContentBoxQuery, ContentBoxResponse}; use layout_interface::{ContentBoxQuery, ContentBoxResponse};
@ -29,7 +29,7 @@ impl HTMLImageElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLImageElement::new_inherited(localName, document); let element = HTMLImageElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLImageElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLImageElementBinding::Wrap)
} }
@ -74,13 +74,11 @@ impl HTMLImageElement {
Ok(()) Ok(())
} }
pub fn Src(&self, _abstract_self: AbstractNode<ScriptView>) -> DOMString { pub fn Src(&self, _abstract_self: AbstractNode) -> DOMString {
~"" ~""
} }
pub fn SetSrc(&mut self, pub fn SetSrc(&mut self, abstract_self: AbstractNode, src: DOMString) -> ErrorResult {
abstract_self: AbstractNode<ScriptView>,
src: DOMString) -> ErrorResult {
let node = &mut self.htmlelement.element; let node = &mut self.htmlelement.element;
node.set_attr(abstract_self, ~"src", src.clone()); node.set_attr(abstract_self, ~"src", src.clone());
Ok(()) Ok(())
@ -110,7 +108,7 @@ impl HTMLImageElement {
Ok(()) Ok(())
} }
pub fn Width(&self, abstract_self: AbstractNode<ScriptView>) -> u32 { pub fn Width(&self, abstract_self: AbstractNode) -> u32 {
let node = &self.htmlelement.element.node; let node = &self.htmlelement.element.node;
let page = node.owner_doc().document().window.page; let page = node.owner_doc().document().window.page;
let (port, chan) = stream(); let (port, chan) = stream();
@ -121,15 +119,13 @@ impl HTMLImageElement {
} }
} }
pub fn SetWidth(&mut self, pub fn SetWidth(&mut self, abstract_self: AbstractNode, width: u32) -> ErrorResult {
abstract_self: AbstractNode<ScriptView>,
width: u32) -> ErrorResult {
let node = &mut self.htmlelement.element; let node = &mut self.htmlelement.element;
node.set_attr(abstract_self, ~"width", width.to_str()); node.set_attr(abstract_self, ~"width", width.to_str());
Ok(()) Ok(())
} }
pub fn Height(&self, abstract_self: AbstractNode<ScriptView>) -> u32 { pub fn Height(&self, abstract_self: AbstractNode) -> u32 {
let node = &self.htmlelement.element.node; let node = &self.htmlelement.element.node;
let page = node.owner_doc().document().window.page; let page = node.owner_doc().document().window.page;
let (port, chan) = stream(); let (port, chan) = stream();
@ -140,9 +136,7 @@ impl HTMLImageElement {
} }
} }
pub fn SetHeight(&mut self, pub fn SetHeight(&mut self, abstract_self: AbstractNode, height: u32) -> ErrorResult {
abstract_self: AbstractNode<ScriptView>,
height: u32) -> ErrorResult {
let node = &mut self.htmlelement.element; let node = &mut self.htmlelement.element;
node.set_attr(abstract_self, ~"height", height.to_str()); node.set_attr(abstract_self, ~"height", height.to_str());
Ok(()) Ok(())

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult, Fallible};
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLInputElementTypeId; use dom::element::HTMLInputElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLInputElement { pub struct HTMLInputElement {
htmlelement: HTMLElement, htmlelement: HTMLElement,
@ -20,7 +20,7 @@ impl HTMLInputElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLInputElement::new_inherited(localName, document); let element = HTMLInputElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLInputElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLInputElementBinding::Wrap)
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::DOMString;
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLLabelElementTypeId; use dom::element::HTMLLabelElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLLabelElement { pub struct HTMLLabelElement {
htmlelement: HTMLElement, htmlelement: HTMLElement,
@ -20,7 +20,7 @@ impl HTMLLabelElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLLabelElement::new_inherited(localName, document); let element = HTMLLabelElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLLabelElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLLabelElementBinding::Wrap)
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLLegendElementTypeId; use dom::element::HTMLLegendElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLLegendElement { pub struct HTMLLegendElement {
htmlelement: HTMLElement, htmlelement: HTMLElement,
@ -20,7 +20,7 @@ impl HTMLLegendElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLLegendElement::new_inherited(localName, document); let element = HTMLLegendElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLLegendElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLLegendElementBinding::Wrap)
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLLIElementTypeId; use dom::element::HTMLLIElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLLIElement { pub struct HTMLLIElement {
htmlelement: HTMLElement, htmlelement: HTMLElement,
@ -20,7 +20,7 @@ impl HTMLLIElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLLIElement::new_inherited(localName, document); let element = HTMLLIElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLLIElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLLIElementBinding::Wrap)
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLLinkElementTypeId; use dom::element::HTMLLinkElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLLinkElement { pub struct HTMLLinkElement {
htmlelement: HTMLElement, htmlelement: HTMLElement,
@ -20,7 +20,7 @@ impl HTMLLinkElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLLinkElement::new_inherited(localName, document); let element = HTMLLinkElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLLinkElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLLinkElementBinding::Wrap)
} }

View file

@ -6,7 +6,7 @@ use dom::bindings::codegen::HTMLMainElementBinding;
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLMainElementTypeId; use dom::element::HTMLMainElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLMainElement { pub struct HTMLMainElement {
htmlelement: HTMLElement htmlelement: HTMLElement
@ -19,7 +19,7 @@ impl HTMLMainElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLMainElement::new_inherited(localName, document); let element = HTMLMainElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLMainElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLMainElementBinding::Wrap)
} }

View file

@ -8,7 +8,7 @@ use dom::htmlcollection::HTMLCollection;
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLMapElementTypeId; use dom::element::HTMLMapElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLMapElement { pub struct HTMLMapElement {
htmlelement: HTMLElement htmlelement: HTMLElement
@ -21,7 +21,7 @@ impl HTMLMapElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLMapElement::new_inherited(localName, document); let element = HTMLMapElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLMapElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLMapElementBinding::Wrap)
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLMetaElementTypeId; use dom::element::HTMLMetaElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLMetaElement { pub struct HTMLMetaElement {
htmlelement: HTMLElement, htmlelement: HTMLElement,
@ -20,7 +20,7 @@ impl HTMLMetaElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLMetaElement::new_inherited(localName, document); let element = HTMLMetaElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLMetaElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLMetaElementBinding::Wrap)
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::ErrorResult;
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLMeterElementTypeId; use dom::element::HTMLMeterElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLMeterElement { pub struct HTMLMeterElement {
htmlelement: HTMLElement htmlelement: HTMLElement
@ -20,7 +20,7 @@ impl HTMLMeterElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLMeterElement::new_inherited(localName, document); let element = HTMLMeterElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLMeterElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLMeterElementBinding::Wrap)
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLModElementTypeId; use dom::element::HTMLModElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLModElement { pub struct HTMLModElement {
htmlelement: HTMLElement htmlelement: HTMLElement
@ -20,7 +20,7 @@ impl HTMLModElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLModElement::new_inherited(localName, document); let element = HTMLModElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLModElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLModElementBinding::Wrap)
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLObjectElementTypeId; use dom::element::HTMLObjectElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
use dom::validitystate::ValidityState; use dom::validitystate::ValidityState;
use dom::windowproxy::WindowProxy; use dom::windowproxy::WindowProxy;
@ -22,7 +22,7 @@ impl HTMLObjectElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLObjectElement::new_inherited(localName, document); let element = HTMLObjectElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLObjectElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLObjectElementBinding::Wrap)
} }
@ -61,7 +61,7 @@ impl HTMLObjectElement {
Ok(()) Ok(())
} }
pub fn GetForm(&self) -> Option<AbstractNode<ScriptView>> { pub fn GetForm(&self) -> Option<AbstractNode> {
None None
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLOListElementTypeId; use dom::element::HTMLOListElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLOListElement { pub struct HTMLOListElement {
htmlelement: HTMLElement, htmlelement: HTMLElement,
@ -20,7 +20,7 @@ impl HTMLOListElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLOListElement::new_inherited(localName, document); let element = HTMLOListElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLOListElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLOListElementBinding::Wrap)
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLOptGroupElementTypeId; use dom::element::HTMLOptGroupElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLOptGroupElement { pub struct HTMLOptGroupElement {
htmlelement: HTMLElement htmlelement: HTMLElement
@ -20,7 +20,7 @@ impl HTMLOptGroupElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLOptGroupElement::new_inherited(localName, document); let element = HTMLOptGroupElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLOptGroupElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLOptGroupElementBinding::Wrap)
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLOptionElementTypeId; use dom::element::HTMLOptionElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLOptionElement { pub struct HTMLOptionElement {
htmlelement: HTMLElement htmlelement: HTMLElement
@ -20,7 +20,7 @@ impl HTMLOptionElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLOptionElement::new_inherited(localName, document); let element = HTMLOptionElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLOptionElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLOptionElementBinding::Wrap)
} }
@ -35,7 +35,7 @@ impl HTMLOptionElement {
Ok(()) Ok(())
} }
pub fn GetForm(&self) -> Option<AbstractNode<ScriptView>> { pub fn GetForm(&self) -> Option<AbstractNode> {
None None
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLOutputElementTypeId; use dom::element::HTMLOutputElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
use dom::validitystate::ValidityState; use dom::validitystate::ValidityState;
pub struct HTMLOutputElement { pub struct HTMLOutputElement {
@ -21,14 +21,14 @@ impl HTMLOutputElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLOutputElement::new_inherited(localName, document); let element = HTMLOutputElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLOutputElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLOutputElementBinding::Wrap)
} }
} }
impl HTMLOutputElement { impl HTMLOutputElement {
pub fn GetForm(&self) -> Option<AbstractNode<ScriptView>> { pub fn GetForm(&self) -> Option<AbstractNode> {
None None
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLParagraphElementTypeId; use dom::element::HTMLParagraphElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLParagraphElement { pub struct HTMLParagraphElement {
htmlelement: HTMLElement htmlelement: HTMLElement
@ -20,7 +20,7 @@ impl HTMLParagraphElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLParagraphElement::new_inherited(localName, document); let element = HTMLParagraphElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLParagraphElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLParagraphElementBinding::Wrap)
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLParamElementTypeId; use dom::element::HTMLParamElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLParamElement { pub struct HTMLParamElement {
htmlelement: HTMLElement htmlelement: HTMLElement
@ -20,7 +20,7 @@ impl HTMLParamElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLParamElement::new_inherited(localName, document); let element = HTMLParamElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLParamElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLParamElementBinding::Wrap)
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::{ErrorResult};
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLPreElementTypeId; use dom::element::HTMLPreElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLPreElement { pub struct HTMLPreElement {
htmlelement: HTMLElement, htmlelement: HTMLElement,
@ -20,7 +20,7 @@ impl HTMLPreElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLPreElement::new_inherited(localName, document); let element = HTMLPreElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLPreElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLPreElementBinding::Wrap)
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::{ErrorResult, Fallible};
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLProgressElementTypeId; use dom::element::HTMLProgressElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLProgressElement { pub struct HTMLProgressElement {
htmlelement: HTMLElement, htmlelement: HTMLElement,
@ -20,7 +20,7 @@ impl HTMLProgressElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLProgressElement::new_inherited(localName, document); let element = HTMLProgressElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLProgressElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLProgressElementBinding::Wrap)
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLQuoteElementTypeId; use dom::element::HTMLQuoteElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLQuoteElement { pub struct HTMLQuoteElement {
htmlelement: HTMLElement, htmlelement: HTMLElement,
@ -20,7 +20,7 @@ impl HTMLQuoteElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLQuoteElement::new_inherited(localName, document); let element = HTMLQuoteElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLQuoteElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLQuoteElementBinding::Wrap)
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLScriptElementTypeId; use dom::element::HTMLScriptElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
use style::TElement; use style::TElement;
pub struct HTMLScriptElement { pub struct HTMLScriptElement {
@ -21,7 +21,7 @@ impl HTMLScriptElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLScriptElement::new_inherited(localName, document); let element = HTMLScriptElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLScriptElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLScriptElementBinding::Wrap)
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLSelectElementTypeId; use dom::element::HTMLSelectElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
use dom::validitystate::ValidityState; use dom::validitystate::ValidityState;
pub struct HTMLSelectElement { pub struct HTMLSelectElement {
@ -21,7 +21,7 @@ impl HTMLSelectElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLSelectElement::new_inherited(localName, document); let element = HTMLSelectElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLSelectElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLSelectElementBinding::Wrap)
} }
@ -44,7 +44,7 @@ impl HTMLSelectElement {
Ok(()) Ok(())
} }
pub fn GetForm(&self) -> Option<AbstractNode<ScriptView>> { pub fn GetForm(&self) -> Option<AbstractNode> {
None None
} }
@ -92,19 +92,19 @@ impl HTMLSelectElement {
Ok(()) Ok(())
} }
pub fn Item(&self, _index: u32) -> Option<AbstractNode<ScriptView>> { pub fn Item(&self, _index: u32) -> Option<AbstractNode> {
None None
} }
pub fn NamedItem(&self, _name: DOMString) -> Option<AbstractNode<ScriptView>> { pub fn NamedItem(&self, _name: DOMString) -> Option<AbstractNode> {
None None
} }
pub fn IndexedGetter(&self, _index: u32, _found: &mut bool) -> Option<AbstractNode<ScriptView>> { pub fn IndexedGetter(&self, _index: u32, _found: &mut bool) -> Option<AbstractNode> {
None None
} }
pub fn IndexedSetter(&mut self, _index: u32, _option: Option<AbstractNode<ScriptView>>) -> ErrorResult { pub fn IndexedSetter(&mut self, _index: u32, _option: Option<AbstractNode>) -> ErrorResult {
Ok(()) Ok(())
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLSourceElementTypeId; use dom::element::HTMLSourceElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLSourceElement { pub struct HTMLSourceElement {
htmlelement: HTMLElement htmlelement: HTMLElement
@ -20,7 +20,7 @@ impl HTMLSourceElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLSourceElement::new_inherited(localName, document); let element = HTMLSourceElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLSourceElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLSourceElementBinding::Wrap)
} }

View file

@ -6,7 +6,7 @@ use dom::bindings::codegen::HTMLSpanElementBinding;
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLSpanElementTypeId; use dom::element::HTMLSpanElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLSpanElement { pub struct HTMLSpanElement {
htmlelement: HTMLElement htmlelement: HTMLElement
@ -19,7 +19,7 @@ impl HTMLSpanElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLSpanElement::new_inherited(localName, document); let element = HTMLSpanElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLSpanElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLSpanElementBinding::Wrap)
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLStyleElementTypeId; use dom::element::HTMLStyleElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLStyleElement { pub struct HTMLStyleElement {
htmlelement: HTMLElement, htmlelement: HTMLElement,
@ -20,7 +20,7 @@ impl HTMLStyleElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLStyleElement::new_inherited(localName, document); let element = HTMLStyleElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLStyleElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLStyleElementBinding::Wrap)
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLTableCaptionElementTypeId; use dom::element::HTMLTableCaptionElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLTableCaptionElement { pub struct HTMLTableCaptionElement {
htmlelement: HTMLElement htmlelement: HTMLElement
@ -20,7 +20,7 @@ impl HTMLTableCaptionElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLTableCaptionElement::new_inherited(localName, document); let element = HTMLTableCaptionElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLTableCaptionElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLTableCaptionElementBinding::Wrap)
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLTableColElementTypeId; use dom::element::HTMLTableColElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLTableColElement { pub struct HTMLTableColElement {
htmlelement: HTMLElement, htmlelement: HTMLElement,
@ -20,7 +20,7 @@ impl HTMLTableColElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLTableColElement::new_inherited(localName, document); let element = HTMLTableColElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLTableColElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLTableColElementBinding::Wrap)
} }

View file

@ -6,7 +6,7 @@ use dom::bindings::codegen::HTMLTableDataCellElementBinding;
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLTableDataCellElementTypeId; use dom::element::HTMLTableDataCellElementTypeId;
use dom::htmltablecellelement::HTMLTableCellElement; use dom::htmltablecellelement::HTMLTableCellElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLTableDataCellElement { pub struct HTMLTableDataCellElement {
htmltablecellelement: HTMLTableCellElement, htmltablecellelement: HTMLTableCellElement,
@ -19,7 +19,7 @@ impl HTMLTableDataCellElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLTableDataCellElement::new_inherited(localName, document); let element = HTMLTableDataCellElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLTableDataCellElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLTableDataCellElementBinding::Wrap)
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLTableElementTypeId; use dom::element::HTMLTableElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLTableElement { pub struct HTMLTableElement {
htmlelement: HTMLElement, htmlelement: HTMLElement,
@ -20,7 +20,7 @@ impl HTMLTableElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLTableElement::new_inherited(localName, document); let element = HTMLTableElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLTableElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLTableElementBinding::Wrap)
} }

View file

@ -6,7 +6,7 @@ use dom::bindings::codegen::HTMLTableHeaderCellElementBinding;
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLTableHeaderCellElementTypeId; use dom::element::HTMLTableHeaderCellElementTypeId;
use dom::htmltablecellelement::HTMLTableCellElement; use dom::htmltablecellelement::HTMLTableCellElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLTableHeaderCellElement { pub struct HTMLTableHeaderCellElement {
htmltablecellelement: HTMLTableCellElement, htmltablecellelement: HTMLTableCellElement,
@ -19,7 +19,7 @@ impl HTMLTableHeaderCellElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLTableHeaderCellElement::new_inherited(localName, document); let element = HTMLTableHeaderCellElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLTableHeaderCellElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLTableHeaderCellElementBinding::Wrap)
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLTableRowElementTypeId; use dom::element::HTMLTableRowElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLTableRowElement { pub struct HTMLTableRowElement {
htmlelement: HTMLElement, htmlelement: HTMLElement,
@ -20,7 +20,7 @@ impl HTMLTableRowElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLTableRowElement::new_inherited(localName, document); let element = HTMLTableRowElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLTableRowElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLTableRowElementBinding::Wrap)
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLTableSectionElementTypeId; use dom::element::HTMLTableSectionElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLTableSectionElement { pub struct HTMLTableSectionElement {
htmlelement: HTMLElement, htmlelement: HTMLElement,
@ -20,7 +20,7 @@ impl HTMLTableSectionElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLTableSectionElement::new_inherited(localName, document); let element = HTMLTableSectionElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLTableSectionElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLTableSectionElementBinding::Wrap)
} }

View file

@ -6,7 +6,7 @@ use dom::bindings::codegen::HTMLTemplateElementBinding;
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLTemplateElementTypeId; use dom::element::HTMLTemplateElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLTemplateElement { pub struct HTMLTemplateElement {
htmlelement: HTMLElement, htmlelement: HTMLElement,
@ -19,7 +19,7 @@ impl HTMLTemplateElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLTemplateElement::new_inherited(localName, document); let element = HTMLTemplateElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLTemplateElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLTemplateElementBinding::Wrap)
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult, Fallible};
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLTextAreaElementTypeId; use dom::element::HTMLTextAreaElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLTextAreaElement { pub struct HTMLTextAreaElement {
htmlelement: HTMLElement, htmlelement: HTMLElement,
@ -20,7 +20,7 @@ impl HTMLTextAreaElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLTextAreaElement::new_inherited(localName, document); let element = HTMLTextAreaElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLTextAreaElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLTextAreaElementBinding::Wrap)
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLTimeElementTypeId; use dom::element::HTMLTimeElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLTimeElement { pub struct HTMLTimeElement {
htmlelement: HTMLElement htmlelement: HTMLElement
@ -20,7 +20,7 @@ impl HTMLTimeElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLTimeElement::new_inherited(localName, document); let element = HTMLTimeElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLTimeElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLTimeElementBinding::Wrap)
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLTitleElementTypeId; use dom::element::HTMLTitleElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLTitleElement { pub struct HTMLTitleElement {
htmlelement: HTMLElement, htmlelement: HTMLElement,
@ -20,7 +20,7 @@ impl HTMLTitleElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLTitleElement::new_inherited(localName, document); let element = HTMLTitleElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLTitleElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLTitleElementBinding::Wrap)
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLTrackElementTypeId; use dom::element::HTMLTrackElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLTrackElement { pub struct HTMLTrackElement {
htmlelement: HTMLElement, htmlelement: HTMLElement,
@ -20,7 +20,7 @@ impl HTMLTrackElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLTrackElement::new_inherited(localName, document); let element = HTMLTrackElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLTrackElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLTrackElementBinding::Wrap)
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLUListElementTypeId; use dom::element::HTMLUListElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLUListElement { pub struct HTMLUListElement {
htmlelement: HTMLElement htmlelement: HTMLElement
@ -20,7 +20,7 @@ impl HTMLUListElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLUListElement::new_inherited(localName, document); let element = HTMLUListElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLUListElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLUListElementBinding::Wrap)
} }

View file

@ -6,7 +6,7 @@ use dom::bindings::codegen::HTMLUnknownElementBinding;
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLUnknownElementTypeId; use dom::element::HTMLUnknownElementTypeId;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLUnknownElement { pub struct HTMLUnknownElement {
htmlelement: HTMLElement htmlelement: HTMLElement
@ -19,7 +19,7 @@ impl HTMLUnknownElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLUnknownElement::new_inherited(localName, document); let element = HTMLUnknownElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLUnknownElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLUnknownElementBinding::Wrap)
} }

View file

@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::element::HTMLVideoElementTypeId; use dom::element::HTMLVideoElementTypeId;
use dom::htmlmediaelement::HTMLMediaElement; use dom::htmlmediaelement::HTMLMediaElement;
use dom::node::{AbstractNode, Node, ScriptView}; use dom::node::{AbstractNode, Node};
pub struct HTMLVideoElement { pub struct HTMLVideoElement {
htmlmediaelement: HTMLMediaElement htmlmediaelement: HTMLMediaElement
@ -20,7 +20,7 @@ impl HTMLVideoElement {
} }
} }
pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
let element = HTMLVideoElement::new_inherited(localName, document); let element = HTMLVideoElement::new_inherited(localName, document);
Node::reflect_node(@mut element, document, HTMLVideoElementBinding::Wrap) Node::reflect_node(@mut element, document, HTMLVideoElementBinding::Wrap)
} }

View file

@ -31,36 +31,160 @@ use style::TNode;
// The basic Node structure // The basic Node structure
// //
/// A phantom type representing the script task's view of this node. Script is able to mutate /// A wrapper so that layout can access only the properties that it should have access to. Layout
/// nodes but may not access layout data. /// should only ever see this.
#[deriving(Eq)] #[deriving(Clone, Eq)]
pub struct ScriptView; pub struct LayoutNode {
priv node: AbstractNode,
}
/// A phantom type representing the layout task's view of the node. Layout is not allowed to mutate impl LayoutNode {
/// nodes but may access layout data. // NB: Do not make this public.
#[deriving(Eq)] //
pub struct LayoutView; // FIXME(pcwalton): Probably this should be marked `unsafe`.
fn new(node: AbstractNode) -> LayoutNode {
LayoutNode {
node: node,
}
}
// We shouldn't need Eq for ScriptView and LayoutView; see Rust #7671. /// FIXME(pcwalton): This isn't safe, as it exposes guts, and should be deprecated.
pub fn get<'a>(&'a self) -> &'a Node<LayoutView> {
unsafe {
cast::transmute(self.node.node())
}
}
/// Returns the first child of this node.
pub fn first_child(&self) -> Option<LayoutNode> {
self.node.first_child().map(|node| LayoutNode::new(node))
}
/// Returns the first child of this node.
pub fn last_child(&self) -> Option<LayoutNode> {
self.node.last_child().map(|node| LayoutNode::new(node))
}
/// Iterates over this node and all its descendants, in preorder.
///
/// FIXME(pcwalton): Terribly inefficient. We should use parallelism.
pub fn traverse_preorder(&self) -> LayoutTreeIterator {
let mut nodes = ~[];
gather_layout_nodes(self, &mut nodes, false);
LayoutTreeIterator::new(nodes)
}
/// Returns an iterator over this node's children.
pub fn children(&self) -> LayoutNodeChildrenIterator {
LayoutNodeChildrenIterator {
current_node: self.first_child(),
}
}
/// Returns the type ID of this node. Fails if this node is borrowed mutably.
pub fn type_id(&self) -> NodeTypeId {
self.node.type_id()
}
/// Downcasts this node to an image element and calls the given closure.
///
/// FIXME(pcwalton): RAII.
/// FIXME(pcwalton): This isn't safe, as it allows layout to access `AbstractNode`s, and should
/// be deprecated.
pub fn with_image_element<R>(self, f: &fn(&HTMLImageElement) -> R) -> R {
if !self.node.is_image_element() {
fail!(~"node is not an image element");
}
self.node.transmute(f)
}
/// Downcasts this node to an iframe element and calls the given closure.
///
/// FIXME(pcwalton): RAII.
/// FIXME(pcwalton): This isn't safe, as it allows layout to access `AbstractNode`s, and should
/// be deprecated.
pub fn with_iframe_element<R>(self, f: &fn(&HTMLIFrameElement) -> R) -> R {
if !self.node.is_iframe_element() {
fail!(~"node is not an iframe element");
}
self.node.transmute(f)
}
/// Returns true if this node is a text node or false otherwise.
#[inline]
pub fn is_text(self) -> bool {
self.node.is_text()
}
/// Downcasts this node to a text node and calls the given closure.
///
/// FIXME(pcwalton): RAII.
/// FIXME(pcwalton): This isn't safe, as it allows layout to access `AbstractNode`s, and should
/// be deprecated.
pub fn with_text<R>(self, f: &fn(&Text) -> R) -> R {
self.node.with_imm_text(f)
}
/// Dumps this node tree, for debugging.
pub fn dump(&self) {
self.node.dump()
}
/// Returns a string that describes this node, for debugging.
pub fn debug_str(&self) -> ~str {
self.node.debug_str()
}
}
impl TNode<Element> for LayoutNode {
fn parent_node(&self) -> Option<LayoutNode> {
self.node.node().parent_node.map(|node| LayoutNode::new(node))
}
fn prev_sibling(&self) -> Option<LayoutNode> {
self.node.node().prev_sibling.map(|node| LayoutNode::new(node))
}
fn next_sibling(&self) -> Option<LayoutNode> {
self.node.node().next_sibling.map(|node| LayoutNode::new(node))
}
fn is_element(&self) -> bool {
match self.node.type_id() {
ElementNodeTypeId(*) => true,
_ => false
}
}
fn is_document(&self) -> bool {
match self.node.type_id() {
DocumentNodeTypeId(*) => true,
_ => false
}
}
#[inline]
fn with_element<R>(&self, f: &fn(&Element) -> R) -> R {
self.node.with_imm_element(f)
}
}
/// This is what a Node looks like if you do not know what kind of node it is. To unpack it, use /// This is what a Node looks like if you do not know what kind of node it is. To unpack it, use
/// downcast(). /// downcast().
/// ///
/// FIXME: This should be replaced with a trait once they can inherit from structs. /// FIXME: This should be replaced with a trait once they can inherit from structs.
#[deriving(Eq)] #[deriving(Eq)]
pub struct AbstractNode<View> { pub struct AbstractNode {
priv obj: *mut Box<Node<View>>, priv obj: *mut Box<Node<ScriptView>>,
} }
pub struct AbstractNodeChildrenIterator<View> { /// The script task's mutable view of a node.
priv current_node: Option<AbstractNode<View>>, pub struct ScriptView;
}
/// The layout task's mutable view of a node.
pub struct LayoutView;
/// An HTML node. /// An HTML node.
///
/// `View` describes extra data associated with this node that this task has access to. For
/// the script task, this is the unit type `()`. For the layout task, this is
/// `LayoutData`.
pub struct Node<View> { pub struct Node<View> {
/// The JavaScript reflector for this node. /// The JavaScript reflector for this node.
eventtarget: EventTarget, eventtarget: EventTarget,
@ -68,22 +192,22 @@ pub struct Node<View> {
/// The type of node that this is. /// The type of node that this is.
type_id: NodeTypeId, type_id: NodeTypeId,
abstract: Option<AbstractNode<View>>, abstract: Option<AbstractNode>,
/// The parent of this node. /// The parent of this node.
parent_node: Option<AbstractNode<View>>, parent_node: Option<AbstractNode>,
/// The first child of this node. /// The first child of this node.
first_child: Option<AbstractNode<View>>, first_child: Option<AbstractNode>,
/// The last child of this node. /// The last child of this node.
last_child: Option<AbstractNode<View>>, last_child: Option<AbstractNode>,
/// The next sibling of this node. /// The next sibling of this node.
next_sibling: Option<AbstractNode<View>>, next_sibling: Option<AbstractNode>,
/// The previous sibling of this node. /// The previous sibling of this node.
prev_sibling: Option<AbstractNode<View>>, prev_sibling: Option<AbstractNode>,
/// The document that this node belongs to. /// The document that this node belongs to.
priv owner_doc: Option<AbstractDocument>, priv owner_doc: Option<AbstractDocument>,
@ -204,68 +328,53 @@ pub enum NodeTypeId {
TextNodeTypeId, TextNodeTypeId,
} }
impl<View> Clone for AbstractNode<View> { impl Clone for AbstractNode {
fn clone(&self) -> AbstractNode<View> { fn clone(&self) -> AbstractNode {
*self *self
} }
} }
impl<View> TNode<Element> for AbstractNode<View> { impl AbstractNode {
fn parent_node(&self) -> Option<AbstractNode<View>> { pub fn node<'a>(&'a self) -> &'a Node<ScriptView> {
unsafe {
&(*self.obj).data
}
}
pub fn mut_node<'a>(&'a self) -> &'a mut Node<ScriptView> {
unsafe {
&mut (*self.obj).data
}
}
pub fn parent_node(&self) -> Option<AbstractNode> {
self.node().parent_node self.node().parent_node
} }
fn prev_sibling(&self) -> Option<AbstractNode<View>> { pub fn first_child(&self) -> Option<AbstractNode> {
self.node().prev_sibling self.node().first_child
}
fn next_sibling(&self) -> Option<AbstractNode<View>> {
self.node().next_sibling
} }
fn is_element(&self) -> bool { pub fn last_child(&self) -> Option<AbstractNode> {
self.node().last_child
}
pub fn is_element(&self) -> bool {
match self.type_id() { match self.type_id() {
ElementNodeTypeId(*) => true, ElementNodeTypeId(*) => true,
_ => false _ => false
} }
} }
fn is_document(&self) -> bool { pub fn is_document(&self) -> bool {
match self.type_id() { match self.type_id() {
DocumentNodeTypeId(*) => true, DocumentNodeTypeId(*) => true,
_ => false _ => false
} }
} }
#[inline]
fn with_element<R>(&self, f: &fn(&Element) -> R) -> R {
self.with_imm_element(f)
}
} }
impl<View> AbstractNode<View> { impl<'self> AbstractNode {
pub fn node<'a>(&'a self) -> &'a Node<View> {
unsafe {
&(*self.obj).data
}
}
pub fn mut_node<'a>(&'a self) -> &'a mut Node<View> {
unsafe {
&mut (*self.obj).data
}
}
pub fn first_child(&self) -> Option<AbstractNode<View>> {
self.node().first_child
}
pub fn last_child(&self) -> Option<AbstractNode<View>> {
self.node().last_child
}
}
impl<'self, View> AbstractNode<View> {
// Unsafe accessors // Unsafe accessors
pub unsafe fn as_cacheable_wrapper(&self) -> @mut Reflectable { pub unsafe fn as_cacheable_wrapper(&self) -> @mut Reflectable {
@ -283,20 +392,22 @@ impl<'self, View> AbstractNode<View> {
/// Allow consumers to recreate an AbstractNode from the raw boxed type. /// Allow consumers to recreate an AbstractNode from the raw boxed type.
/// Must only be used in situations where the boxed type is in the inheritance /// Must only be used in situations where the boxed type is in the inheritance
/// chain for nodes. /// chain for nodes.
pub fn from_box<T>(ptr: *mut Box<T>) -> AbstractNode<View> { ///
/// FIXME(pcwalton): Mark unsafe?
pub fn from_box<T>(ptr: *mut Box<T>) -> AbstractNode {
AbstractNode { AbstractNode {
obj: ptr as *mut Box<Node<View>> obj: ptr as *mut Box<Node<ScriptView>>
} }
} }
/// Allow consumers to upcast from derived classes. /// Allow consumers to upcast from derived classes.
pub fn from_document(doc: AbstractDocument) -> AbstractNode<View> { pub fn from_document(doc: AbstractDocument) -> AbstractNode {
unsafe { unsafe {
cast::transmute(doc) cast::transmute(doc)
} }
} }
pub fn from_eventtarget(target: AbstractEventTarget) -> AbstractNode<View> { pub fn from_eventtarget(target: AbstractEventTarget) -> AbstractNode {
assert!(target.is_node()); assert!(target.is_node());
unsafe { unsafe {
cast::transmute(target) cast::transmute(target)
@ -311,12 +422,12 @@ impl<'self, View> AbstractNode<View> {
} }
/// Returns the previous sibling of this node. Fails if this node is borrowed mutably. /// Returns the previous sibling of this node. Fails if this node is borrowed mutably.
pub fn prev_sibling(self) -> Option<AbstractNode<View>> { pub fn prev_sibling(self) -> Option<AbstractNode> {
self.node().prev_sibling self.node().prev_sibling
} }
/// Returns the next sibling of this node. Fails if this node is borrowed mutably. /// Returns the next sibling of this node. Fails if this node is borrowed mutably.
pub fn next_sibling(self) -> Option<AbstractNode<View>> { pub fn next_sibling(self) -> Option<AbstractNode> {
self.node().next_sibling self.node().next_sibling
} }
@ -326,7 +437,7 @@ impl<'self, View> AbstractNode<View> {
pub fn transmute<T, R>(self, f: &fn(&T) -> R) -> R { pub fn transmute<T, R>(self, f: &fn(&T) -> R) -> R {
unsafe { unsafe {
let node_box: *mut Box<Node<View>> = transmute(self.obj); let node_box: *mut Box<Node<ScriptView>> = transmute(self.obj);
let node = &mut (*node_box).data; let node = &mut (*node_box).data;
let old = node.abstract; let old = node.abstract;
node.abstract = Some(self); node.abstract = Some(self);
@ -339,7 +450,7 @@ impl<'self, View> AbstractNode<View> {
pub fn transmute_mut<T, R>(self, f: &fn(&mut T) -> R) -> R { pub fn transmute_mut<T, R>(self, f: &fn(&mut T) -> R) -> R {
unsafe { unsafe {
let node_box: *mut Box<Node<View>> = transmute(self.obj); let node_box: *mut Box<Node<ScriptView>> = transmute(self.obj);
let node = &mut (*node_box).data; let node = &mut (*node_box).data;
let old = node.abstract; let old = node.abstract;
node.abstract = Some(self); node.abstract = Some(self);
@ -446,13 +557,6 @@ impl<'self, View> AbstractNode<View> {
} }
} }
pub fn with_imm_image_element<R>(self, f: &fn(&HTMLImageElement) -> R) -> R {
if !self.is_image_element() {
fail!(~"node is not an image element");
}
self.transmute(f)
}
pub fn with_mut_image_element<R>(self, f: &fn(&mut HTMLImageElement) -> R) -> R { pub fn with_mut_image_element<R>(self, f: &fn(&mut HTMLImageElement) -> R) -> R {
if !self.is_image_element() { if !self.is_image_element() {
fail!(~"node is not an image element"); fail!(~"node is not an image element");
@ -464,13 +568,6 @@ impl<'self, View> AbstractNode<View> {
self.type_id() == ElementNodeTypeId(HTMLIframeElementTypeId) self.type_id() == ElementNodeTypeId(HTMLIframeElementTypeId)
} }
pub fn with_imm_iframe_element<R>(self, f: &fn(&HTMLIFrameElement) -> R) -> R {
if !self.is_iframe_element() {
fail!(~"node is not an iframe element");
}
self.transmute(f)
}
pub fn with_mut_iframe_element<R>(self, f: &fn(&mut HTMLIFrameElement) -> R) -> R { pub fn with_mut_iframe_element<R>(self, f: &fn(&mut HTMLIFrameElement) -> R) -> R {
if !self.is_iframe_element() { if !self.is_iframe_element() {
fail!(~"node is not an iframe element"); fail!(~"node is not an iframe element");
@ -486,11 +583,11 @@ impl<'self, View> AbstractNode<View> {
self.type_id() == ElementNodeTypeId(HTMLAnchorElementTypeId) self.type_id() == ElementNodeTypeId(HTMLAnchorElementTypeId)
} }
pub unsafe fn raw_object(self) -> *mut Box<Node<View>> { pub unsafe fn raw_object(self) -> *mut Box<Node<ScriptView>> {
self.obj self.obj
} }
pub fn from_raw(raw: *mut Box<Node<View>>) -> AbstractNode<View> { pub fn from_raw(raw: *mut Box<Node<ScriptView>>) -> AbstractNode {
AbstractNode { AbstractNode {
obj: raw obj: raw
} }
@ -530,7 +627,7 @@ impl<'self, View> AbstractNode<View> {
self.first_child().is_none() self.first_child().is_none()
} }
pub fn children(&self) -> AbstractNodeChildrenIterator<View> { pub fn children(&self) -> AbstractNodeChildrenIterator {
self.node().children() self.node().children()
} }
@ -539,12 +636,12 @@ impl<'self, View> AbstractNode<View> {
} }
} }
impl AbstractNode<ScriptView> { impl AbstractNode {
pub fn AppendChild(self, node: AbstractNode<ScriptView>) -> Fallible<AbstractNode<ScriptView>> { pub fn AppendChild(self, node: AbstractNode) -> Fallible<AbstractNode> {
self.node().AppendChild(self, node) self.node().AppendChild(self, node)
} }
pub fn RemoveChild(self, node: AbstractNode<ScriptView>) -> Fallible<AbstractNode<ScriptView>> { pub fn RemoveChild(self, node: AbstractNode) -> Fallible<AbstractNode> {
self.node().RemoveChild(self, node) self.node().RemoveChild(self, node)
} }
@ -577,9 +674,7 @@ impl AbstractNode<ScriptView> {
/// Adds a new child to the end of this node's list of children. /// Adds a new child to the end of this node's list of children.
/// ///
/// Fails unless `new_child` is disconnected from the tree. /// Fails unless `new_child` is disconnected from the tree.
fn add_child(&self, fn add_child(&self, new_child: AbstractNode, before: Option<AbstractNode>) {
new_child: AbstractNode<ScriptView>,
before: Option<AbstractNode<ScriptView>>) {
let this_node = self.mut_node(); let this_node = self.mut_node();
let new_child_node = new_child.mut_node(); let new_child_node = new_child.mut_node();
assert!(new_child_node.parent_node.is_none()); assert!(new_child_node.parent_node.is_none());
@ -626,7 +721,7 @@ impl AbstractNode<ScriptView> {
/// Removes the given child from this node's list of children. /// Removes the given child from this node's list of children.
/// ///
/// Fails unless `child` is a child of this node. (FIXME: This is not yet checked.) /// Fails unless `child` is a child of this node. (FIXME: This is not yet checked.)
fn remove_child(&self, child: AbstractNode<ScriptView>) { fn remove_child(&self, child: AbstractNode) {
let this_node = self.mut_node(); let this_node = self.mut_node();
let child_node = child.mut_node(); let child_node = child.mut_node();
assert!(child_node.parent_node.is_some()); assert!(child_node.parent_node.is_some());
@ -656,27 +751,27 @@ impl AbstractNode<ScriptView> {
// Low-level pointer stitching wrappers // Low-level pointer stitching wrappers
// //
fn set_parent_node(&self, new_parent_node: Option<AbstractNode<ScriptView>>) { fn set_parent_node(&self, new_parent_node: Option<AbstractNode>) {
let node = self.mut_node(); let node = self.mut_node();
node.set_parent_node(new_parent_node) node.set_parent_node(new_parent_node)
} }
fn set_first_child(&self, new_first_child: Option<AbstractNode<ScriptView>>) { fn set_first_child(&self, new_first_child: Option<AbstractNode>) {
let node = self.mut_node(); let node = self.mut_node();
node.set_first_child(new_first_child) node.set_first_child(new_first_child)
} }
fn set_last_child(&self, new_last_child: Option<AbstractNode<ScriptView>>) { fn set_last_child(&self, new_last_child: Option<AbstractNode>) {
let node = self.mut_node(); let node = self.mut_node();
node.set_last_child(new_last_child) node.set_last_child(new_last_child)
} }
fn set_prev_sibling(&self, new_prev_sibling: Option<AbstractNode<ScriptView>>) { fn set_prev_sibling(&self, new_prev_sibling: Option<AbstractNode>) {
let node = self.mut_node(); let node = self.mut_node();
node.set_prev_sibling(new_prev_sibling) node.set_prev_sibling(new_prev_sibling)
} }
fn set_next_sibling(&self, new_next_sibling: Option<AbstractNode<ScriptView>>) { fn set_next_sibling(&self, new_next_sibling: Option<AbstractNode>) {
let node = self.mut_node(); let node = self.mut_node();
node.set_next_sibling(new_next_sibling) node.set_next_sibling(new_next_sibling)
} }
@ -686,8 +781,12 @@ impl AbstractNode<ScriptView> {
// Iteration and traversal // Iteration and traversal
// //
impl<View> Iterator<AbstractNode<View>> for AbstractNodeChildrenIterator<View> { pub struct AbstractNodeChildrenIterator {
fn next(&mut self) -> Option<AbstractNode<View>> { priv current_node: Option<AbstractNode>,
}
impl Iterator<AbstractNode> for AbstractNodeChildrenIterator {
fn next(&mut self) -> Option<AbstractNode> {
let node = self.current_node; let node = self.current_node;
self.current_node = do self.current_node.and_then |node| { self.current_node = do self.current_node.and_then |node| {
node.next_sibling() node.next_sibling()
@ -696,12 +795,26 @@ impl<View> Iterator<AbstractNode<View>> for AbstractNodeChildrenIterator<View> {
} }
} }
pub struct AncestorIterator<View> { pub struct LayoutNodeChildrenIterator {
priv current: Option<AbstractNode<View>>, priv current_node: Option<LayoutNode>,
} }
impl<View> Iterator<AbstractNode<View>> for AncestorIterator<View> { impl Iterator<LayoutNode> for LayoutNodeChildrenIterator {
fn next(&mut self) -> Option<AbstractNode<View>> { fn next(&mut self) -> Option<LayoutNode> {
let node = self.current_node;
self.current_node = do self.current_node.and_then |node| {
node.next_sibling()
};
node
}
}
pub struct AncestorIterator {
priv current: Option<AbstractNode>,
}
impl Iterator<AbstractNode> for AncestorIterator {
fn next(&mut self) -> Option<AbstractNode> {
if self.current.is_none() { if self.current.is_none() {
return None; return None;
} }
@ -715,13 +828,13 @@ impl<View> Iterator<AbstractNode<View>> for AncestorIterator<View> {
// FIXME: Do this without precomputing a vector of refs. // FIXME: Do this without precomputing a vector of refs.
// Easy for preorder; harder for postorder. // Easy for preorder; harder for postorder.
pub struct TreeIterator<View> { pub struct TreeIterator {
priv nodes: ~[AbstractNode<View>], priv nodes: ~[AbstractNode],
priv index: uint, priv index: uint,
} }
impl<View> TreeIterator<View> { impl TreeIterator {
fn new(nodes: ~[AbstractNode<View>]) -> TreeIterator<View> { fn new(nodes: ~[AbstractNode]) -> TreeIterator {
TreeIterator { TreeIterator {
nodes: nodes, nodes: nodes,
index: 0, index: 0,
@ -729,8 +842,8 @@ impl<View> TreeIterator<View> {
} }
} }
impl<View> Iterator<AbstractNode<View>> for TreeIterator<View> { impl Iterator<AbstractNode> for TreeIterator {
fn next(&mut self) -> Option<AbstractNode<View>> { fn next(&mut self) -> Option<AbstractNode> {
if self.index >= self.nodes.len() { if self.index >= self.nodes.len() {
None None
} else { } else {
@ -741,37 +854,80 @@ impl<View> Iterator<AbstractNode<View>> for TreeIterator<View> {
} }
} }
fn gather<View>(cur: &AbstractNode<View>, refs: &mut ~[AbstractNode<View>], postorder: bool) { fn gather_abstract_nodes(cur: &AbstractNode, refs: &mut ~[AbstractNode], postorder: bool) {
if !postorder { if !postorder {
refs.push(cur.clone()); refs.push(cur.clone());
} }
for kid in cur.children() { for kid in cur.children() {
gather(&kid, refs, postorder) gather_abstract_nodes(&kid, refs, postorder)
} }
if postorder { if postorder {
refs.push(cur.clone()); refs.push(cur.clone());
} }
} }
impl<View> AbstractNode<View> { // FIXME: Do this without precomputing a vector of refs.
// Easy for preorder; harder for postorder.
//
// FIXME(pcwalton): Parallelism! Eventually this should just be nuked.
pub struct LayoutTreeIterator {
priv nodes: ~[LayoutNode],
priv index: uint,
}
impl LayoutTreeIterator {
fn new(nodes: ~[LayoutNode]) -> LayoutTreeIterator {
LayoutTreeIterator {
nodes: nodes,
index: 0,
}
}
}
impl Iterator<LayoutNode> for LayoutTreeIterator {
fn next(&mut self) -> Option<LayoutNode> {
if self.index >= self.nodes.len() {
None
} else {
let v = self.nodes[self.index].clone();
self.index += 1;
Some(v)
}
}
}
/// FIXME(pcwalton): This is super inefficient.
fn gather_layout_nodes(cur: &LayoutNode, refs: &mut ~[LayoutNode], postorder: bool) {
if !postorder {
refs.push(cur.clone());
}
for kid in cur.children() {
gather_layout_nodes(&kid, refs, postorder)
}
if postorder {
refs.push(cur.clone());
}
}
impl AbstractNode {
/// Iterates over all ancestors of this node. /// Iterates over all ancestors of this node.
pub fn ancestors(&self) -> AncestorIterator<View> { pub fn ancestors(&self) -> AncestorIterator {
AncestorIterator { AncestorIterator {
current: self.parent_node(), current: self.parent_node(),
} }
} }
/// Iterates over this node and all its descendants, in preorder. /// Iterates over this node and all its descendants, in preorder.
pub fn traverse_preorder(&self) -> TreeIterator<View> { pub fn traverse_preorder(&self) -> TreeIterator {
let mut nodes = ~[]; let mut nodes = ~[];
gather(self, &mut nodes, false); gather_abstract_nodes(self, &mut nodes, false);
TreeIterator::new(nodes) TreeIterator::new(nodes)
} }
/// Iterates over this node and all its descendants, in postorder. /// Iterates over this node and all its descendants, in postorder.
pub fn sequential_traverse_postorder(&self) -> TreeIterator<View> { pub fn sequential_traverse_postorder(&self) -> TreeIterator {
let mut nodes = ~[]; let mut nodes = ~[];
gather(self, &mut nodes, true); gather_abstract_nodes(self, &mut nodes, true);
TreeIterator::new(nodes) TreeIterator::new(nodes)
} }
} }
@ -780,24 +936,24 @@ impl<View> Node<View> {
pub fn owner_doc(&self) -> AbstractDocument { pub fn owner_doc(&self) -> AbstractDocument {
self.owner_doc.unwrap() self.owner_doc.unwrap()
} }
}
impl Node<ScriptView> {
pub fn set_owner_doc(&mut self, document: AbstractDocument) { pub fn set_owner_doc(&mut self, document: AbstractDocument) {
self.owner_doc = Some(document); self.owner_doc = Some(document);
} }
pub fn children(&self) -> AbstractNodeChildrenIterator<View> { pub fn children(&self) -> AbstractNodeChildrenIterator {
AbstractNodeChildrenIterator { AbstractNodeChildrenIterator {
current_node: self.first_child, current_node: self.first_child,
} }
} }
}
impl Node<ScriptView> {
pub fn reflect_node<N: Reflectable> pub fn reflect_node<N: Reflectable>
(node: @mut N, (node: @mut N,
document: AbstractDocument, document: AbstractDocument,
wrap_fn: extern "Rust" fn(*JSContext, *JSObject, @mut N) -> *JSObject) wrap_fn: extern "Rust" fn(*JSContext, *JSObject, @mut N) -> *JSObject)
-> AbstractNode<ScriptView> { -> AbstractNode {
assert!(node.reflector().get_jsobject().is_null()); assert!(node.reflector().get_jsobject().is_null());
let node = reflect_dom_object(node, document.document().window, wrap_fn); let node = reflect_dom_object(node, document.document().window, wrap_fn);
assert!(node.reflector().get_jsobject().is_not_null()); assert!(node.reflector().get_jsobject().is_not_null());
@ -860,7 +1016,7 @@ impl Node<ScriptView> {
} }
} }
pub fn NodeName(&self, abstract_self: AbstractNode<ScriptView>) -> DOMString { pub fn NodeName(&self, abstract_self: AbstractNode) -> DOMString {
match self.type_id { match self.type_id {
ElementNodeTypeId(*) => { ElementNodeTypeId(*) => {
do abstract_self.with_imm_element |element| { do abstract_self.with_imm_element |element| {
@ -894,11 +1050,11 @@ impl Node<ScriptView> {
} }
} }
pub fn GetParentNode(&self) -> Option<AbstractNode<ScriptView>> { pub fn GetParentNode(&self) -> Option<AbstractNode> {
self.parent_node self.parent_node
} }
pub fn GetParentElement(&self) -> Option<AbstractNode<ScriptView>> { pub fn GetParentElement(&self) -> Option<AbstractNode> {
self.parent_node.filtered(|parent| parent.is_element()) self.parent_node.filtered(|parent| parent.is_element())
} }
@ -906,23 +1062,23 @@ impl Node<ScriptView> {
self.first_child.is_some() self.first_child.is_some()
} }
pub fn GetFirstChild(&self) -> Option<AbstractNode<ScriptView>> { pub fn GetFirstChild(&self) -> Option<AbstractNode> {
self.first_child self.first_child
} }
pub fn GetLastChild(&self) -> Option<AbstractNode<ScriptView>> { pub fn GetLastChild(&self) -> Option<AbstractNode> {
self.last_child self.last_child
} }
pub fn GetPreviousSibling(&self) -> Option<AbstractNode<ScriptView>> { pub fn GetPreviousSibling(&self) -> Option<AbstractNode> {
self.prev_sibling self.prev_sibling
} }
pub fn GetNextSibling(&self) -> Option<AbstractNode<ScriptView>> { pub fn GetNextSibling(&self) -> Option<AbstractNode> {
self.next_sibling self.next_sibling
} }
pub fn GetNodeValue(&self, abstract_self: AbstractNode<ScriptView>) -> Option<DOMString> { pub fn GetNodeValue(&self, abstract_self: AbstractNode) -> Option<DOMString> {
match self.type_id { match self.type_id {
// ProcessingInstruction // ProcessingInstruction
CommentNodeTypeId | TextNodeTypeId => { CommentNodeTypeId | TextNodeTypeId => {
@ -936,11 +1092,12 @@ impl Node<ScriptView> {
} }
} }
pub fn SetNodeValue(&mut self, _abstract_self: AbstractNode<ScriptView>, _val: Option<DOMString>) -> ErrorResult { pub fn SetNodeValue(&mut self, _abstract_self: AbstractNode, _val: Option<DOMString>)
-> ErrorResult {
Ok(()) Ok(())
} }
pub fn GetTextContent(&self, abstract_self: AbstractNode<ScriptView>) -> Option<DOMString> { pub fn GetTextContent(&self, abstract_self: AbstractNode) -> Option<DOMString> {
match self.type_id { match self.type_id {
DocumentFragmentNodeTypeId | ElementNodeTypeId(*) => { DocumentFragmentNodeTypeId | ElementNodeTypeId(*) => {
let mut content = ~""; let mut content = ~"";
@ -964,7 +1121,7 @@ impl Node<ScriptView> {
} }
} }
pub fn ChildNodes(&mut self, abstract_self: AbstractNode<ScriptView>) -> @mut NodeList { pub fn ChildNodes(&mut self, abstract_self: AbstractNode) -> @mut NodeList {
match self.child_list { match self.child_list {
None => { None => {
let window = self.owner_doc().document().window; let window = self.owner_doc().document().window;
@ -977,7 +1134,7 @@ impl Node<ScriptView> {
} }
// http://dom.spec.whatwg.org/#concept-node-adopt // http://dom.spec.whatwg.org/#concept-node-adopt
fn adopt(node: AbstractNode<ScriptView>, document: AbstractDocument) { fn adopt(node: AbstractNode, document: AbstractDocument) {
// Step 1. // Step 1.
match node.parent_node() { match node.parent_node() {
Some(parent) => Node::remove(node, parent, false), Some(parent) => Node::remove(node, parent, false),
@ -996,11 +1153,9 @@ impl Node<ScriptView> {
} }
// http://dom.spec.whatwg.org/#concept-node-pre-insert // http://dom.spec.whatwg.org/#concept-node-pre-insert
fn pre_insert(node: AbstractNode<ScriptView>, fn pre_insert(node: AbstractNode, parent: AbstractNode, child: Option<AbstractNode>)
parent: AbstractNode<ScriptView>, -> Fallible<AbstractNode> {
child: Option<AbstractNode<ScriptView>>) -> Fallible<AbstractNode<ScriptView>> { fn is_inclusive_ancestor_of(node: AbstractNode, parent: AbstractNode) -> bool {
fn is_inclusive_ancestor_of(node: AbstractNode<ScriptView>,
parent: AbstractNode<ScriptView>) -> bool {
node == parent || parent.ancestors().any(|ancestor| ancestor == node) node == parent || parent.ancestors().any(|ancestor| ancestor == node)
} }
@ -1060,7 +1215,7 @@ impl Node<ScriptView> {
// Step 6. // Step 6.
match parent.type_id() { match parent.type_id() {
DocumentNodeTypeId(_) => { DocumentNodeTypeId(_) => {
fn inclusively_followed_by_doctype(child: Option<AbstractNode<ScriptView>>) -> bool{ fn inclusively_followed_by_doctype(child: Option<AbstractNode>) -> bool{
match child { match child {
Some(child) if child.is_doctype() => true, Some(child) if child.is_doctype() => true,
Some(child) => { Some(child) => {
@ -1159,9 +1314,9 @@ impl Node<ScriptView> {
} }
// http://dom.spec.whatwg.org/#concept-node-insert // http://dom.spec.whatwg.org/#concept-node-insert
fn insert(node: AbstractNode<ScriptView>, fn insert(node: AbstractNode,
parent: AbstractNode<ScriptView>, parent: AbstractNode,
child: Option<AbstractNode<ScriptView>>, child: Option<AbstractNode>,
suppress_observers: bool) { suppress_observers: bool) {
// XXX assert owner_doc // XXX assert owner_doc
// Step 1-3: ranges. // Step 1-3: ranges.
@ -1198,8 +1353,7 @@ impl Node<ScriptView> {
} }
// http://dom.spec.whatwg.org/#concept-node-replace-all // http://dom.spec.whatwg.org/#concept-node-replace-all
pub fn replace_all(node: Option<AbstractNode<ScriptView>>, pub fn replace_all(node: Option<AbstractNode>, parent: AbstractNode) {
parent: AbstractNode<ScriptView>) {
// Step 1. // Step 1.
match node { match node {
Some(node) => Node::adopt(node, parent.node().owner_doc()), Some(node) => Node::adopt(node, parent.node().owner_doc()),
@ -1207,7 +1361,7 @@ impl Node<ScriptView> {
} }
// Step 2. // Step 2.
let removedNodes: ~[AbstractNode<ScriptView>] = parent.children().collect(); let removedNodes: ~[AbstractNode] = parent.children().collect();
// Step 3. // Step 3.
let addedNodes = match node { let addedNodes = match node {
@ -1241,8 +1395,7 @@ impl Node<ScriptView> {
} }
// http://dom.spec.whatwg.org/#concept-node-pre-remove // http://dom.spec.whatwg.org/#concept-node-pre-remove
fn pre_remove(child: AbstractNode<ScriptView>, fn pre_remove(child: AbstractNode, parent: AbstractNode) -> Fallible<AbstractNode> {
parent: AbstractNode<ScriptView>) -> Fallible<AbstractNode<ScriptView>> {
// Step 1. // Step 1.
if child.parent_node() != Some(parent) { if child.parent_node() != Some(parent) {
return Err(NotFound); return Err(NotFound);
@ -1256,9 +1409,7 @@ impl Node<ScriptView> {
} }
// http://dom.spec.whatwg.org/#concept-node-remove // http://dom.spec.whatwg.org/#concept-node-remove
fn remove(node: AbstractNode<ScriptView>, fn remove(node: AbstractNode, parent: AbstractNode, suppress_observers: bool) {
parent: AbstractNode<ScriptView>,
suppress_observers: bool) {
assert!(node.parent_node() == Some(parent)); assert!(node.parent_node() == Some(parent));
// Step 1-5: ranges. // Step 1-5: ranges.
@ -1273,9 +1424,8 @@ impl Node<ScriptView> {
} }
} }
pub fn SetTextContent(&mut self, pub fn SetTextContent(&mut self, abstract_self: AbstractNode, value: Option<DOMString>)
abstract_self: AbstractNode<ScriptView>, -> ErrorResult {
value: Option<DOMString>) -> ErrorResult {
let value = null_str_as_empty(&value); let value = null_str_as_empty(&value);
match self.type_id { match self.type_id {
DocumentFragmentNodeTypeId | ElementNodeTypeId(*) => { DocumentFragmentNodeTypeId | ElementNodeTypeId(*) => {
@ -1305,9 +1455,8 @@ impl Node<ScriptView> {
Ok(()) Ok(())
} }
pub fn InsertBefore(&self, pub fn InsertBefore(&self, node: AbstractNode, child: Option<AbstractNode>)
node: AbstractNode<ScriptView>, -> Fallible<AbstractNode> {
child: Option<AbstractNode<ScriptView>>) -> Fallible<AbstractNode<ScriptView>> {
Node::pre_insert(node, node, child) Node::pre_insert(node, node, child)
} }
@ -1316,38 +1465,37 @@ impl Node<ScriptView> {
document.document().wait_until_safe_to_modify_dom(); document.document().wait_until_safe_to_modify_dom();
} }
pub fn AppendChild(&self, pub fn AppendChild(&self, abstract_self: AbstractNode, node: AbstractNode)
abstract_self: AbstractNode<ScriptView>, -> Fallible<AbstractNode> {
node: AbstractNode<ScriptView>) -> Fallible<AbstractNode<ScriptView>> {
Node::pre_insert(node, abstract_self, None) Node::pre_insert(node, abstract_self, None)
} }
pub fn ReplaceChild(&mut self, _node: AbstractNode<ScriptView>, _child: AbstractNode<ScriptView>) -> Fallible<AbstractNode<ScriptView>> { pub fn ReplaceChild(&mut self, _node: AbstractNode, _child: AbstractNode)
-> Fallible<AbstractNode> {
fail!("stub") fail!("stub")
} }
pub fn RemoveChild(&self, pub fn RemoveChild(&self, abstract_self: AbstractNode, node: AbstractNode)
abstract_self: AbstractNode<ScriptView>, -> Fallible<AbstractNode> {
node: AbstractNode<ScriptView>) -> Fallible<AbstractNode<ScriptView>> {
Node::pre_remove(node, abstract_self) Node::pre_remove(node, abstract_self)
} }
pub fn Normalize(&mut self) { pub fn Normalize(&mut self) {
} }
pub fn CloneNode(&self, _deep: bool) -> Fallible<AbstractNode<ScriptView>> { pub fn CloneNode(&self, _deep: bool) -> Fallible<AbstractNode> {
fail!("stub") fail!("stub")
} }
pub fn IsEqualNode(&self, _node: Option<AbstractNode<ScriptView>>) -> bool { pub fn IsEqualNode(&self, _node: Option<AbstractNode>) -> bool {
false false
} }
pub fn CompareDocumentPosition(&self, _other: AbstractNode<ScriptView>) -> u16 { pub fn CompareDocumentPosition(&self, _other: AbstractNode) -> u16 {
0 0
} }
pub fn Contains(&self, _other: Option<AbstractNode<ScriptView>>) -> bool { pub fn Contains(&self, _other: Option<AbstractNode>) -> bool {
false false
} }
@ -1384,31 +1532,31 @@ impl Node<ScriptView> {
// Low-level pointer stitching // Low-level pointer stitching
// //
pub fn set_parent_node(&mut self, new_parent_node: Option<AbstractNode<ScriptView>>) { pub fn set_parent_node(&mut self, new_parent_node: Option<AbstractNode>) {
let doc = self.owner_doc(); let doc = self.owner_doc();
doc.document().wait_until_safe_to_modify_dom(); doc.document().wait_until_safe_to_modify_dom();
self.parent_node = new_parent_node self.parent_node = new_parent_node
} }
pub fn set_first_child(&mut self, new_first_child: Option<AbstractNode<ScriptView>>) { pub fn set_first_child(&mut self, new_first_child: Option<AbstractNode>) {
let doc = self.owner_doc(); let doc = self.owner_doc();
doc.document().wait_until_safe_to_modify_dom(); doc.document().wait_until_safe_to_modify_dom();
self.first_child = new_first_child self.first_child = new_first_child
} }
pub fn set_last_child(&mut self, new_last_child: Option<AbstractNode<ScriptView>>) { pub fn set_last_child(&mut self, new_last_child: Option<AbstractNode>) {
let doc = self.owner_doc(); let doc = self.owner_doc();
doc.document().wait_until_safe_to_modify_dom(); doc.document().wait_until_safe_to_modify_dom();
self.last_child = new_last_child self.last_child = new_last_child
} }
pub fn set_prev_sibling(&mut self, new_prev_sibling: Option<AbstractNode<ScriptView>>) { pub fn set_prev_sibling(&mut self, new_prev_sibling: Option<AbstractNode>) {
let doc = self.owner_doc(); let doc = self.owner_doc();
doc.document().wait_until_safe_to_modify_dom(); doc.document().wait_until_safe_to_modify_dom();
self.prev_sibling = new_prev_sibling self.prev_sibling = new_prev_sibling
} }
pub fn set_next_sibling(&mut self, new_next_sibling: Option<AbstractNode<ScriptView>>) { pub fn set_next_sibling(&mut self, new_next_sibling: Option<AbstractNode>) {
let doc = self.owner_doc(); let doc = self.owner_doc();
doc.document().wait_until_safe_to_modify_dom(); doc.document().wait_until_safe_to_modify_dom();
self.next_sibling = new_next_sibling self.next_sibling = new_next_sibling
@ -1428,12 +1576,12 @@ impl Reflectable for Node<ScriptView> {
/// A bottom-up, parallelizable traversal. /// A bottom-up, parallelizable traversal.
pub trait PostorderNodeTraversal { pub trait PostorderNodeTraversal {
/// The operation to perform. Return true to continue or false to stop. /// The operation to perform. Return true to continue or false to stop.
fn process(&self, node: AbstractNode<LayoutView>) -> bool; fn process(&self, node: LayoutNode) -> bool;
/// Returns true if this node should be pruned. If this returns true, we skip the operation /// Returns true if this node should be pruned. If this returns true, we skip the operation
/// entirely and do not process any descendant nodes. This is called *before* child nodes are /// entirely and do not process any descendant nodes. This is called *before* child nodes are
/// visited. The default implementation never prunes any nodes. /// visited. The default implementation never prunes any nodes.
fn should_prune(&self, _node: AbstractNode<LayoutView>) -> bool { fn should_prune(&self, _node: LayoutNode) -> bool {
false false
} }
} }
@ -1441,18 +1589,17 @@ pub trait PostorderNodeTraversal {
/// A bottom-up, parallelizable traversal. /// A bottom-up, parallelizable traversal.
pub trait PostorderNodeMutTraversal { pub trait PostorderNodeMutTraversal {
/// The operation to perform. Return true to continue or false to stop. /// The operation to perform. Return true to continue or false to stop.
fn process(&mut self, node: AbstractNode<LayoutView>) -> bool; fn process(&mut self, node: LayoutNode) -> bool;
/// Returns true if this node should be pruned. If this returns true, we skip the operation /// Returns true if this node should be pruned. If this returns true, we skip the operation
/// entirely and do not process any descendant nodes. This is called *before* child nodes are /// entirely and do not process any descendant nodes. This is called *before* child nodes are
/// visited. The default implementation never prunes any nodes. /// visited. The default implementation never prunes any nodes.
fn should_prune(&self, _node: AbstractNode<LayoutView>) -> bool { fn should_prune(&self, _node: LayoutNode) -> bool {
false false
} }
} }
impl LayoutNode {
impl AbstractNode<LayoutView> {
/// Traverses the tree in postorder. /// Traverses the tree in postorder.
/// ///
/// TODO(pcwalton): Offer a parallel version with a compatible API. /// TODO(pcwalton): Offer a parallel version with a compatible API.

View file

@ -4,12 +4,12 @@
use dom::bindings::codegen::NodeListBinding; use dom::bindings::codegen::NodeListBinding;
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object}; use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::node::{AbstractNode, ScriptView}; use dom::node::AbstractNode;
use dom::window::Window; use dom::window::Window;
enum NodeListType { enum NodeListType {
Simple(~[AbstractNode<ScriptView>]), Simple(~[AbstractNode]),
Children(AbstractNode<ScriptView>) Children(AbstractNode)
} }
pub struct NodeList { pub struct NodeList {
@ -34,11 +34,11 @@ impl NodeList {
window, NodeListBinding::Wrap) window, NodeListBinding::Wrap)
} }
pub fn new_simple_list(window: @mut Window, elements: ~[AbstractNode<ScriptView>]) -> @mut NodeList { pub fn new_simple_list(window: @mut Window, elements: ~[AbstractNode]) -> @mut NodeList {
NodeList::new(window, Simple(elements)) NodeList::new(window, Simple(elements))
} }
pub fn new_child_list(window: @mut Window, node: AbstractNode<ScriptView>) -> @mut NodeList { pub fn new_child_list(window: @mut Window, node: AbstractNode) -> @mut NodeList {
NodeList::new(window, Children(node)) NodeList::new(window, Children(node))
} }
@ -49,7 +49,7 @@ impl NodeList {
} }
} }
pub fn Item(&self, index: u32) -> Option<AbstractNode<ScriptView>> { pub fn Item(&self, index: u32) -> Option<AbstractNode> {
match self.list_type { match self.list_type {
_ if index >= self.Length() => None, _ if index >= self.Length() => None,
Simple(ref elems) => Some(elems[index]), Simple(ref elems) => Some(elems[index]),
@ -57,7 +57,7 @@ impl NodeList {
} }
} }
pub fn IndexedGetter(&self, index: u32, found: &mut bool) -> Option<AbstractNode<ScriptView>> { pub fn IndexedGetter(&self, index: u32, found: &mut bool) -> Option<AbstractNode> {
let item = self.Item(index); let item = self.Item(index);
*found = item.is_some(); *found = item.is_some();
item item

View file

@ -6,7 +6,7 @@ use dom::bindings::codegen::TextBinding;
use dom::bindings::utils::{DOMString, Fallible}; use dom::bindings::utils::{DOMString, Fallible};
use dom::characterdata::CharacterData; use dom::characterdata::CharacterData;
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::node::{AbstractNode, ScriptView, Node, TextNodeTypeId}; use dom::node::{AbstractNode, Node, TextNodeTypeId};
use dom::window::Window; use dom::window::Window;
/// An HTML text node. /// An HTML text node.
@ -21,16 +21,16 @@ impl Text {
} }
} }
pub fn new(text: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn new(text: ~str, document: AbstractDocument) -> AbstractNode {
let node = Text::new_inherited(text, document); let node = Text::new_inherited(text, document);
Node::reflect_node(@mut node, document, TextBinding::Wrap) Node::reflect_node(@mut node, document, TextBinding::Wrap)
} }
pub fn Constructor(owner: @mut Window, text: DOMString) -> Fallible<AbstractNode<ScriptView>> { pub fn Constructor(owner: @mut Window, text: DOMString) -> Fallible<AbstractNode> {
Ok(Text::new(text.clone(), owner.Document())) Ok(Text::new(text.clone(), owner.Document()))
} }
pub fn SplitText(&self, _offset: u32) -> Fallible<AbstractNode<ScriptView>> { pub fn SplitText(&self, _offset: u32) -> Fallible<AbstractNode> {
fail!("unimplemented") fail!("unimplemented")
} }

View file

@ -5,7 +5,7 @@
use dom::bindings::codegen::UIEventBinding; use dom::bindings::codegen::UIEventBinding;
use dom::bindings::utils::{DOMString, Fallible}; use dom::bindings::utils::{DOMString, Fallible};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object}; use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::node::{AbstractNode, ScriptView}; use dom::node::AbstractNode;
use dom::event::{AbstractEvent, Event, EventTypeId, UIEventTypeId}; use dom::event::{AbstractEvent, Event, EventTypeId, UIEventTypeId};
use dom::window::Window; use dom::window::Window;
use dom::windowproxy::WindowProxy; use dom::windowproxy::WindowProxy;
@ -85,7 +85,7 @@ impl UIEvent {
0 0
} }
pub fn GetRangeParent(&self) -> Option<AbstractNode<ScriptView>> { pub fn GetRangeParent(&self) -> Option<AbstractNode> {
//TODO //TODO
None None
} }

View file

@ -8,7 +8,7 @@ use dom::bindings::utils::{trace_option, trace_reflector};
use dom::bindings::utils::DOMString; use dom::bindings::utils::DOMString;
use dom::document::AbstractDocument; use dom::document::AbstractDocument;
use dom::eventtarget::{EventTarget, WindowTypeId}; use dom::eventtarget::{EventTarget, WindowTypeId};
use dom::node::{AbstractNode, ScriptView}; use dom::node::AbstractNode;
use dom::location::Location; use dom::location::Location;
use dom::navigator::Navigator; use dom::navigator::Navigator;
@ -114,7 +114,7 @@ impl Window {
pub fn Blur(&self) { pub fn Blur(&self) {
} }
pub fn GetFrameElement(&self) -> Option<AbstractNode<ScriptView>> { pub fn GetFrameElement(&self) -> Option<AbstractNode> {
None None
} }

View file

@ -9,7 +9,7 @@ use dom::htmlheadingelement::{Heading1, Heading2, Heading3, Heading4, Heading5,
use dom::htmliframeelement::IFrameSize; use dom::htmliframeelement::IFrameSize;
use dom::htmlformelement::HTMLFormElement; use dom::htmlformelement::HTMLFormElement;
use dom::namespace; use dom::namespace;
use dom::node::{AbstractNode, ElementNodeTypeId, ScriptView}; use dom::node::{AbstractNode, ElementNodeTypeId};
use dom::types::*; use dom::types::*;
use html::cssparse::{InlineProvenance, StylesheetProvenance, UrlProvenance, spawn_css_parser}; use html::cssparse::{InlineProvenance, StylesheetProvenance, UrlProvenance, spawn_css_parser};
use script_task::page_from_context; use script_task::page_from_context;
@ -77,11 +77,11 @@ trait NodeWrapping {
unsafe fn from_hubbub_node(n: hubbub::NodeDataPtr) -> Self; unsafe fn from_hubbub_node(n: hubbub::NodeDataPtr) -> Self;
} }
impl NodeWrapping for AbstractNode<ScriptView> { impl NodeWrapping for AbstractNode {
unsafe fn to_hubbub_node(self) -> hubbub::NodeDataPtr { unsafe fn to_hubbub_node(self) -> hubbub::NodeDataPtr {
cast::transmute(self) cast::transmute(self)
} }
unsafe fn from_hubbub_node(n: hubbub::NodeDataPtr) -> AbstractNode<ScriptView> { unsafe fn from_hubbub_node(n: hubbub::NodeDataPtr) -> AbstractNode {
cast::transmute(n) cast::transmute(n)
} }
} }
@ -159,7 +159,7 @@ fn js_script_listener(to_parent: SharedChan<HtmlDiscoveryMessage>,
// Silly macros to handle constructing DOM nodes. This produces bad code and should be optimized // Silly macros to handle constructing DOM nodes. This produces bad code and should be optimized
// via atomization (issue #85). // via atomization (issue #85).
pub fn build_element_from_tag(tag: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> { pub fn build_element_from_tag(tag: ~str, document: AbstractDocument) -> AbstractNode {
// TODO (Issue #85): use atoms // TODO (Issue #85): use atoms
handle_element!(document, tag, "a", HTMLAnchorElement); handle_element!(document, tag, "a", HTMLAnchorElement);
handle_element!(document, tag, "applet", HTMLAppletElement); handle_element!(document, tag, "applet", HTMLAppletElement);
@ -299,7 +299,7 @@ pub fn parse_html(cx: *JSContext,
let mut parser = hubbub::Parser("UTF-8", false); let mut parser = hubbub::Parser("UTF-8", false);
debug!("created parser"); debug!("created parser");
let document_node = AbstractNode::<ScriptView>::from_document(document); let document_node = AbstractNode::from_document(document);
parser.set_document_node(unsafe { document_node.to_hubbub_node() }); parser.set_document_node(unsafe { document_node.to_hubbub_node() });
parser.enable_scripting(true); parser.enable_scripting(true);
parser.enable_styling(true); parser.enable_styling(true);
@ -415,8 +415,8 @@ pub fn parse_html(cx: *JSContext,
append_child: |parent: hubbub::NodeDataPtr, child: hubbub::NodeDataPtr| { append_child: |parent: hubbub::NodeDataPtr, child: hubbub::NodeDataPtr| {
unsafe { unsafe {
debug!("append child {:x} {:x}", parent, child); debug!("append child {:x} {:x}", parent, child);
let parent: AbstractNode<ScriptView> = NodeWrapping::from_hubbub_node(parent); let parent: AbstractNode = NodeWrapping::from_hubbub_node(parent);
let child: AbstractNode<ScriptView> = NodeWrapping::from_hubbub_node(child); let child: AbstractNode = NodeWrapping::from_hubbub_node(child);
parent.AppendChild(child); parent.AppendChild(child);
} }
child child
@ -460,7 +460,7 @@ pub fn parse_html(cx: *JSContext,
}, },
complete_script: |script| { complete_script: |script| {
unsafe { unsafe {
let scriptnode: AbstractNode<ScriptView> = NodeWrapping::from_hubbub_node(script); let scriptnode: AbstractNode = NodeWrapping::from_hubbub_node(script);
do scriptnode.with_imm_element |script| { do scriptnode.with_imm_element |script| {
match script.get_attr(None, "src") { match script.get_attr(None, "src") {
Some(src) => { Some(src) => {
@ -489,7 +489,7 @@ pub fn parse_html(cx: *JSContext,
complete_style: |style| { complete_style: |style| {
// We've reached the end of a <style> so we can submit all the text to the parser. // We've reached the end of a <style> so we can submit all the text to the parser.
unsafe { unsafe {
let style: AbstractNode<ScriptView> = NodeWrapping::from_hubbub_node(style); let style: AbstractNode = NodeWrapping::from_hubbub_node(style);
let url = FromStr::from_str("http://example.com/"); // FIXME let url = FromStr::from_str("http://example.com/"); // FIXME
let url_cell = Cell::new(url); let url_cell = Cell::new(url);

View file

@ -6,7 +6,7 @@
/// coupling between these two components, and enables the DOM to be placed in a separate crate /// coupling between these two components, and enables the DOM to be placed in a separate crate
/// from layout. /// from layout.
use dom::node::{AbstractNode, LayoutDataRef, LayoutView, ScriptView}; use dom::node::{AbstractNode, LayoutDataRef};
use extra::url::Url; use extra::url::Url;
use geom::point::Point2D; use geom::point::Point2D;
@ -51,16 +51,16 @@ pub enum Msg {
/// Synchronous messages that script can send to layout. /// Synchronous messages that script can send to layout.
pub enum LayoutQuery { pub enum LayoutQuery {
/// Requests the dimensions of the content box, as in the `getBoundingClientRect()` call. /// Requests the dimensions of the content box, as in the `getBoundingClientRect()` call.
ContentBoxQuery(AbstractNode<ScriptView>, Chan<ContentBoxResponse>), ContentBoxQuery(AbstractNode, Chan<ContentBoxResponse>),
/// Requests the dimensions of all the content boxes, as in the `getClientRects()` call. /// Requests the dimensions of all the content boxes, as in the `getClientRects()` call.
ContentBoxesQuery(AbstractNode<ScriptView>, Chan<ContentBoxesResponse>), ContentBoxesQuery(AbstractNode, Chan<ContentBoxesResponse>),
/// Requests the node containing the point of interest /// Requests the node containing the point of interest
HitTestQuery(AbstractNode<ScriptView>, Point2D<f32>, Chan<Result<HitTestResponse, ()>>), HitTestQuery(AbstractNode, Point2D<f32>, Chan<Result<HitTestResponse, ()>>),
} }
pub struct ContentBoxResponse(Rect<Au>); pub struct ContentBoxResponse(Rect<Au>);
pub struct ContentBoxesResponse(~[Rect<Au>]); pub struct ContentBoxesResponse(~[Rect<Au>]);
pub struct HitTestResponse(AbstractNode<LayoutView>); pub struct HitTestResponse(AbstractNode);
/// Determines which part of the /// Determines which part of the
#[deriving(Eq, Ord)] #[deriving(Eq, Ord)]
@ -85,7 +85,7 @@ impl DocumentDamageLevel {
/// Note that this is fairly coarse-grained and is separate from layout's notion of the document /// Note that this is fairly coarse-grained and is separate from layout's notion of the document
pub struct DocumentDamage { pub struct DocumentDamage {
/// The topmost node in the tree that has changed. /// The topmost node in the tree that has changed.
root: AbstractNode<ScriptView>, root: AbstractNode,
/// The amount of damage that occurred. /// The amount of damage that occurred.
level: DocumentDamageLevel, level: DocumentDamageLevel,
} }
@ -102,7 +102,7 @@ pub enum ReflowGoal {
/// Information needed for a reflow. /// Information needed for a reflow.
pub struct Reflow { pub struct Reflow {
/// The document node. /// The document node.
document_root: AbstractNode<ScriptView>, document_root: AbstractNode,
/// The style changes that need to be done. /// The style changes that need to be done.
damage: DocumentDamage, damage: DocumentDamage,
/// The goal of reflow: either to render to the screen or to flush layout info for script. /// The goal of reflow: either to render to the screen or to flush layout info for script.

View file

@ -26,7 +26,6 @@ use layout_interface::{Reflow, ReflowDocumentDamage, ReflowForDisplay, ReflowGoa
use layout_interface::ContentChangedDocumentDamage; use layout_interface::ContentChangedDocumentDamage;
use layout_interface; use layout_interface;
use dom::node::ScriptView;
use extra::url::Url; use extra::url::Url;
use geom::point::Point2D; use geom::point::Point2D;
use geom::size::Size2D; use geom::size::Size2D;
@ -133,7 +132,7 @@ pub struct Page {
resize_event: Option<Size2D<uint>>, resize_event: Option<Size2D<uint>>,
/// Pending scroll to fragment event, if any /// Pending scroll to fragment event, if any
fragment_node: Option<AbstractNode<ScriptView>> fragment_node: Option<AbstractNode>
} }
pub struct PageTree { pub struct PageTree {
@ -804,7 +803,7 @@ impl ScriptTask {
page.fragment_node = fragment.map_default(None, |fragid| self.find_fragment_node(page, fragid)); page.fragment_node = fragment.map_default(None, |fragid| self.find_fragment_node(page, fragid));
} }
fn find_fragment_node(&self, page: &mut Page, fragid: ~str) -> Option<AbstractNode<ScriptView>> { fn find_fragment_node(&self, page: &mut Page, fragid: ~str) -> Option<AbstractNode> {
let document = page.frame.expect("root frame is None").document; let document = page.frame.expect("root frame is None").document;
match document.document().GetElementById(fragid.to_owned()) { match document.document().GetElementById(fragid.to_owned()) {
Some(node) => Some(node), Some(node) => Some(node),
@ -823,7 +822,7 @@ impl ScriptTask {
} }
} }
fn scroll_fragment_point(&self, pipeline_id: PipelineId, page: &mut Page, node: AbstractNode<ScriptView>) { fn scroll_fragment_point(&self, pipeline_id: PipelineId, page: &mut Page, node: AbstractNode) {
let (port, chan) = comm::stream(); let (port, chan) = comm::stream();
match page.query_layout(ContentBoxQuery(node, chan), port) { match page.query_layout(ContentBoxQuery(node, chan), port) {
ContentBoxResponse(rect) => { ContentBoxResponse(rect) => {