diff --git a/src/components/script/dom/bindings/codegen/Bindings.conf b/src/components/script/dom/bindings/codegen/Bindings.conf index 9db9477850d5..12d15d37fe94 100644 --- a/src/components/script/dom/bindings/codegen/Bindings.conf +++ b/src/components/script/dom/bindings/codegen/Bindings.conf @@ -185,7 +185,7 @@ DOMInterfaces = { 'Element': { 'nativeType': 'AbstractNode', 'pointerType': '', - 'needsAbstract': ['getClientRects', 'getBoundingClientRect', 'setAttribute', 'setAttributeNS', 'removeAttribute', 'removeAttributeNS', 'id', 'attributes'] + 'needsAbstract': ['getClientRects', 'getBoundingClientRect', 'setAttribute', 'setAttributeNS', 'removeAttribute', 'removeAttributeNS', 'id', 'attributes', 'innerHTML', 'outerHTML'] }, 'Event': { diff --git a/src/components/script/dom/element.rs b/src/components/script/dom/element.rs index 25a9e3811b26..c4196b9fab42 100644 --- a/src/components/script/dom/element.rs +++ b/src/components/script/dom/element.rs @@ -13,10 +13,11 @@ use dom::htmlcollection::HTMLCollection; use dom::clientrect::ClientRect; use dom::clientrectlist::ClientRectList; use dom::document::AbstractDocument; -use dom::node::{AbstractNode, ElementNodeTypeId, Node}; +use dom::node::{AbstractNode, ElementNodeTypeId, Node, NodeIterator}; use dom::document; use dom::namespace; use dom::namespace::{Namespace, Null}; +use dom::htmlserializer::serialize; use layout_interface::{ContentBoxQuery, ContentBoxResponse, ContentBoxesQuery}; use layout_interface::{ContentBoxesResponse, ContentChangedDocumentDamage}; use layout_interface::{MatchSelectorsDocumentDamage}; @@ -323,6 +324,20 @@ impl Element { document.document().damage_and_reflow(damage); } } + + pub fn is_void(&self) -> bool { + if self.namespace != namespace::HTML { + return false + } + match self.tag_name.as_slice() { + /* List of void elements from + http://www.whatwg.org/specs/web-apps/current-work/multipage/the-end.html#html-fragment-serialization-algorithm */ + "area" | "base" | "basefont" | "bgsound" | "br" | "col" | "embed" | + "frame" | "hr" | "img" | "input" | "keygen" | "link" | "menuitem" | + "meta" | "param" | "source" | "track" | "wbr" => true, + _ => false + } + } } // http://www.whatwg.org/html/#reflecting-content-attributes-in-idl-attributes @@ -535,19 +550,20 @@ impl Element { 0 } - pub fn GetInnerHTML(&self) -> Fallible { - Ok(~"") + pub fn GetInnerHTML(&self, abstract_self: AbstractNode) -> Fallible { + //XXX TODO: XML case + Ok(serialize(&mut NodeIterator::new(abstract_self, false, false))) } - pub fn SetInnerHTML(&mut self, _value: DOMString) -> ErrorResult { + pub fn SetInnerHTML(&mut self, _abstract_self: AbstractNode, _value: DOMString) -> ErrorResult { Ok(()) } - pub fn GetOuterHTML(&self) -> Fallible { - Ok(~"") + pub fn GetOuterHTML(&self, abstract_self:AbstractNode) -> Fallible { + Ok(serialize(&mut NodeIterator::new(abstract_self, true, false))) } - pub fn SetOuterHTML(&mut self, _value: DOMString) -> ErrorResult { + pub fn SetOuterHTML(&mut self, _abstract_self: AbstractNode, _value: DOMString) -> ErrorResult { Ok(()) } @@ -560,7 +576,6 @@ impl Element { } } - fn get_attribute_parts(name: DOMString) -> (Option<~str>, ~str) { //FIXME: Throw for XML-invalid names //FIXME: Throw for XMLNS-invalid names diff --git a/src/components/script/dom/htmlserializer.rs b/src/components/script/dom/htmlserializer.rs new file mode 100644 index 000000000000..3de36d831f20 --- /dev/null +++ b/src/components/script/dom/htmlserializer.rs @@ -0,0 +1,135 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +use dom::namespace; +use dom::attr::Attr; +use dom::node::NodeIterator; +use dom::node::{DoctypeNodeTypeId, DocumentFragmentNodeTypeId, CommentNodeTypeId, DocumentNodeTypeId, ElementNodeTypeId, TextNodeTypeId, AbstractNode}; + +pub fn serialize(iterator: &mut NodeIterator) -> ~str { + let mut html = ~""; + let mut open_elements: ~[~str] = ~[]; + + for node in *iterator { + while open_elements.len() > iterator.depth { + html.push_str(~""); + } + html.push_str( + match node.type_id() { + ElementNodeTypeId(..) => { + serialize_elem(node, &mut open_elements) + } + CommentNodeTypeId => { + serialize_comment(node) + } + TextNodeTypeId => { + serialize_text(node) + } + DoctypeNodeTypeId => { + serialize_doctype(node) + } + DocumentFragmentNodeTypeId => { + ~"" + } + DocumentNodeTypeId(_) => { + fail!("It shouldn't be possible to serialize a document node") + } + } + ); + } + while open_elements.len() > 0 { + html.push_str(~""); + } + html +} + +fn serialize_comment(node: AbstractNode) -> ~str { + node.with_imm_characterdata(|comment| { + ~"" + }) +} + +fn serialize_text(node: AbstractNode) -> ~str { + node.with_imm_characterdata(|text| { + match node.parent_node() { + Some(parent) if parent.is_element() => { + parent.with_imm_element(|elem| { + match elem.tag_name.as_slice() { + "style" | "script" | "xmp" | "iframe" | + "noembed" | "noframes" | "plaintext" | + "noscript" if elem.namespace == namespace::HTML => { + text.data.clone() + }, + _ => escape(text.data, false) + } + }) + }, + _ => escape(text.data, false) + } + }) +} + +fn serialize_doctype(node: AbstractNode) -> ~str { + node.with_imm_doctype(|doctype| { + ~"" + }) +} + +fn serialize_elem(node: AbstractNode, open_elements: &mut ~[~str]) -> ~str { + node.with_imm_element(|elem| { + let mut rv = ~"<" + elem.tag_name; + for attr in elem.attrs.iter() { + rv.push_str(serialize_attr(attr)); + }; + rv.push_str(">"); + match elem.tag_name.as_slice() { + "pre" | "listing" | "textarea" if + elem.namespace == namespace::HTML => { + match node.first_child() { + Some(child) if child.is_text() => { + child.with_imm_characterdata(|text| { + if text.data[0] == 0x0A as u8 { + rv.push_str("\x0A"); + } + }) + }, + _ => {} + } + }, + _ => {} + } + if !elem.is_void() { + open_elements.push(elem.tag_name.clone()); + } + rv + }) +} + +fn serialize_attr(attr: &@mut Attr) -> ~str { + let attr_name = if attr.namespace == namespace::XML { + ~"xml:" + attr.local_name.clone() + } else if attr.namespace == namespace::XMLNS && + attr.local_name.as_slice() == "xmlns" { + ~"xmlns" + } else if attr.namespace == namespace::XMLNS { + ~"xmlns:" + attr.local_name.clone() + } else if attr.namespace == namespace::XLink { + ~"xlink:" + attr.local_name.clone() + } else { + attr.name.clone() + }; + ~" " + attr_name + "=\"" + escape(attr.value, true) + "\"" +} + +fn escape(string: &str, attr_mode: bool) -> ~str { + let replaced = string.replace("&", "&").replace("\xA0", " "); + match attr_mode { + true => { + replaced.replace("\"", """) + }, + false => { + replaced.replace("<", "<").replace(">", ">") + } + } +} diff --git a/src/components/script/dom/node.rs b/src/components/script/dom/node.rs index a98f89b48177..7c58f4d2751d 100644 --- a/src/components/script/dom/node.rs +++ b/src/components/script/dom/node.rs @@ -684,6 +684,85 @@ impl Iterator for TreeIterator { } } +pub struct NodeIterator { + start_node: AbstractNode, + current_node: Option, + depth: uint, + priv include_start: bool, + priv include_descendants_of_void: bool +} + +impl NodeIterator { + pub fn new(start_node: AbstractNode, include_start: bool, include_descendants_of_void: bool) -> NodeIterator { + NodeIterator { + start_node: start_node, + current_node: None, + depth: 0, + include_start: include_start, + include_descendants_of_void: include_descendants_of_void + } + } + + fn next_child(&self, node: AbstractNode) -> Option { + if !self.include_descendants_of_void && + node.is_element() { + node.with_imm_element(|elem| { + if elem.is_void() { + None + } else { + node.first_child() + } + }) + } else { + node.first_child() + } + } +} + +impl Iterator for NodeIterator { + fn next(&mut self) -> Option { + self.current_node = match self.current_node { + None => { + if self.include_start { + Some(self.start_node) + } else { + self.next_child(self.start_node) + } + }, + Some(node) => { + match self.next_child(node) { + Some(child) => { + self.depth += 1; + Some(child) + }, + None if node == self.start_node => None, + None => { + match node.next_sibling() { + Some(sibling) => Some(sibling), + None => { + let mut candidate = node; + while candidate.next_sibling().is_none() { + candidate = candidate.parent_node().expect("Got to root without reaching start node"); + self.depth -= 1; + if candidate == self.start_node { + break; + } + } + if candidate != self.start_node { + candidate.next_sibling() + } else { + None + } + } + } + } + } + } + }; + self.current_node + } +} + fn gather_abstract_nodes(cur: &AbstractNode, refs: &mut ~[AbstractNode], postorder: bool) { if !postorder { refs.push(cur.clone()); diff --git a/src/components/script/script.rc b/src/components/script/script.rc index 0e25bea39e23..dd12823c0038 100644 --- a/src/components/script/script.rc +++ b/src/components/script/script.rc @@ -113,6 +113,7 @@ pub mod dom { pub mod htmlquoteelement; pub mod htmlscriptelement; pub mod htmlselectelement; + pub mod htmlserializer; pub mod htmlspanelement; pub mod htmlsourceelement; pub mod htmlstyleelement;