Use spec names for ElementKinds

src/servo/dom/base.rs

@@ -17,12 +17,12 @@ enum node_kind {
 
 class ElementData {
     let tag_name: str;
-    let subclass: ~element_subclass;
+    let kind: ~ElementKind;
     let attrs: dvec<~attr>;
 
-    new(-tag_name: str, -subclass: ~element_subclass) {
+    new(-tag_name: str, -kind: ~ElementKind) {
         self.tag_name = tag_name;
-        self.subclass = subclass;
+        self.kind = kind;
         self.attrs = dvec();
     }
 
@@ -49,11 +49,11 @@ class attr {
     }
 }
 
-enum element_subclass {
+enum ElementKind {
-    es_unknown,
+    UnknownElement,
-    es_div,
+    HTMLDivElement,
-    es_img({mut size: Size2D<au>}),
+    HTMLHeadElement,
-    es_head
+    HTMLImageElement({mut size: Size2D<au>})
 }
 
 #[doc="The rd_aux data is a (weak) pointer to the layout data, which

src/servo/layout/base.rs

@@ -1,6 +1,7 @@
 #[doc="Fundamental layout structures and algorithms."]
 
-import dom::base::{Element, es_div, es_img, node_data, node_kind, node};
+import dom::base::{Element, ElementKind, HTMLDivElement, HTMLImageElement, node_data, node_kind};
+import dom::base::{node};
 import dom::rcu;
 import dom::rcu::reader_methods;
 import gfx::geometry;
@@ -145,8 +146,8 @@ impl node_methods for node {
 
 #[cfg(test)]
 mod test {
-    import dom::base::{ElementData, es_div, es_img, methods, Element, node_data, node_kind, node};
+    import dom::base::{ElementData, HTMLDivElement, HTMLImageElement, methods, Element, node_data};
-    import dom::base::{wr_tree_ops};
+    import dom::base::{node, node_kind, wr_tree_ops};
     import dom::rcu::scope;
     import box_builder::{box_builder_methods};
 
@@ -179,14 +180,14 @@ mod test {
     fn do_layout() {
         let s = scope();
 
-        fn mk_img(size: Size2D<au>) -> ~dom::base::element_subclass {
+        fn mk_img(size: Size2D<au>) -> ~ElementKind {
-            ~es_img({mut size: size})
+            ~HTMLImageElement({mut size: size})
         }
 
         let n0 = s.new_node(Element(ElementData("img", mk_img(Size2D(au(10),au(10))))));
         let n1 = s.new_node(Element(ElementData("img", mk_img(Size2D(au(10),au(10))))));
         let n2 = s.new_node(Element(ElementData("img", mk_img(Size2D(au(10),au(20))))));
-        let n3 = s.new_node(Element(ElementData("div", ~es_div)));
+        let n3 = s.new_node(Element(ElementData("div", ~HTMLDivElement)));
 
         tree::add_child(s, n3, n0);
         tree::add_child(s, n3, n1);

src/servo/layout/box_builder.rs

@@ -1,6 +1,6 @@
 #[doc="Creates CSS boxes from a DOM."]
 
-import dom::base::{ElementData, es_div, es_img, Element, Text, node};
+import dom::base::{ElementData, HTMLDivElement, HTMLImageElement, Element, Text, node};
 import dom::style::{display_type, di_block, di_inline, di_none};
 import dom::rcu::reader_methods;
 import gfx::geometry;
@@ -162,10 +162,10 @@ impl box_builder_priv for node {
         alt self.rd({ |n| copy n.kind }) {
             ~Text(string) { bk_text(@text_box(string)) }
             ~Element(element) {
-                alt *element.subclass {
+                alt *element.kind {
-                    es_div         { bk_block            }
+                    HTMLDivElement           { bk_block            }
-                    es_img({size}) { bk_intrinsic(@size) }
+                    HTMLImageElement({size}) { bk_intrinsic(@size) }
-                    es_unknown     { bk_inline           }
+                    UnknownElement           { bk_inline           }
                 }
             }
         }

src/servo/layout/style/apply.rs

@@ -1,5 +1,5 @@
 #[doc="Applies style to boxes."]
-import dom::base::{es_img, Element, node};
+import dom::base::{HTMLImageElement, Element, node};
 import dom::rcu::reader_methods;
 import image::base::load;
 import layout::base::*;
@@ -25,8 +25,8 @@ impl apply_style_methods for @box {
 
                 self.appearance.background_color = some(style.back_color);
 
-                alt element.subclass {
+                alt element.kind {
-                  ~es_img(*) {
+                  ~HTMLImageElement(*) {
                     alt element.get_attr("src") {
                       some(url) {
                         // FIXME: Some sort of BASE HREF support!

src/servo/layout/style/matching.rs

@@ -204,13 +204,13 @@ impl matching_methods for node {
 }
 
 mod test {
-    import dom::base::{node_scope, methods, Element, attr, es_div, es_img, es_unknown, es_head};
+    import dom::base::{node_scope, methods, Element, attr, HTMLDivElement, HTMLImageElement};
-    import dom::base::{wr_tree_ops};
+    import dom::base::{UnknownElement, HTMLHeadElement, wr_tree_ops};
     import dvec::{dvec, extensions};
     import io::println;
 
     fn new_node_from_attr(scope: node_scope, -name: str, -val: str) -> node {
-        let elmt = ElementData("div", ~es_div);
+        let elmt = ElementData("div", ~HTMLDivElement);
         let attr = ~attr(name, val);
         elmt.attrs.push(attr);
         ret scope.new_node(Element(elmt));

src/servo/layout/style/style.rs

@@ -1,7 +1,7 @@
 #[doc="High-level interface to CSS selector matching."]
 
 import dom::style::{display_type, di_block, di_inline, di_none, stylesheet};
-import dom::base::{es_div, es_head, es_img, Element, Text, node};
+import dom::base::{HTMLDivElement, HTMLHeadElement, HTMLImageElement, Element, Text, node};
 import dom::base::node_kind;
 import dom::rcu::reader_methods;
 import layout::base::*; // FIXME: resolve bug requires *
@@ -23,12 +23,11 @@ fn default_style_for_node_kind(kind: node_kind) -> computed_style {
         let r = rand::rng();
         let rand_color = rgb(r.next() as u8, r.next() as u8, r.next() as u8);
 
-        alt *element.subclass {
+        alt *element.kind {
-          es_div { {mut display: di_block,
+          HTMLDivElement      { {mut display: di_block,  mut back_color: rand_color} }
-                    mut back_color: rand_color} }
+          HTMLHeadElement     { {mut display: di_none,   mut back_color: rand_color} }
-          es_head { {mut display: di_none, mut back_color: rand_color} }
+          HTMLImageElement(*) { {mut display: di_inline, mut back_color: rand_color} }
-          es_img(*) { {mut display: di_inline, mut back_color: rand_color} }
+          UnknownElement      { {mut display: di_inline, mut back_color: rand_color} }
-          es_unknown { {mut display: di_inline, mut back_color: rand_color} }
         }
       }
     }

src/servo/parser/html_builder.rs

@@ -1,8 +1,8 @@
 #[doc="Constructs a DOM tree from an incoming token stream."]
 
 import dom::rcu::writer_methods;
-import dom::base::{attr, element_subclass, es_div, es_head, es_img, es_unknown, methods, Element};
+import dom::base::{attr, ElementKind, HTMLDivElement, HTMLHeadElement, HTMLImageElement};
-import dom::base::{ElementData, Text, rd_tree_ops, wr_tree_ops};
+import dom::base::{UnknownElement, methods, Element, ElementData, Text, rd_tree_ops, wr_tree_ops};
 import dom = dom::base;
 import dvec::extensions;
 import geom::size::Size2D;
@@ -18,8 +18,8 @@ fn link_up_attribute(scope: dom::node_scope, node: dom::node, -key: str, -value:
         alt *node_contents.kind {
             Element(element) {
                 element.attrs.push(~attr(copy key, copy value));
-                alt *element.subclass {
+                alt *element.kind {
-                    es_img(img) if key == "width" {
+                    HTMLImageElement(img) if key == "width" {
                         alt int::from_str(value) {
                             none {
                                 // Drop on the floor.
@@ -27,7 +27,7 @@ fn link_up_attribute(scope: dom::node_scope, node: dom::node, -key: str, -value:
                             some(s) { img.size.width = geometry::px_to_au(s); }
                         }
                     }
-                    es_img(img) if key == "height" {
+                    HTMLImageElement(img) if key == "height" {
                         alt int::from_str(value) {
                             none {
                                 // Drop on the floor.
@@ -37,7 +37,7 @@ fn link_up_attribute(scope: dom::node_scope, node: dom::node, -key: str, -value:
                             }
                         }
                     }
-                    es_div | es_img(*) | es_head | es_unknown {
+                    HTMLDivElement | HTMLImageElement(*) | HTMLHeadElement | UnknownElement {
                         // Drop on the floor.
                     }
                 }
@@ -50,31 +50,31 @@ fn link_up_attribute(scope: dom::node_scope, node: dom::node, -key: str, -value:
     }
 }
 
-fn build_element_subclass(tag_name: str) -> ~element_subclass {
+fn build_element_kind(tag_name: str) -> ~ElementKind {
     alt tag_name {
-        "div" { ret ~es_div; }
+        "div"   { ~HTMLDivElement }
         "img"   {
-            ret ~es_img({
+            ~HTMLImageElement({
                 mut size: Size2D(geometry::px_to_au(100),
                                  geometry::px_to_au(100))
-            });
+            })
         }
-        "head" { ret ~es_head; }
+        "head"  { ~HTMLHeadElement }
-        _ { ret ~es_unknown; }
+        _       { ~UnknownElement  }
     }
 }
 
 fn build_dom(scope: dom::node_scope, stream: port<token>) -> dom::node {
     // The current reference node.
-    let mut cur = scope.new_node(Element(ElementData("html", ~es_div)));
+    let mut cur = scope.new_node(Element(ElementData("html", ~HTMLDivElement)));
     loop {
         let token = stream.recv();
         alt token {
             parser::to_eof { break; }
             parser::to_start_opening_tag(tag_name) {
                 #debug["starting tag %s", tag_name];
-                let element_subclass = build_element_subclass(tag_name);
+                let element_kind = build_element_kind(tag_name);
-                let new_node = scope.new_node(Element(ElementData(tag_name, element_subclass)));
+                let new_node = scope.new_node(Element(ElementData(tag_name, element_kind)));
                 scope.add_child(cur, new_node);
                 cur = new_node;
             }