Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-08-06 06:00:15 +01:00
Code Issues Projects Releases Packages Wiki Activity

Update rustc to revision 3dcd2157403163789aaf21a9ab3c4d30a7c6494d.

Browse source
This commit is contained in:
Ms2ger 2014-12-17 10:42:52 +01:00 • committed by Josh Matthews
parent b8900782b0
commit 466faac2a5
223 changed files with 4414 additions and 4105 deletions
Download patch file Download diff file Expand all files Collapse all files

35
components/script/dom/attr.rs
View file

@ -30,32 +30,32 @@ pub enum AttrSettingType {
#[deriving(PartialEq, Clone)]
#[jstraceable]
pub enum AttrValue {
StringAttrValue(DOMString),
TokenListAttrValue(DOMString, Vec<Atom>),
UIntAttrValue(DOMString, u32),
AtomAttrValue(Atom),
String(DOMString),
TokenList(DOMString, Vec<Atom>),
UInt(DOMString, u32),
Atom(Atom),
}
impl AttrValue {
pub fn from_tokenlist(tokens: DOMString) -> AttrValue {
let atoms = split_html_space_chars(tokens.as_slice())
.map(|token| Atom::from_slice(token)).collect();
TokenListAttrValue(tokens, atoms)
AttrValue::TokenList(tokens, atoms)
}
pub fn from_u32(string: DOMString, default: u32) -> AttrValue {
let result: u32 = from_str(string.as_slice()).unwrap_or(default);
UIntAttrValue(string, result)
AttrValue::UInt(string, result)
}
pub fn from_atomic(string: DOMString) -> AttrValue {
let value = Atom::from_slice(string.as_slice());
AtomAttrValue(value)
AttrValue::Atom(value)
}
pub fn tokens<'a>(&'a self) -> Option<&'a [Atom]> {
match *self {
TokenListAttrValue(_, ref tokens) => Some(tokens.as_slice()),
AttrValue::TokenList(_, ref tokens) => Some(tokens.as_slice()),
_ => None
}
}
@ -64,10 +64,10 @@ impl AttrValue {
impl Str for AttrValue {
fn as_slice<'a>(&'a self) -> &'a str {
match *self {
StringAttrValue(ref value) |
TokenListAttrValue(ref value, _) |
UIntAttrValue(ref value, _) => value.as_slice(),
AtomAttrValue(ref value) => value.as_slice(),
AttrValue::String(ref value) |
AttrValue::TokenList(ref value, _) |
AttrValue::UInt(ref value, _) => value.as_slice(),
AttrValue::Atom(ref value) => value.as_slice(),
}
}
}
@ -141,12 +141,12 @@ impl<'a> AttrMethods for JSRef<'a, Attr> {
fn SetValue(self, value: DOMString) {
match self.owner {
None => {
*self.value.borrow_mut() = StringAttrValue(value)
*self.value.borrow_mut() = AttrValue::String(value)
}
Some(o) => {
let owner = o.root();
let value = owner.parse_attribute(&self.namespace, self.local_name(), value);
self.set_value(ReplacedAttr, value, *owner);
self.set_value(AttrSettingType::ReplacedAttr, value, *owner);
}
}
}
@ -207,7 +207,8 @@ impl<'a> AttrHelpers<'a> for JSRef<'a, Attr> {
let namespace_is_null = self.namespace == ns!("");
match set_type {
ReplacedAttr if namespace_is_null => vtable_for(&node).before_remove_attr(self),
AttrSettingType::ReplacedAttr if namespace_is_null =>
vtable_for(&node).before_remove_attr(self),
_ => ()
}
@ -255,7 +256,7 @@ impl AttrHelpersForLayout for Attr {
unsafe fn value_atom_forever(&self) -> Option<Atom> {
let value = self.value.borrow_for_layout();
match *value {
AtomAttrValue(ref val) => Some(val.clone()),
AttrValue::Atom(ref val) => Some(val.clone()),
_ => None,
}
}
@ -265,7 +266,7 @@ impl AttrHelpersForLayout for Attr {
// This transmute is used to cheat the lifetime restriction.
let value = mem::transmute::<&AttrValue, &AttrValue>(self.value.borrow_for_layout());
match *value {
TokenListAttrValue(_, ref tokens) => Some(tokens.as_slice()),
AttrValue::TokenList(_, ref tokens) => Some(tokens.as_slice()),
_ => None,
}
}

82
components/script/dom/bindings/codegen/CodegenRust.py
View file

@ -425,7 +425,7 @@ def typeNeedsRooting(type, descriptorProvider):
def union_native_type(t):
name = t.unroll().name
return 'UnionTypes::%s::%s' % (name, name)
return 'UnionTypes::%s' % name
def getJSToNativeConversionTemplate(type, descriptorProvider, failureCode=None,
@ -741,7 +741,7 @@ def getJSToNativeConversionTemplate(type, descriptorProvider, failureCode=None,
if defaultValue is not None:
assert(defaultValue.type.tag() == IDLType.Tags.domstring)
default = "%sValues::%s" % (enum, getEnumValueName(defaultValue.value))
default = "%s::%s" % (enum, getEnumValueName(defaultValue.value))
else:
default = None
@ -1419,11 +1419,11 @@ class CGNamespace(CGWrapper):
def DOMClass(descriptor):
protoList = ['PrototypeList::id::' + proto for proto in descriptor.prototypeChain]
# Pad out the list to the right length with IDCount so we
# guarantee that all the lists are the same length. IDCount
# Pad out the list to the right length with id::Count so we
# guarantee that all the lists are the same length. id::Count
# is never the ID of any prototype, so it's safe to use as
# padding.
protoList.extend(['PrototypeList::id::IDCount'] * (descriptor.config.maxProtoChainLength - len(protoList)))
protoList.extend(['PrototypeList::id::Count'] * (descriptor.config.maxProtoChainLength - len(protoList)))
prototypeChainString = ', '.join(protoList)
return """DOMClass {
interface_chain: [ %s ],
@ -1673,7 +1673,7 @@ def UnionTypes(descriptors, dictionaries, callbacks, config):
'dom::bindings::codegen::PrototypeList',
'dom::bindings::conversions::FromJSValConvertible',
'dom::bindings::conversions::ToJSValConvertible',
'dom::bindings::conversions::Default',
'dom::bindings::conversions::StringificationBehavior::Default',
'dom::bindings::error::throw_not_in_union',
'dom::bindings::js::JS',
'dom::types::*',
@ -1693,14 +1693,12 @@ def UnionTypes(descriptors, dictionaries, callbacks, config):
name = str(t)
if not name in unionStructs:
provider = descriptor or config.getDescriptorProvider()
unionStructs[name] = CGNamespace(name,
CGImports(CGList([
CGUnionStruct(t, provider),
CGUnionConversionStruct(t, provider)
]), [], imports),
public=True)
unionStructs[name] = CGList([
CGUnionStruct(t, provider),
CGUnionConversionStruct(t, provider)
])
return CGList(SortedDictValues(unionStructs), "\n\n")
return CGImports(CGList(SortedDictValues(unionStructs), "\n\n"), [], imports)
class Argument():
@ -1889,7 +1887,7 @@ class CGIDLInterface(CGThing):
}
return string.Template("""
impl IDLInterface for ${type} {
fn get_prototype_id(_: Option<${type}>) -> PrototypeList::id::ID {
fn get_prototype_id(_: Option<${type}>) -> PrototypeList::id {
PrototypeList::id::${type}
}
fn get_prototype_depth(_: Option<${type}>) -> uint {
@ -2753,35 +2751,36 @@ def getEnumValueName(value):
class CGEnum(CGThing):
def __init__(self, enum):
CGThing.__init__(self)
decl = """
#[repr(uint)]
#[deriving(PartialEq)]
#[jstraceable]
pub enum %s {
%s
}
""" % (enum.identifier.name, ",\n ".join(map(getEnumValueName, enum.values())))
inner = """
use dom::bindings::conversions::ToJSValConvertible;
use js::jsapi::JSContext;
use js::jsval::JSVal;
#[repr(uint)]
#[deriving(PartialEq)]
#[jstraceable]
pub enum valuelist {
%s
}
pub const strings: &'static [&'static str] = &[
%s,
];
impl ToJSValConvertible for valuelist {
impl ToJSValConvertible for super::%s {
fn to_jsval(&self, cx: *mut JSContext) -> JSVal {
strings[*self as uint].to_string().to_jsval(cx)
}
}
""" % (",\n ".join(map(getEnumValueName, enum.values())),
",\n ".join(['"%s"' % val for val in enum.values()]))
""" % (",\n ".join(['"%s"' % val for val in enum.values()]), enum.identifier.name)
self.cgRoot = CGList([
CGGeneric(decl),
CGNamespace.build([enum.identifier.name + "Values"],
CGIndenter(CGGeneric(inner)), public=True),
CGGeneric("pub type %s = self::%sValues::valuelist;\n" %
(enum.identifier.name, enum.identifier.name)),
])
def define(self):
@ -2876,7 +2875,7 @@ class CGUnionStruct(CGThing):
" e%s(%s)," % (v["name"], v["typeName"]) for v in templateVars
]
enumConversions = [
" e%s(ref inner) => inner.to_jsval(cx)," % v["name"] for v in templateVars
" %s::e%s(ref inner) => inner.to_jsval(cx)," % (self.type, v["name"]) for v in templateVars
]
# XXXManishearth The following should be #[must_root],
# however we currently allow it till #2661 is fixed
@ -2922,9 +2921,9 @@ class CGUnionConversionStruct(CGThing):
return (
"match %s::TryConvertTo%s(cx, value) {\n"
" Err(_) => return Err(()),\n"
" Ok(Some(value)) => return Ok(e%s(value)),\n"
" Ok(Some(value)) => return Ok(%s::e%s(value)),\n"
" Ok(None) => (),\n"
"}\n") % (self.type, name, name)
"}\n") % (self.type, name, self.type, name)
typeNames = [get_name(memberType) for memberType in interfaceMemberTypes]
interfaceObject = CGList(CGGeneric(get_match(typeName)) for typeName in typeNames)
@ -2990,9 +2989,9 @@ class CGUnionConversionStruct(CGThing):
match = (
"match %s::TryConvertTo%s(cx, value) {\n"
" Err(_) => return Err(()),\n"
" Ok(Some(value)) => return Ok(e%s(value)),\n"
" Ok(Some(value)) => return Ok(%s::e%s(value)),\n"
" Ok(None) => (),\n"
"}\n") % (self.type, name, name)
"}\n") % (self.type, name, self.type, name)
conversions.append(CGGeneric(match))
names.append(name)
@ -4182,8 +4181,8 @@ class CGDescriptor(CGThing):
def define(self):
return self.cgRoot.define()
class CGNamespacedEnum(CGThing):
def __init__(self, namespace, enumName, names, values, comment="", deriving=""):
class CGNonNamespacedEnum(CGThing):
def __init__(self, enumName, names, values, comment="", deriving=""):
if not values:
values = []
@ -4198,7 +4197,7 @@ class CGNamespacedEnum(CGThing):
entries.append(entry)
# Append a Count.
entries.append(enumName + 'Count = ' + str(len(entries)))
entries.append('Count = ' + str(len(entries)))
# Indent.
entries = [' ' + e for e in entries]
@ -4212,9 +4211,6 @@ class CGNamespacedEnum(CGThing):
# Add some whitespace padding.
curr = CGWrapper(curr, pre='\n',post='\n')
# Add the namespace.
curr = CGNamespace(namespace, curr, public=True)
# Add the typedef
#typedef = '\ntypedef %s::%s %s;\n\n' % (namespace, enumName, enumName)
#curr = CGList([curr, CGGeneric(typedef)])
@ -4504,23 +4500,25 @@ class CGBindingRoot(CGThing):
'dom::bindings::utils::{DOMJSClass, JSCLASS_DOM_GLOBAL}',
'dom::bindings::utils::{FindEnumStringIndex, GetArrayIndexFromId}',
'dom::bindings::utils::{GetPropertyOnPrototype, GetProtoOrIfaceArray}',
'dom::bindings::utils::{HasPropertyOnPrototype, IntVal, UintVal}',
'dom::bindings::utils::HasPropertyOnPrototype',
'dom::bindings::utils::{Reflectable}',
'dom::bindings::utils::{squirrel_away_unique}',
'dom::bindings::utils::{ThrowingConstructor, unwrap, unwrap_jsmanaged}',
'dom::bindings::utils::get_dictionary_property',
'dom::bindings::utils::{NativeProperties, NativePropertyHooks}',
'dom::bindings::utils::ConstantVal::{IntVal, UintVal}',
'dom::bindings::trace::JSTraceable',
'dom::bindings::callback::{CallbackContainer,CallbackInterface,CallbackFunction}',
'dom::bindings::callback::{CallSetup,ExceptionHandling}',
'dom::bindings::callback::{WrapCallThisObject}',
'dom::bindings::conversions::{FromJSValConvertible, ToJSValConvertible}',
'dom::bindings::conversions::IDLInterface',
'dom::bindings::conversions::{Default, Empty}',
'dom::bindings::conversions::jsid_to_str',
'dom::bindings::conversions::StringificationBehavior::{Default, Empty}',
'dom::bindings::codegen::{PrototypeList, RegisterBindings, UnionTypes}',
'dom::bindings::codegen::Bindings::*',
'dom::bindings::error::{FailureUnknown, Fallible, Error, ErrorResult}',
'dom::bindings::error::{Fallible, Error, ErrorResult}',
'dom::bindings::error::Error::FailureUnknown',
'dom::bindings::error::throw_dom_exception',
'dom::bindings::error::throw_type_error',
'dom::bindings::proxyhandler',
@ -5137,8 +5135,8 @@ class GlobalGenRoots():
return CGList([
CGGeneric(AUTOGENERATED_WARNING_COMMENT),
CGGeneric("pub const MAX_PROTO_CHAIN_LENGTH: uint = %d;\n\n" % config.maxProtoChainLength),
CGNamespacedEnum('id', 'ID', protos, [0], deriving="PartialEq"),
CGNamespacedEnum('proxies', 'Proxy', proxies, [0], deriving="PartialEq"),
CGNonNamespacedEnum('id', protos, [0], deriving="PartialEq"),
CGNonNamespacedEnum('proxies', proxies, [0], deriving="PartialEq"),
])

6
components/script/dom/bindings/conversions.rs
View file

@ -37,7 +37,7 @@ use dom::bindings::codegen::PrototypeList;
// remove Option<Self> arguments.
pub trait IDLInterface {
/// Returns the prototype ID.
fn get_prototype_id(_: Option<Self>) -> PrototypeList::id::ID;
fn get_prototype_id(_: Option<Self>) -> PrototypeList::id;
/// Returns the prototype depth, i.e., the number of interfaces this
/// interface inherits from.
fn get_prototype_depth(_: Option<Self>) -> uint;
@ -256,7 +256,7 @@ pub enum StringificationBehavior {
impl default::Default for StringificationBehavior {
fn default() -> StringificationBehavior {
Default
StringificationBehavior::Default
}
}
@ -283,7 +283,7 @@ pub fn jsid_to_str(cx: *mut JSContext, id: jsid) -> DOMString {
impl FromJSValConvertible<StringificationBehavior> for DOMString {
fn from_jsval(cx: *mut JSContext, value: JSVal, nullBehavior: StringificationBehavior) -> Result<DOMString, ()> {
if nullBehavior == Empty && value.is_null() {
if nullBehavior == StringificationBehavior::Empty && value.is_null() {
Ok("".to_string())
} else {
let jsstr = unsafe { JS_ValueToString(cx, value) };

4
components/script/dom/bindings/global.rs
View file

@ -7,6 +7,10 @@
//! This module contains smart pointers to global scopes, to simplify writing
//! code that works in workers as well as window scopes.
pub use self::GlobalRef::*;
pub use self::GlobalRoot::*;
pub use self::GlobalField::*;
use dom::bindings::conversions::FromJSValConvertible;
use dom::bindings::js::{JS, JSRef, Root};
use dom::bindings::utils::{Reflectable, Reflector};

26
components/script/dom/bindings/str.rs
View file

@ -4,9 +4,9 @@
//! The `ByteString` struct.
use std::from_str::FromStr;
use std::hash::{Hash, sip};
use std::str;
use std::str::FromStr;
/// Encapsulates the IDL `ByteString` type.
#[deriving(Clone,Eq,PartialEq)]
@ -89,31 +89,31 @@ impl ByteString {
SPHT // SP or HT
}
let ByteString(ref vec) = *self;
let mut prev = Other; // The previous character
let mut prev = PreviousCharacter::Other; // The previous character
vec.iter().all(|&x| {
// http://tools.ietf.org/html/rfc2616#section-2.2
match x {
13 => { // CR
if prev == Other || prev == SPHT {
prev = CR;
if prev == PreviousCharacter::Other || prev == PreviousCharacter::SPHT {
prev = PreviousCharacter::CR;
true
} else {
false
}
},
10 => { // LF
if prev == CR {
prev = LF;
if prev == PreviousCharacter::CR {
prev = PreviousCharacter::LF;
true
} else {
false
}
},
32 => { // SP
if prev == LF || prev == SPHT {
prev = SPHT;
if prev == PreviousCharacter::LF || prev == PreviousCharacter::SPHT {
prev = PreviousCharacter::SPHT;
true
} else if prev == Other {
} else if prev == PreviousCharacter::Other {
// Counts as an Other here, since it's not preceded by a CRLF
// SP is not a CTL, so it can be used anywhere
// though if used immediately after a CR the CR is invalid
@ -124,8 +124,8 @@ impl ByteString {
}
},
9 => { // HT
if prev == LF || prev == SPHT {
prev = SPHT;
if prev == PreviousCharacter::LF || prev == PreviousCharacter::SPHT {
prev = PreviousCharacter::SPHT;
true
} else {
false
@ -133,8 +133,8 @@ impl ByteString {
},
0...31 | 127 => false, // CTLs
x if x > 127 => false, // non ASCII
_ if prev == Other || prev == SPHT => {
prev = Other;
_ if prev == PreviousCharacter::Other || prev == PreviousCharacter::SPHT => {
prev = PreviousCharacter::Other;
true
},
_ => false // Previous character was a CR/LF but not part of the [CRLF] (SP|HT) rule

26
components/script/dom/bindings/utils.rs
View file

@ -124,7 +124,7 @@ pub unsafe fn get_dom_class(obj: *mut JSObject) -> Result<DOMClass, ()> {
/// not a reflector for a DOM object of the given type (as defined by the
/// proto_id and proto_depth).
pub fn unwrap_jsmanaged<T: Reflectable>(mut obj: *mut JSObject,
proto_id: PrototypeList::id::ID,
proto_id: PrototypeList::id,
proto_depth: uint) -> Result<JS<T>, ()> {
unsafe {
let dom_class = get_dom_class(obj).or_else(|_| {
@ -212,11 +212,11 @@ impl ConstantSpec {
/// Returns a `JSVal` that represents the value of this `ConstantSpec`.
pub fn get_value(&self) -> JSVal {
match self.value {
NullVal => NullValue(),
IntVal(i) => Int32Value(i),
UintVal(u) => UInt32Value(u),
DoubleVal(d) => DoubleValue(d),
BoolVal(b) => BooleanValue(b),
ConstantVal::NullVal => NullValue(),
ConstantVal::IntVal(i) => Int32Value(i),
ConstantVal::UintVal(u) => UInt32Value(u),
ConstantVal::DoubleVal(d) => DoubleValue(d),
ConstantVal::BoolVal(b) => BooleanValue(b),
}
}
}
@ -234,7 +234,7 @@ pub struct NativePropertyHooks {
pub struct DOMClass {
/// A list of interfaces that this object implements, in order of decreasing
/// derivedness.
pub interface_chain: [PrototypeList::id::ID, ..MAX_PROTO_CHAIN_LENGTH],
pub interface_chain: [PrototypeList::id, ..MAX_PROTO_CHAIN_LENGTH],
/// The NativePropertyHooks for the interface associated with this class.
pub native_hooks: &'static NativePropertyHooks,
@ -421,7 +421,7 @@ pub unsafe extern fn ThrowingConstructor(cx: *mut JSContext, _argc: c_uint, _vp:
/// Construct and cache the ProtoOrIfaceArray for the given global.
/// Fails if the argument is not a DOM global.
pub fn initialize_global(global: *mut JSObject) {
let protoArray = box () ([0 as *mut JSObject, ..PrototypeList::id::IDCount as uint]);
let protoArray = box () ([0 as *mut JSObject, ..PrototypeList::id::Count as uint]);
unsafe {
assert!(((*JS_GetClass(global)).flags & JSCLASS_DOM_GLOBAL) != 0);
let box_ = squirrel_away_unique(protoArray);
@ -722,10 +722,10 @@ pub fn xml_name_type(name: &str) -> XMLName {
let mut non_qname_colons = false;
let mut seen_colon = false;
match iter.next() {
None => return InvalidXMLName,
None => return XMLName::InvalidXMLName,
Some(c) => {
if !is_valid_start(c) {
return InvalidXMLName;
return XMLName::InvalidXMLName;
}
if c == ':' {
non_qname_colons = true;
@ -735,7 +735,7 @@ pub fn xml_name_type(name: &str) -> XMLName {
for c in name.chars() {
if !is_valid_continuation(c) {
return InvalidXMLName;
return XMLName::InvalidXMLName;
}
if c == ':' {
match seen_colon {
@ -746,7 +746,7 @@ pub fn xml_name_type(name: &str) -> XMLName {
}
match non_qname_colons {
false => QName,
true => Name
false => XMLName::QName,
true => XMLName::Name
}
}

14
components/script/dom/blob.rs
View file

@ -14,15 +14,15 @@ use servo_util::str::DOMString;
use std::cmp::{min, max};
#[jstraceable]
pub enum BlobType {
BlobTypeId,
FileTypeId
pub enum BlobTypeId {
Blob,
File,
}
#[dom_struct]
pub struct Blob {
reflector_: Reflector,
type_: BlobType,
type_: BlobTypeId,
bytes: Option<Vec<u8>>,
typeString: DOMString,
global: GlobalField
@ -30,7 +30,7 @@ pub struct Blob {
}
impl Blob {
pub fn new_inherited(global: &GlobalRef, type_: BlobType,
pub fn new_inherited(global: &GlobalRef, type_: BlobTypeId,
bytes: Option<Vec<u8>>) -> Blob {
Blob {
reflector_: Reflector::new(),
@ -43,7 +43,7 @@ impl Blob {
}
pub fn new(global: &GlobalRef, bytes: Option<Vec<u8>>) -> Temporary<Blob> {
reflect_dom_object(box Blob::new_inherited(global, BlobTypeId, bytes),
reflect_dom_object(box Blob::new_inherited(global, BlobTypeId::Blob, bytes),
*global,
BlobBinding::Wrap)
}
@ -133,7 +133,7 @@ impl Reflectable for Blob {
impl FileDerived for Blob {
fn is_file(&self) -> bool {
match self.type_ {
FileTypeId => true,
BlobTypeId::File => true,
_ => false
}
}

13
components/script/dom/characterdata.rs
View file

@ -7,12 +7,13 @@
use dom::bindings::cell::DOMRefCell;
use dom::bindings::codegen::Bindings::CharacterDataBinding::CharacterDataMethods;
use dom::bindings::codegen::InheritTypes::{CharacterDataDerived, NodeCast};
use dom::bindings::error::{Fallible, ErrorResult, IndexSize};
use dom::bindings::error::{Fallible, ErrorResult};
use dom::bindings::error::Error::IndexSize;
use dom::bindings::js::JSRef;
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::node::{CommentNodeTypeId, Node, NodeTypeId, TextNodeTypeId, ProcessingInstructionNodeTypeId, NodeHelpers};
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::node::{Node, NodeHelpers, NodeTypeId};
use servo_util::str::DOMString;
@ -27,9 +28,9 @@ pub struct CharacterData {
impl CharacterDataDerived for EventTarget {
fn is_characterdata(&self) -> bool {
match *self.type_id() {
NodeTargetTypeId(TextNodeTypeId) |
NodeTargetTypeId(CommentNodeTypeId) |
NodeTargetTypeId(ProcessingInstructionNodeTypeId) => true,
EventTargetTypeId::Node(NodeTypeId::Text) |
EventTargetTypeId::Node(NodeTypeId::Comment) |
EventTargetTypeId::Node(NodeTypeId::ProcessingInstruction) => true,
_ => false
}
}

8
components/script/dom/comment.rs
View file

@ -11,8 +11,8 @@ use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::characterdata::CharacterData;
use dom::document::Document;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::node::{CommentNodeTypeId, Node};
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::node::{Node, NodeTypeId};
use servo_util::str::DOMString;
/// An HTML comment.
@ -23,14 +23,14 @@ pub struct Comment {
impl CommentDerived for EventTarget {
fn is_comment(&self) -> bool {
*self.type_id() == NodeTargetTypeId(CommentNodeTypeId)
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Comment)
}
}
impl Comment {
fn new_inherited(text: DOMString, document: JSRef<Document>) -> Comment {
Comment {
characterdata: CharacterData::new_inherited(CommentNodeTypeId, text, document)
characterdata: CharacterData::new_inherited(NodeTypeId::Comment, text, document)
}
}

2
components/script/dom/create.rs
View file

@ -29,7 +29,7 @@ use dom::htmlformelement::HTMLFormElement;
use dom::htmlframeelement::HTMLFrameElement;
use dom::htmlframesetelement::HTMLFrameSetElement;
use dom::htmlheadelement::HTMLHeadElement;
use dom::htmlheadingelement::{Heading1, Heading2, Heading3, Heading4, Heading5, Heading6};
use dom::htmlheadingelement::HeadingLevel::*;
use dom::htmlheadingelement::HTMLHeadingElement;
use dom::htmlhrelement::HTMLHRElement;
use dom::htmlhtmlelement::HTMLHtmlElement;

6
components/script/dom/customevent.rs
View file

@ -10,7 +10,7 @@ use dom::bindings::error::Fallible;
use dom::bindings::global::GlobalRef;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::event::{Event, EventTypeId, CustomEventTypeId};
use dom::event::{Event, EventTypeId};
use js::jsapi::JSContext;
use js::jsval::{JSVal, NullValue};
use servo_util::str::DOMString;
@ -25,7 +25,7 @@ pub struct CustomEvent {
impl CustomEventDerived for Event {
fn is_customevent(&self) -> bool {
*self.type_id() == CustomEventTypeId
*self.type_id() == EventTypeId::CustomEvent
}
}
@ -38,7 +38,7 @@ impl CustomEvent {
}
pub fn new_uninitialized(global: GlobalRef) -> Temporary<CustomEvent> {
reflect_dom_object(box CustomEvent::new_inherited(CustomEventTypeId),
reflect_dom_object(box CustomEvent::new_inherited(EventTypeId::CustomEvent),
global,
CustomEventBinding::Wrap)
}

22
components/script/dom/dedicatedworkerglobalscope.rs
View file

@ -7,20 +7,20 @@ use dom::bindings::codegen::Bindings::DedicatedWorkerGlobalScopeBinding::Dedicat
use dom::bindings::codegen::Bindings::EventHandlerBinding::EventHandlerNonNull;
use dom::bindings::codegen::InheritTypes::DedicatedWorkerGlobalScopeDerived;
use dom::bindings::codegen::InheritTypes::{EventTargetCast, WorkerGlobalScopeCast};
use dom::bindings::error::{ErrorResult, DataClone};
use dom::bindings::error::ErrorResult;
use dom::bindings::error::Error::DataClone;
use dom::bindings::global;
use dom::bindings::js::{JSRef, Temporary, RootCollection};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::eventtarget::{EventTarget, EventTargetHelpers};
use dom::eventtarget::WorkerGlobalScopeTypeId;
use dom::eventtarget::{EventTarget, EventTargetHelpers, EventTargetTypeId};
use dom::messageevent::MessageEvent;
use dom::worker::{Worker, TrustedWorkerAddress};
use dom::workerglobalscope::DedicatedGlobalScope;
use dom::workerglobalscope::{WorkerGlobalScope, WorkerGlobalScopeHelpers};
use dom::workerglobalscope::WorkerGlobalScopeTypeId;
use dom::xmlhttprequest::XMLHttpRequest;
use script_task::{ScriptTask, ScriptChan};
use script_task::{ScriptMsg, FromWorker, DOMMessage, FireTimerMsg, XHRProgressMsg, XHRReleaseMsg, WorkerRelease};
use script_task::WorkerPostMessage;
use script_task::{ScriptTask, ScriptChan, ScriptMsg, TimerSource};
use script_task::ScriptMsg::{DOMMessage, FireTimerMsg, XHRProgressMsg};
use script_task::ScriptMsg::{XHRReleaseMsg, WorkerRelease, WorkerPostMessage};
use script_task::StackRootTLS;
use servo_net::resource_task::{ResourceTask, load_whole_resource};
@ -57,8 +57,8 @@ impl DedicatedWorkerGlobalScope {
-> DedicatedWorkerGlobalScope {
DedicatedWorkerGlobalScope {
workerglobalscope: WorkerGlobalScope::new_inherited(
DedicatedGlobalScope, worker_url, cx, resource_task,
own_sender),
WorkerGlobalScopeTypeId::DedicatedGlobalScope, worker_url, cx,
resource_task, own_sender),
receiver: receiver,
parent_sender: parent_sender,
worker: worker,
@ -145,7 +145,7 @@ impl DedicatedWorkerGlobalScope {
Ok(WorkerRelease(addr)) => {
Worker::handle_release(addr)
},
Ok(FireTimerMsg(FromWorker, timer_id)) => {
Ok(FireTimerMsg(TimerSource::FromWorker, timer_id)) => {
scope.handle_fire_timer(timer_id);
}
Ok(_) => panic!("Unexpected message"),
@ -197,7 +197,7 @@ impl Reflectable for DedicatedWorkerGlobalScope {
impl DedicatedWorkerGlobalScopeDerived for EventTarget {
fn is_dedicatedworkerglobalscope(&self) -> bool {
match *self.type_id() {
WorkerGlobalScopeTypeId(DedicatedGlobalScope) => true,
EventTargetTypeId::WorkerGlobalScope(WorkerGlobalScopeTypeId::DedicatedGlobalScope) => true,
_ => false
}
}

74
components/script/dom/document.rs
View file

@ -2,11 +2,10 @@
* 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::attr::{Attr, AttrHelpers, StringAttrValue};
use dom::attr::{Attr, AttrHelpers, AttrValue};
use dom::bindings::cell::DOMRefCell;
use dom::bindings::codegen::Bindings::DocumentBinding;
use dom::bindings::codegen::Bindings::DocumentBinding::{DocumentMethods, DocumentReadyState};
use dom::bindings::codegen::Bindings::DocumentBinding::DocumentReadyStateValues;
use dom::bindings::codegen::Bindings::EventHandlerBinding::EventHandlerNonNull;
use dom::bindings::codegen::Bindings::EventTargetBinding::EventTargetMethods;
use dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
@ -20,24 +19,25 @@ use dom::bindings::codegen::InheritTypes::{HTMLAnchorElementDerived, HTMLAppletE
use dom::bindings::codegen::InheritTypes::{HTMLAreaElementDerived, HTMLEmbedElementDerived};
use dom::bindings::codegen::InheritTypes::{HTMLFormElementDerived, HTMLImageElementDerived};
use dom::bindings::codegen::InheritTypes::{HTMLScriptElementDerived};
use dom::bindings::error::{ErrorResult, Fallible, NotSupported, InvalidCharacter};
use dom::bindings::error::{HierarchyRequest, NamespaceError};
use dom::bindings::error::{ErrorResult, Fallible};
use dom::bindings::error::Error::{NotSupported, InvalidCharacter};
use dom::bindings::error::Error::{HierarchyRequest, NamespaceError};
use dom::bindings::global::GlobalRef;
use dom::bindings::global;
use dom::bindings::js::{MutNullableJS, JS, JSRef, Temporary, OptionalSettable, TemporaryPushable};
use dom::bindings::js::OptionalRootable;
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::bindings::utils::{xml_name_type, InvalidXMLName, Name, QName};
use dom::bindings::utils::xml_name_type;
use dom::bindings::utils::XMLName::{QName, Name, InvalidXMLName};
use dom::comment::Comment;
use dom::customevent::CustomEvent;
use dom::documentfragment::DocumentFragment;
use dom::documenttype::DocumentType;
use dom::domimplementation::DOMImplementation;
use dom::element::{Element, ScriptCreated, AttributeHandlers, get_attribute_parts};
use dom::element::{HTMLHeadElementTypeId, HTMLTitleElementTypeId};
use dom::element::{HTMLBodyElementTypeId, HTMLFrameSetElementTypeId};
use dom::event::{Event, DoesNotBubble, NotCancelable};
use dom::eventtarget::{EventTarget, NodeTargetTypeId, EventTargetHelpers};
use dom::element::{Element, ElementCreator, AttributeHandlers, get_attribute_parts};
use dom::element::ElementTypeId;
use dom::event::{Event, EventBubbles, EventCancelable};
use dom::eventtarget::{EventTarget, EventTargetTypeId, EventTargetHelpers};
use dom::htmlanchorelement::HTMLAnchorElement;
use dom::htmlcollection::{HTMLCollection, CollectionFilter};
use dom::htmlelement::HTMLElement;
@ -48,8 +48,7 @@ use dom::location::Location;
use dom::mouseevent::MouseEvent;
use dom::keyboardevent::KeyboardEvent;
use dom::messageevent::MessageEvent;
use dom::node::{Node, ElementNodeTypeId, DocumentNodeTypeId, NodeHelpers};
use dom::node::{CloneChildren, DoNotCloneChildren, NodeDamage, OtherNodeDamage};
use dom::node::{Node, NodeHelpers, NodeTypeId, CloneChildrenFlag, NodeDamage};
use dom::nodelist::NodeList;
use dom::text::Text;
use dom::processinginstruction::ProcessingInstruction;
@ -107,7 +106,7 @@ pub struct Document {
impl DocumentDerived for EventTarget {
fn is_document(&self) -> bool {
*self.type_id() == NodeTargetTypeId(DocumentNodeTypeId)
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Document)
}
}
@ -341,7 +340,8 @@ impl<'a> DocumentHelpers<'a> for JSRef<'a, Document> {
let window = self.window.root();
let event = Event::new(global::Window(*window), "readystatechange".to_string(),
DoesNotBubble, NotCancelable).root();
EventBubbles::DoesNotBubble,
EventCancelable::NotCancelable).root();
let target: JSRef<EventTarget> = EventTargetCast::from_ref(self);
let _ = target.DispatchEvent(*event);
}
@ -379,7 +379,7 @@ impl<'a> DocumentHelpers<'a> for JSRef<'a, Document> {
fn dirty_all_nodes(self) {
let root: JSRef<Node> = NodeCast::from_ref(self);
for node in root.traverse_preorder() {
node.dirty(OtherNodeDamage)
node.dirty(NodeDamage::OtherNodeDamage)
}
}
}
@ -410,14 +410,14 @@ impl Document {
source: DocumentSource) -> Document {
let url = url.unwrap_or_else(|| Url::parse("about:blank").unwrap());
let ready_state = if source == FromParser {
DocumentReadyStateValues::Loading
let ready_state = if source == DocumentSource::FromParser {
DocumentReadyState::Loading
} else {
DocumentReadyStateValues::Complete
DocumentReadyState::Complete
};
Document {
node: Node::new_without_doc(DocumentNodeTypeId),
node: Node::new_without_doc(NodeTypeId::Document),
window: JS::from_rooted(window),
idmap: DOMRefCell::new(HashMap::new()),
implementation: Default::default(),
@ -425,9 +425,9 @@ impl Document {
Some(string) => string.clone(),
None => match is_html_document {
// http://dom.spec.whatwg.org/#dom-domimplementation-createhtmldocument
HTMLDocument => "text/html".to_string(),
IsHTMLDocument::HTMLDocument => "text/html".to_string(),
// http://dom.spec.whatwg.org/#concept-document-content-type
NonHTMLDocument => "application/xml".to_string()
IsHTMLDocument::NonHTMLDocument => "application/xml".to_string()
}
},
last_modified: DOMRefCell::new(None),
@ -436,7 +436,7 @@ impl Document {
quirks_mode: Cell::new(NoQuirks),
// http://dom.spec.whatwg.org/#concept-document-encoding
encoding_name: DOMRefCell::new("UTF-8".to_string()),
is_html_document: is_html_document == HTMLDocument,
is_html_document: is_html_document == IsHTMLDocument::HTMLDocument,
images: Default::default(),
embeds: Default::default(),
links: Default::default(),
@ -452,7 +452,9 @@ impl Document {
// http://dom.spec.whatwg.org/#dom-document
pub fn Constructor(global: &GlobalRef) -> Fallible<Temporary<Document>> {
Ok(Document::new(global.as_window(), None, NonHTMLDocument, None, NotFromParser))
Ok(Document::new(global.as_window(), None,
IsHTMLDocument::NonHTMLDocument, None,
DocumentSource::NotFromParser))
}
pub fn new(window: JSRef<Window>,
@ -596,7 +598,7 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
local_name
};
let name = QualName::new(ns!(HTML), Atom::from_slice(local_name.as_slice()));
Ok(Element::create(name, None, self, ScriptCreated))
Ok(Element::create(name, None, self, ElementCreator::ScriptCreated))
}
// http://dom.spec.whatwg.org/#dom-document-createelementns
@ -641,7 +643,7 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
let name = QualName::new(ns, Atom::from_slice(local_name_from_qname));
Ok(Element::create(name, prefix_from_qname.map(|s| s.to_string()), self,
ScriptCreated))
ElementCreator::ScriptCreated))
}
// http://dom.spec.whatwg.org/#dom-document-createattribute
@ -655,7 +657,7 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
let name = Atom::from_slice(local_name.as_slice());
// repetition used because string_cache::atom::Atom is non-copyable
let l_name = Atom::from_slice(local_name.as_slice());
let value = StringAttrValue("".to_string());
let value = AttrValue::String("".to_string());
Ok(Attr::new(*window, name, value, l_name, ns!(""), None, None))
}
@ -702,8 +704,8 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
// Step 2.
let clone_children = match deep {
true => CloneChildren,
false => DoNotCloneChildren
true => CloneChildrenFlag::CloneChildren,
false => CloneChildrenFlag::DoNotCloneChildren
};
Ok(Node::clone(node, Some(self), clone_children))
@ -748,7 +750,7 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
fn LastModified(self) -> DOMString {
match *self.last_modified.borrow() {
Some(ref t) => t.clone(),
None => time::now().strftime("%m/%d/%Y %H:%M:%S").unwrap(),
None => format!("{}", time::now().strftime("%m/%d/%Y %H:%M:%S").unwrap()),
}
}
@ -769,7 +771,7 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
self.GetDocumentElement().root().map(|root| {
let root: JSRef<Node> = NodeCast::from_ref(*root);
root.traverse_preorder()
.find(|node| node.type_id() == ElementNodeTypeId(HTMLTitleElementTypeId))
.find(|node| node.type_id() == NodeTypeId::Element(ElementTypeId::HTMLTitleElement))
.map(|title_elem| {
for text in title_elem.children().filter_map::<JSRef<Text>>(TextCast::to_ref) {
title.push_str(text.characterdata().data().as_slice());
@ -785,11 +787,11 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
self.GetDocumentElement().root().map(|root| {
let root: JSRef<Node> = NodeCast::from_ref(*root);
let head_node = root.traverse_preorder().find(|child| {
child.type_id() == ElementNodeTypeId(HTMLHeadElementTypeId)
child.type_id() == NodeTypeId::Element(ElementTypeId::HTMLHeadElement)
});
head_node.map(|head| {
let title_node = head.children().find(|child| {
child.type_id() == ElementNodeTypeId(HTMLTitleElementTypeId)
child.type_id() == NodeTypeId::Element(ElementTypeId::HTMLTitleElement)
});
match title_node {
@ -834,8 +836,8 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
let node: JSRef<Node> = NodeCast::from_ref(*root);
node.children().find(|child| {
match child.type_id() {
ElementNodeTypeId(HTMLBodyElementTypeId) |
ElementNodeTypeId(HTMLFrameSetElementTypeId) => true,
NodeTypeId::Element(ElementTypeId::HTMLBodyElement) |
NodeTypeId::Element(ElementTypeId::HTMLFrameSetElement) => true,
_ => false
}
}).map(|node| {
@ -854,8 +856,8 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
let node: JSRef<Node> = NodeCast::from_ref(new_body);
match node.type_id() {
ElementNodeTypeId(HTMLBodyElementTypeId) |
ElementNodeTypeId(HTMLFrameSetElementTypeId) => {}
NodeTypeId::Element(ElementTypeId::HTMLBodyElement) |
NodeTypeId::Element(ElementTypeId::HTMLFrameSetElement) => {}
_ => return Err(HierarchyRequest)
}

8
components/script/dom/documentfragment.rs
View file

@ -12,9 +12,9 @@ use dom::bindings::global::GlobalRef;
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::Element;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlcollection::HTMLCollection;
use dom::node::{DocumentFragmentNodeTypeId, Node, NodeHelpers, window_from_node};
use dom::node::{Node, NodeHelpers, NodeTypeId, window_from_node};
use dom::nodelist::NodeList;
use servo_util::str::DOMString;
@ -25,7 +25,7 @@ pub struct DocumentFragment {
impl DocumentFragmentDerived for EventTarget {
fn is_documentfragment(&self) -> bool {
*self.type_id() == NodeTargetTypeId(DocumentFragmentNodeTypeId)
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::DocumentFragment)
}
}
@ -33,7 +33,7 @@ impl DocumentFragment {
/// Creates a new DocumentFragment.
fn new_inherited(document: JSRef<Document>) -> DocumentFragment {
DocumentFragment {
node: Node::new_inherited(DocumentFragmentNodeTypeId, document),
node: Node::new_inherited(NodeTypeId::DocumentFragment, document),
}
}

8
components/script/dom/documenttype.rs
View file

@ -8,8 +8,8 @@ use dom::bindings::codegen::InheritTypes::{DocumentTypeDerived, NodeCast};
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::node::{Node, DoctypeNodeTypeId, NodeHelpers};
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::node::{Node, NodeHelpers, NodeTypeId};
use servo_util::str::DOMString;
/// The `DOCTYPE` tag.
@ -23,7 +23,7 @@ pub struct DocumentType {
impl DocumentTypeDerived for EventTarget {
fn is_documenttype(&self) -> bool {
*self.type_id() == NodeTargetTypeId(DoctypeNodeTypeId)
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::DocumentType)
}
}
@ -34,7 +34,7 @@ impl DocumentType {
document: JSRef<Document>)
-> DocumentType {
DocumentType {
node: Node::new_inherited(DoctypeNodeTypeId, document),
node: Node::new_inherited(NodeTypeId::DocumentType, document),
name: name,
public_id: public_id.unwrap_or("".to_string()),
system_id: system_id.unwrap_or("".to_string())

75
components/script/dom/domexception.rs
View file

@ -5,7 +5,6 @@
use dom::bindings::codegen::Bindings::DOMExceptionBinding;
use dom::bindings::codegen::Bindings::DOMExceptionBinding::DOMExceptionConstants;
use dom::bindings::codegen::Bindings::DOMExceptionBinding::DOMExceptionMethods;
use dom::bindings::error;
use dom::bindings::error::Error;
use dom::bindings::global::GlobalRef;
use dom::bindings::js::{JSRef, Temporary};
@ -42,21 +41,21 @@ pub enum DOMErrorName {
impl DOMErrorName {
fn from_error(error: Error) -> DOMErrorName {
match error {
error::IndexSize => IndexSizeError,
error::NotFound => NotFoundError,
error::HierarchyRequest => HierarchyRequestError,
error::InvalidCharacter => InvalidCharacterError,
error::NotSupported => NotSupportedError,
error::InvalidState => InvalidStateError,
error::Syntax => SyntaxError,
error::NamespaceError => NamespaceError,
error::InvalidAccess => InvalidAccessError,
error::Security => SecurityError,
error::Network => NetworkError,
error::Abort => AbortError,
error::Timeout => TimeoutError,
error::DataClone => DataCloneError,
error::FailureUnknown => panic!(),
Error::IndexSize => DOMErrorName::IndexSizeError,
Error::NotFound => DOMErrorName::NotFoundError,
Error::HierarchyRequest => DOMErrorName::HierarchyRequestError,
Error::InvalidCharacter => DOMErrorName::InvalidCharacterError,
Error::NotSupported => DOMErrorName::NotSupportedError,
Error::InvalidState => DOMErrorName::InvalidStateError,
Error::Syntax => DOMErrorName::SyntaxError,
Error::NamespaceError => DOMErrorName::NamespaceError,
Error::InvalidAccess => DOMErrorName::InvalidAccessError,
Error::Security => DOMErrorName::SecurityError,
Error::Network => DOMErrorName::NetworkError,
Error::Abort => DOMErrorName::AbortError,
Error::Timeout => DOMErrorName::TimeoutError,
Error::DataClone => DOMErrorName::DataCloneError,
Error::FailureUnknown => panic!(),
}
}
}
@ -95,7 +94,7 @@ impl<'a> DOMExceptionMethods for JSRef<'a, DOMException> {
fn Code(self) -> u16 {
match self.code {
// http://dom.spec.whatwg.org/#concept-throw
EncodingError => 0,
DOMErrorName::EncodingError => 0,
code => code as u16
}
}
@ -108,27 +107,27 @@ impl<'a> DOMExceptionMethods for JSRef<'a, DOMException> {
// http://dom.spec.whatwg.org/#error-names-0
fn Message(self) -> DOMString {
let message = match self.code {
IndexSizeError => "The index is not in the allowed range.",
HierarchyRequestError => "The operation would yield an incorrect node tree.",
WrongDocumentError => "The object is in the wrong document.",
InvalidCharacterError => "The string contains invalid characters.",
NoModificationAllowedError => "The object can not be modified.",
NotFoundError => "The object can not be found here.",
NotSupportedError => "The operation is not supported.",
InvalidStateError => "The object is in an invalid state.",
SyntaxError => "The string did not match the expected pattern.",
InvalidModificationError => "The object can not be modified in this way.",
NamespaceError => "The operation is not allowed by Namespaces in XML.",
InvalidAccessError => "The object does not support the operation or argument.",
SecurityError => "The operation is insecure.",
NetworkError => "A network error occurred.",
AbortError => "The operation was aborted.",
URLMismatchError => "The given URL does not match another URL.",
QuotaExceededError => "The quota has been exceeded.",
TimeoutError => "The operation timed out.",
InvalidNodeTypeError => "The supplied node is incorrect or has an incorrect ancestor for this operation.",
DataCloneError => "The object can not be cloned.",
EncodingError => "The encoding operation (either encoded or decoding) failed."
DOMErrorName::IndexSizeError => "The index is not in the allowed range.",
DOMErrorName::HierarchyRequestError => "The operation would yield an incorrect node tree.",
DOMErrorName::WrongDocumentError => "The object is in the wrong document.",
DOMErrorName::InvalidCharacterError => "The string contains invalid characters.",
DOMErrorName::NoModificationAllowedError => "The object can not be modified.",
DOMErrorName::NotFoundError => "The object can not be found here.",
DOMErrorName::NotSupportedError => "The operation is not supported.",
DOMErrorName::InvalidStateError => "The object is in an invalid state.",
DOMErrorName::SyntaxError => "The string did not match the expected pattern.",
DOMErrorName::InvalidModificationError => "The object can not be modified in this way.",
DOMErrorName::NamespaceError => "The operation is not allowed by Namespaces in XML.",
DOMErrorName::InvalidAccessError => "The object does not support the operation or argument.",
DOMErrorName::SecurityError => "The operation is insecure.",
DOMErrorName::NetworkError => "A network error occurred.",
DOMErrorName::AbortError => "The operation was aborted.",
DOMErrorName::URLMismatchError => "The given URL does not match another URL.",
DOMErrorName::QuotaExceededError => "The quota has been exceeded.",
DOMErrorName::TimeoutError => "The operation timed out.",
DOMErrorName::InvalidNodeTypeError => "The supplied node is incorrect or has an incorrect ancestor for this operation.",
DOMErrorName::DataCloneError => "The object can not be cloned.",
DOMErrorName::EncodingError => "The encoding operation (either encoded or decoding) failed."
};
message.to_string()

16
components/script/dom/domimplementation.rs
View file

@ -7,13 +7,15 @@ use dom::bindings::codegen::Bindings::DOMImplementationBinding;
use dom::bindings::codegen::Bindings::DOMImplementationBinding::DOMImplementationMethods;
use dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
use dom::bindings::codegen::InheritTypes::NodeCast;
use dom::bindings::error::{Fallible, InvalidCharacter, NamespaceError};
use dom::bindings::error::Fallible;
use dom::bindings::error::Error::{InvalidCharacter, NamespaceError};
use dom::bindings::global::Window;
use dom::bindings::js::{JS, JSRef, Root, Temporary, OptionalRootable};
use dom::bindings::utils::{Reflector, Reflectable, reflect_dom_object};
use dom::bindings::utils::{QName, Name, InvalidXMLName, xml_name_type};
use dom::document::{Document, DocumentHelpers, HTMLDocument, NonHTMLDocument};
use dom::document::NotFromParser;
use dom::bindings::utils::xml_name_type;
use dom::bindings::utils::XMLName::{QName, Name, InvalidXMLName};
use dom::document::{Document, DocumentHelpers, IsHTMLDocument};
use dom::document::DocumentSource;
use dom::documenttype::DocumentType;
use dom::htmlbodyelement::HTMLBodyElement;
use dom::htmlheadelement::HTMLHeadElement;
@ -75,7 +77,8 @@ impl<'a> DOMImplementationMethods for JSRef<'a, DOMImplementation> {
let win = doc.window().root();
// Step 1.
let doc = Document::new(*win, None, NonHTMLDocument, None, NotFromParser).root();
let doc = Document::new(*win, None, IsHTMLDocument::NonHTMLDocument,
None, DocumentSource::NotFromParser).root();
// Step 2-3.
let maybe_elem = if qname.is_empty() {
None
@ -120,7 +123,8 @@ impl<'a> DOMImplementationMethods for JSRef<'a, DOMImplementation> {
let win = document.window().root();
// Step 1-2.
let doc = Document::new(*win, None, HTMLDocument, None, NotFromParser).root();
let doc = Document::new(*win, None, IsHTMLDocument::HTMLDocument, None,
DocumentSource::NotFromParser).root();
let doc_node: JSRef<Node> = NodeCast::from_ref(*doc);
{

25
components/script/dom/domparser.rs
View file

@ -2,17 +2,18 @@
* 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::bindings::codegen::Bindings::DocumentBinding::DocumentReadyStateValues;
use dom::bindings::codegen::Bindings::DocumentBinding::DocumentReadyState;
use dom::bindings::codegen::Bindings::DOMParserBinding;
use dom::bindings::codegen::Bindings::DOMParserBinding::DOMParserMethods;
use dom::bindings::codegen::Bindings::DOMParserBinding::SupportedTypeValues::{Text_html, Text_xml};
use dom::bindings::error::{Fallible, FailureUnknown};
use dom::bindings::codegen::Bindings::DOMParserBinding::SupportedType::{Text_html, Text_xml};
use dom::bindings::error::Fallible;
use dom::bindings::error::Error::FailureUnknown;
use dom::bindings::global::GlobalRef;
use dom::bindings::global;
use dom::bindings::js::{JS, JSRef, Temporary};
use dom::bindings::utils::{Reflector, Reflectable, reflect_dom_object};
use dom::document::{Document, DocumentHelpers, HTMLDocument, NonHTMLDocument};
use dom::document::{FromParser, NotFromParser};
use dom::document::{Document, DocumentHelpers, IsHTMLDocument};
use dom::document::DocumentSource;
use dom::servohtmlparser::ServoHTMLParser;
use dom::window::Window;
use parse::Parser;
@ -53,18 +54,22 @@ impl<'a> DOMParserMethods for JSRef<'a, DOMParser> {
let content_type = DOMParserBinding::SupportedTypeValues::strings[ty as uint].to_string();
match ty {
Text_html => {
let document = Document::new(window, url.clone(), HTMLDocument,
Some(content_type), FromParser).root().clone();
let document = Document::new(window, url.clone(),
IsHTMLDocument::HTMLDocument,
Some(content_type),
DocumentSource::FromParser).root().clone();
let parser = ServoHTMLParser::new(url.clone(), document).root().clone();
parser.parse_chunk(s);
parser.finish();
document.set_ready_state(DocumentReadyStateValues::Complete);
document.set_ready_state(DocumentReadyState::Complete);
Ok(Temporary::from_rooted(document))
}
Text_xml => {
//FIXME: this should probably be FromParser when we actually parse the string (#3756).
Ok(Document::new(window, url.clone(), NonHTMLDocument, Some(content_type),
NotFromParser))
Ok(Document::new(window, url.clone(),
IsHTMLDocument::NonHTMLDocument,
Some(content_type),
DocumentSource::NotFromParser))
}
_ => {
Err(FailureUnknown)

1
components/script/dom/domrect.rs
View file

@ -9,6 +9,7 @@ use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::window::Window;
use servo_util::geometry::Au;
use std::num::Float;
#[dom_struct]
pub struct DOMRect {

3
components/script/dom/domtokenlist.rs
View file

@ -5,7 +5,8 @@
use dom::attr::{Attr, AttrHelpers};
use dom::bindings::codegen::Bindings::DOMTokenListBinding;
use dom::bindings::codegen::Bindings::DOMTokenListBinding::DOMTokenListMethods;
use dom::bindings::error::{Fallible, InvalidCharacter, Syntax};
use dom::bindings::error::Fallible;
use dom::bindings::error::Error::{InvalidCharacter, Syntax};
use dom::bindings::global::Window;
use dom::bindings::js::{JS, JSRef, Temporary, OptionalRootable};
use dom::bindings::utils::{Reflector, Reflectable, reflect_dom_object};

226
components/script/dom/element.rs
View file

@ -5,8 +5,8 @@
//! Element nodes.
use dom::activation::Activatable;
use dom::attr::{Attr, ReplacedAttr, FirstSetAttr, AttrHelpers, AttrHelpersForLayout};
use dom::attr::{AttrValue, StringAttrValue, UIntAttrValue, AtomAttrValue};
use dom::attr::{Attr, AttrSettingType, AttrHelpers, AttrHelpersForLayout};
use dom::attr::AttrValue;
use dom::namednodemap::NamedNodeMap;
use dom::bindings::cell::DOMRefCell;
use dom::bindings::codegen::Bindings::AttrBinding::AttrMethods;
@ -21,18 +21,20 @@ use dom::bindings::codegen::InheritTypes::{HTMLInputElementDerived, HTMLTableEle
use dom::bindings::codegen::InheritTypes::{HTMLTableElementDerived, HTMLTableCellElementDerived};
use dom::bindings::codegen::InheritTypes::{HTMLTableRowElementDerived, HTMLTextAreaElementDerived};
use dom::bindings::codegen::InheritTypes::{HTMLTableSectionElementDerived, NodeCast};
use dom::bindings::error::{ErrorResult, Fallible};
use dom::bindings::error::Error::{NamespaceError, InvalidCharacter, Syntax};
use dom::bindings::js::{MutNullableJS, JS, JSRef, Temporary, TemporaryPushable};
use dom::bindings::js::{OptionalRootable, Root};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::bindings::error::{ErrorResult, Fallible, NamespaceError, InvalidCharacter, Syntax};
use dom::bindings::utils::{QName, Name, InvalidXMLName, xml_name_type};
use dom::bindings::utils::xml_name_type;
use dom::bindings::utils::XMLName::{QName, Name, InvalidXMLName};
use dom::create::create_element;
use dom::domrect::DOMRect;
use dom::domrectlist::DOMRectList;
use dom::document::{Document, DocumentHelpers, LayoutDocumentHelpers};
use dom::domtokenlist::DOMTokenList;
use dom::event::Event;
use dom::eventtarget::{EventTarget, NodeTargetTypeId, EventTargetHelpers};
use dom::eventtarget::{EventTarget, EventTargetTypeId, EventTargetHelpers};
use dom::htmlbodyelement::{HTMLBodyElement, HTMLBodyElementHelpers};
use dom::htmlcollection::HTMLCollection;
use dom::htmlinputelement::{HTMLInputElement, RawLayoutHTMLInputElementHelpers, HTMLInputElementHelpers};
@ -42,16 +44,14 @@ use dom::htmltablecellelement::{HTMLTableCellElement, HTMLTableCellElementHelper
use dom::htmltablerowelement::{HTMLTableRowElement, HTMLTableRowElementHelpers};
use dom::htmltablesectionelement::{HTMLTableSectionElement, HTMLTableSectionElementHelpers};
use dom::htmltextareaelement::{HTMLTextAreaElement, RawLayoutHTMLTextAreaElementHelpers};
use dom::node::{CLICK_IN_PROGRESS, ElementNodeTypeId, LayoutNodeHelpers, Node, NodeHelpers};
use dom::node::{NodeIterator, NodeStyleDamaged, OtherNodeDamage, document_from_node};
use dom::node::{CLICK_IN_PROGRESS, LayoutNodeHelpers, Node, NodeHelpers, NodeTypeId};
use dom::node::{NodeIterator, document_from_node, NodeDamage};
use dom::node::{window_from_node};
use dom::nodelist::NodeList;
use dom::virtualmethods::{VirtualMethods, vtable_for};
use devtools_traits::AttrInfo;
use style::{mod, AuthorOrigin, BgColorSimpleColorAttribute, BorderUnsignedIntegerAttribute};
use style::{ColSpanUnsignedIntegerAttribute, IntegerAttribute, LengthAttribute, ParserContext};
use style::{SimpleColorAttribute, SizeIntegerAttribute, ColsIntegerAttribute, RowsIntegerAttribute};
use style::{UnsignedIntegerAttribute, WidthLengthAttribute, matches};
use style::{mod, StylesheetOrigin, SimpleColorAttribute, UnsignedIntegerAttribute};
use style::{IntegerAttribute, LengthAttribute, ParserContext, matches};
use servo_util::namespace;
use servo_util::str::{DOMString, LengthOrPercentageOrAuto};
@ -79,7 +79,7 @@ impl ElementDerived for EventTarget {
#[inline]
fn is_element(&self) -> bool {
match *self.type_id() {
NodeTargetTypeId(ElementNodeTypeId(_)) => true,
EventTargetTypeId::Node(NodeTypeId::Element(_)) => true,
_ => false
}
}
@ -94,75 +94,75 @@ impl Reflectable for Element {
#[deriving(PartialEq, Show)]
#[jstraceable]
pub enum ElementTypeId {
HTMLElementTypeId,
HTMLAnchorElementTypeId,
HTMLAppletElementTypeId,
HTMLAreaElementTypeId,
HTMLAudioElementTypeId,
HTMLBaseElementTypeId,
HTMLBRElementTypeId,
HTMLBodyElementTypeId,
HTMLButtonElementTypeId,
HTMLCanvasElementTypeId,
HTMLDataElementTypeId,
HTMLDataListElementTypeId,
HTMLDirectoryElementTypeId,
HTMLDListElementTypeId,
HTMLDivElementTypeId,
HTMLEmbedElementTypeId,
HTMLFieldSetElementTypeId,
HTMLFontElementTypeId,
HTMLFormElementTypeId,
HTMLFrameElementTypeId,
HTMLFrameSetElementTypeId,
HTMLHRElementTypeId,
HTMLHeadElementTypeId,
HTMLHeadingElementTypeId,
HTMLHtmlElementTypeId,
HTMLIFrameElementTypeId,
HTMLImageElementTypeId,
HTMLInputElementTypeId,
HTMLLabelElementTypeId,
HTMLLegendElementTypeId,
HTMLLinkElementTypeId,
HTMLLIElementTypeId,
HTMLMapElementTypeId,
HTMLMediaElementTypeId,
HTMLMetaElementTypeId,
HTMLMeterElementTypeId,
HTMLModElementTypeId,
HTMLObjectElementTypeId,
HTMLOListElementTypeId,
HTMLOptGroupElementTypeId,
HTMLOptionElementTypeId,
HTMLOutputElementTypeId,
HTMLParagraphElementTypeId,
HTMLParamElementTypeId,
HTMLPreElementTypeId,
HTMLProgressElementTypeId,
HTMLQuoteElementTypeId,
HTMLScriptElementTypeId,
HTMLSelectElementTypeId,
HTMLSourceElementTypeId,
HTMLSpanElementTypeId,
HTMLStyleElementTypeId,
HTMLTableElementTypeId,
HTMLTableCaptionElementTypeId,
HTMLTableDataCellElementTypeId,
HTMLTableHeaderCellElementTypeId,
HTMLTableColElementTypeId,
HTMLTableRowElementTypeId,
HTMLTableSectionElementTypeId,
HTMLTemplateElementTypeId,
HTMLTextAreaElementTypeId,
HTMLTimeElementTypeId,
HTMLTitleElementTypeId,
HTMLTrackElementTypeId,
HTMLUListElementTypeId,
HTMLVideoElementTypeId,
HTMLUnknownElementTypeId,
HTMLElement,
HTMLAnchorElement,
HTMLAppletElement,
HTMLAreaElement,
HTMLAudioElement,
HTMLBaseElement,
HTMLBRElement,
HTMLBodyElement,
HTMLButtonElement,
HTMLCanvasElement,
HTMLDataElement,
HTMLDataListElement,
HTMLDirectoryElement,
HTMLDListElement,
HTMLDivElement,
HTMLEmbedElement,
HTMLFieldSetElement,
HTMLFontElement,
HTMLFormElement,
HTMLFrameElement,
HTMLFrameSetElement,
HTMLHRElement,
HTMLHeadElement,
HTMLHeadingElement,
HTMLHtmlElement,
HTMLIFrameElement,
HTMLImageElement,
HTMLInputElement,
HTMLLabelElement,
HTMLLegendElement,
HTMLLinkElement,
HTMLLIElement,
HTMLMapElement,
HTMLMediaElement,
HTMLMetaElement,
HTMLMeterElement,
HTMLModElement,
HTMLObjectElement,
HTMLOListElement,
HTMLOptGroupElement,
HTMLOptionElement,
HTMLOutputElement,
HTMLParagraphElement,
HTMLParamElement,
HTMLPreElement,
HTMLProgressElement,
HTMLQuoteElement,
HTMLScriptElement,
HTMLSelectElement,
HTMLSourceElement,
HTMLSpanElement,
HTMLStyleElement,
HTMLTableElement,
HTMLTableCaptionElement,
HTMLTableDataCellElement,
HTMLTableHeaderCellElement,
HTMLTableColElement,
HTMLTableRowElement,
HTMLTableSectionElement,
HTMLTemplateElement,
HTMLTextAreaElement,
HTMLTimeElement,
HTMLTitleElement,
HTMLTrackElement,
HTMLUListElement,
HTMLVideoElement,
HTMLUnknownElement,
ElementTypeId_,
Element,
}
#[deriving(PartialEq)]
@ -183,7 +183,7 @@ impl Element {
pub fn new_inherited(type_id: ElementTypeId, local_name: DOMString, namespace: Namespace, prefix: Option<DOMString>, document: JSRef<Document>) -> Element {
Element {
node: Node::new_inherited(ElementNodeTypeId(type_id), document),
node: Node::new_inherited(NodeTypeId::Element(type_id), document),
local_name: Atom::from_slice(local_name.as_slice()),
namespace: namespace,
prefix: prefix,
@ -195,7 +195,7 @@ impl Element {
}
pub fn new(local_name: DOMString, namespace: Namespace, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<Element> {
Node::reflect_node(box Element::new_inherited(ElementTypeId_, local_name, namespace, prefix, document),
Node::reflect_node(box Element::new_inherited(ElementTypeId::Element, local_name, namespace, prefix, document),
document, ElementBinding::Wrap)
}
}
@ -300,7 +300,7 @@ impl RawLayoutElementHelpers for Element {
unsafe fn get_length_attribute_for_layout(&self, length_attribute: LengthAttribute)
-> LengthOrPercentageOrAuto {
match length_attribute {
WidthLengthAttribute => {
LengthAttribute::Width => {
if self.is_htmltableelement() {
let this: &HTMLTableElement = mem::transmute(self);
this.get_width()
@ -318,21 +318,21 @@ impl RawLayoutElementHelpers for Element {
unsafe fn get_integer_attribute_for_layout(&self, integer_attribute: IntegerAttribute)
-> Option<i32> {
match integer_attribute {
SizeIntegerAttribute => {
IntegerAttribute::Size => {
if !self.is_htmlinputelement() {
panic!("I'm not a form input!")
}
let this: &HTMLInputElement = mem::transmute(self);
Some(this.get_size_for_layout() as i32)
}
ColsIntegerAttribute => {
IntegerAttribute::Cols => {
if !self.is_htmltextareaelement() {
panic!("I'm not a textarea element!")
}
let this: &HTMLTextAreaElement = mem::transmute(self);
Some(this.get_cols_for_layout() as i32)
}
RowsIntegerAttribute => {
IntegerAttribute::Rows => {
if !self.is_htmltextareaelement() {
panic!("I'm not a textarea element!")
}
@ -369,7 +369,7 @@ impl RawLayoutElementHelpers for Element {
attribute: UnsignedIntegerAttribute)
-> Option<u32> {
match attribute {
BorderUnsignedIntegerAttribute => {
UnsignedIntegerAttribute::BorderUnsignedIntegerAttribute => {
if self.is_htmltableelement() {
let this: &HTMLTableElement = mem::transmute(self);
this.get_border()
@ -379,7 +379,7 @@ impl RawLayoutElementHelpers for Element {
None
}
}
ColSpanUnsignedIntegerAttribute => {
UnsignedIntegerAttribute::ColSpanUnsignedIntegerAttribute => {
if self.is_htmltablecellelement() {
let this: &HTMLTableCellElement = mem::transmute(self);
this.get_colspan()
@ -397,7 +397,7 @@ impl RawLayoutElementHelpers for Element {
unsafe fn get_simple_color_attribute_for_layout(&self, attribute: SimpleColorAttribute)
-> Option<RGBA> {
match attribute {
BgColorSimpleColorAttribute => {
SimpleColorAttribute::BgColorSimpleColorAttribute => {
if self.is_htmlbodyelement() {
let this: &HTMLBodyElement = mem::transmute(self);
this.get_background_color()
@ -612,13 +612,13 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
.map(|attr| attr.root())
.position(|attr| cb(*attr));
let (idx, set_type) = match idx {
Some(idx) => (idx, ReplacedAttr),
Some(idx) => (idx, AttrSettingType::ReplacedAttr),
None => {
let window = window_from_node(self).root();
let attr = Attr::new(*window, local_name, value.clone(),
name, namespace.clone(), prefix, Some(self));
self.attrs.borrow_mut().push_unrooted(&attr);
(self.attrs.borrow().len() - 1, FirstSetAttr)
(self.attrs.borrow().len() - 1, AttrSettingType::FirstSetAttr)
}
};
@ -631,7 +631,7 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
vtable_for(&NodeCast::from_ref(self))
.parse_plain_attribute(local_name, value)
} else {
StringAttrValue(value)
AttrValue::String(value)
}
}
@ -657,9 +657,9 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
if node.is_in_doc() {
let document = document_from_node(self).root();
if local_name == atom!("style") {
document.content_changed(node, NodeStyleDamaged);
document.content_changed(node, NodeDamage::NodeStyleDamaged);
} else {
document.content_changed(node, OtherNodeDamage);
document.content_changed(node, NodeDamage::OtherNodeDamage);
}
}
}
@ -725,7 +725,7 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
}
fn set_string_attribute(self, name: &Atom, value: DOMString) {
assert!(name.as_slice() == name.as_slice().to_ascii_lower().as_slice());
self.set_attribute(name, StringAttrValue(value));
self.set_attribute(name, AttrValue::String(value));
}
fn set_tokenlist_attribute(self, name: &Atom, value: DOMString) {
@ -741,8 +741,8 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
match attribute {
Some(attribute) => {
match *attribute.value() {
UIntAttrValue(_, value) => value,
_ => panic!("Expected a UIntAttrValue: \
AttrValue::UInt(_, value) => value,
_ => panic!("Expected an AttrValue::UInt: \
implement parse_plain_attribute"),
}
}
@ -751,7 +751,7 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
}
fn set_uint_attribute(self, name: &Atom, value: u32) {
assert!(name.as_slice() == name.as_slice().to_ascii_lower().as_slice());
self.set_attribute(name, UIntAttrValue(value.to_string(), value));
self.set_attribute(name, AttrValue::UInt(value.to_string(), value));
}
}
@ -1049,7 +1049,7 @@ impl<'a> ElementMethods for JSRef<'a, Element> {
// http://dom.spec.whatwg.org/#dom-element-matches
fn Matches(self, selectors: DOMString) -> Fallible<bool> {
let parser_context = ParserContext {
origin: AuthorOrigin,
origin: StylesheetOrigin::Author,
};
match style::parse_selector_list_from_str(&parser_context, selectors.as_slice()) {
Err(()) => Err(Syntax),
@ -1097,7 +1097,7 @@ impl<'a> VirtualMethods for JSRef<'a, Element> {
*self.style_attribute.borrow_mut() = style;
if node.is_in_doc() {
doc.content_changed(node, NodeStyleDamaged);
doc.content_changed(node, NodeDamage::NodeStyleDamaged);
}
}
&atom!("class") => {
@ -1105,7 +1105,7 @@ impl<'a> VirtualMethods for JSRef<'a, Element> {
let node: JSRef<Node> = NodeCast::from_ref(*self);
if node.is_in_doc() {
let document = document_from_node(*self).root();
document.content_changed(node, NodeStyleDamaged);
document.content_changed(node, NodeDamage::NodeStyleDamaged);
}
}
&atom!("id") => {
@ -1118,7 +1118,7 @@ impl<'a> VirtualMethods for JSRef<'a, Element> {
let value = Atom::from_slice(value.as_slice());
doc.register_named_element(*self, value);
}
doc.content_changed(node, NodeStyleDamaged);
doc.content_changed(node, NodeDamage::NodeStyleDamaged);
}
}
_ => {
@ -1126,7 +1126,7 @@ impl<'a> VirtualMethods for JSRef<'a, Element> {
let node: JSRef<Node> = NodeCast::from_ref(*self);
if node.is_in_doc() {
let document = document_from_node(*self).root();
document.content_changed(node, OtherNodeDamage);
document.content_changed(node, NodeDamage::OtherNodeDamage);
}
}
}
@ -1146,7 +1146,7 @@ impl<'a> VirtualMethods for JSRef<'a, Element> {
let node: JSRef<Node> = NodeCast::from_ref(*self);
if node.is_in_doc() {
let doc = document_from_node(*self).root();
doc.content_changed(node, NodeStyleDamaged);
doc.content_changed(node, NodeDamage::NodeStyleDamaged);
}
}
&atom!("id") => {
@ -1159,7 +1159,7 @@ impl<'a> VirtualMethods for JSRef<'a, Element> {
let value = Atom::from_slice(value.as_slice());
doc.unregister_named_element(*self, value);
}
doc.content_changed(node, NodeStyleDamaged);
doc.content_changed(node, NodeDamage::NodeStyleDamaged);
}
}
&atom!("class") => {
@ -1167,7 +1167,7 @@ impl<'a> VirtualMethods for JSRef<'a, Element> {
let node: JSRef<Node> = NodeCast::from_ref(*self);
if node.is_in_doc() {
let document = document_from_node(*self).root();
document.content_changed(node, NodeStyleDamaged);
document.content_changed(node, NodeDamage::NodeStyleDamaged);
}
}
_ => {
@ -1175,7 +1175,7 @@ impl<'a> VirtualMethods for JSRef<'a, Element> {
let node: JSRef<Node> = NodeCast::from_ref(*self);
if node.is_in_doc() {
let doc = document_from_node(*self).root();
doc.content_changed(node, OtherNodeDamage);
doc.content_changed(node, NodeDamage::OtherNodeDamage);
}
}
}
@ -1251,9 +1251,9 @@ impl<'a> style::TElement<'a> for JSRef<'a, Element> {
match node.type_id() {
// http://www.whatwg.org/specs/web-apps/current-work/multipage/selectors.html#
// selector-link
ElementNodeTypeId(HTMLAnchorElementTypeId) |
ElementNodeTypeId(HTMLAreaElementTypeId) |
ElementNodeTypeId(HTMLLinkElementTypeId) => self.get_attr(&ns!(""), &atom!("href")),
NodeTypeId::Element(ElementTypeId::HTMLAnchorElement) |
NodeTypeId::Element(ElementTypeId::HTMLAreaElement) |
NodeTypeId::Element(ElementTypeId::HTMLLinkElement) => self.get_attr(&ns!(""), &atom!("href")),
_ => None,
}
}
@ -1283,8 +1283,8 @@ impl<'a> style::TElement<'a> for JSRef<'a, Element> {
self.get_attribute(ns!(""), &atom!("id")).map(|attr| {
let attr = attr.root();
match *attr.value() {
AtomAttrValue(ref val) => val.clone(),
_ => panic!("`id` attribute should be AtomAttrValue"),
AttrValue::Atom(ref val) => val.clone(),
_ => panic!("`id` attribute should be AttrValue::Atom"),
}
})
}
@ -1357,7 +1357,7 @@ impl<'a> ActivationElementHelpers<'a> for JSRef<'a, Element> {
fn as_maybe_activatable(&'a self) -> Option<&'a Activatable + 'a> {
let node: JSRef<Node> = NodeCast::from_ref(*self);
match node.type_id() {
ElementNodeTypeId(HTMLInputElementTypeId) => {
NodeTypeId::Element(ElementTypeId::HTMLInputElement) => {
let element: &'a JSRef<'a, HTMLInputElement> = HTMLInputElementCast::to_borrowed_ref(self).unwrap();
Some(element as &'a Activatable + 'a)
},

13
components/script/dom/errorevent.rs
View file

@ -13,7 +13,7 @@ use js::jsapi::JSContext;
use dom::bindings::trace::JSTraceable;
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::event::{Event, EventTypeId, ErrorEventTypeId, EventBubbles, Bubbles, DoesNotBubble, EventCancelable, Cancelable, NotCancelable};
use dom::event::{Event, EventTypeId, EventBubbles, EventCancelable};
use servo_util::str::DOMString;
use dom::bindings::cell::DOMRefCell;
@ -32,7 +32,7 @@ pub struct ErrorEvent {
impl ErrorEventDerived for Event {
fn is_errorevent(&self) -> bool {
*self.type_id() == ErrorEventTypeId
*self.type_id() == EventTypeId::ErrorEvent
}
}
@ -49,7 +49,7 @@ impl ErrorEvent {
}
pub fn new_uninitialized(global: &GlobalRef) -> Temporary<ErrorEvent> {
reflect_dom_object(box ErrorEvent::new_inherited(ErrorEventTypeId),
reflect_dom_object(box ErrorEvent::new_inherited(EventTypeId::ErrorEvent),
*global,
ErrorEventBinding::Wrap)
}
@ -65,7 +65,8 @@ impl ErrorEvent {
error: JSVal) -> Temporary<ErrorEvent> {
let ev = ErrorEvent::new_uninitialized(global).root();
let event: JSRef<Event> = EventCast::from_ref(*ev);
event.InitEvent(type_, bubbles == Bubbles, cancelable == Cancelable);
event.InitEvent(type_, bubbles == EventBubbles::Bubbles,
cancelable == EventCancelable::Cancelable);
*ev.message.borrow_mut() = message;
*ev.filename.borrow_mut() = filename;
ev.lineno.set(lineno);
@ -91,9 +92,9 @@ impl ErrorEvent {
let col_num = init.colno.unwrap_or(0);
let bubbles = if init.parent.bubbles { Bubbles } else { DoesNotBubble };
let bubbles = if init.parent.bubbles { EventBubbles::Bubbles } else { EventBubbles::DoesNotBubble };
let cancelable = if init.parent.cancelable { Cancelable } else { NotCancelable };
let cancelable = if init.parent.cancelable { EventCancelable::Cancelable } else { EventCancelable::NotCancelable };
let event = ErrorEvent::new(global, type_,
bubbles, cancelable,

34
components/script/dom/event.rs
View file

@ -18,23 +18,23 @@ use time;
#[jstraceable]
pub enum EventPhase {
PhaseNone = EventConstants::NONE as int,
PhaseCapturing = EventConstants::CAPTURING_PHASE as int,
PhaseAtTarget = EventConstants::AT_TARGET as int,
PhaseBubbling = EventConstants::BUBBLING_PHASE as int,
None = EventConstants::NONE as int,
Capturing = EventConstants::CAPTURING_PHASE as int,
AtTarget = EventConstants::AT_TARGET as int,
Bubbling = EventConstants::BUBBLING_PHASE as int,
}
#[deriving(PartialEq)]
#[jstraceable]
pub enum EventTypeId {
CustomEventTypeId,
HTMLEventTypeId,
KeyboardEventTypeId,
MessageEventTypeId,
MouseEventTypeId,
ProgressEventTypeId,
UIEventTypeId,
ErrorEventTypeId
CustomEvent,
HTMLEvent,
KeyboardEvent,
MessageEvent,
MouseEvent,
ProgressEvent,
UIEvent,
ErrorEvent
}
#[deriving(PartialEq)]
@ -75,7 +75,7 @@ impl Event {
reflector_: Reflector::new(),
current_target: Default::default(),
target: Default::default(),
phase: Cell::new(PhaseNone),
phase: Cell::new(EventPhase::None),
type_: DOMRefCell::new("".to_string()),
canceled: Cell::new(false),
cancelable: Cell::new(false),
@ -90,7 +90,7 @@ impl Event {
}
pub fn new_uninitialized(global: GlobalRef) -> Temporary<Event> {
reflect_dom_object(box Event::new_inherited(HTMLEventTypeId),
reflect_dom_object(box Event::new_inherited(EventTypeId::HTMLEvent),
global,
EventBinding::Wrap)
}
@ -100,15 +100,15 @@ impl Event {
bubbles: EventBubbles,
cancelable: EventCancelable) -> Temporary<Event> {
let event = Event::new_uninitialized(global).root();
event.InitEvent(type_, bubbles == Bubbles, cancelable == Cancelable);
event.InitEvent(type_, bubbles == EventBubbles::Bubbles, cancelable == EventCancelable::Cancelable);
Temporary::from_rooted(*event)
}
pub fn Constructor(global: &GlobalRef,
type_: DOMString,
init: &EventBinding::EventInit) -> Fallible<Temporary<Event>> {
let bubbles = if init.bubbles { Bubbles } else { DoesNotBubble };
let cancelable = if init.cancelable { Cancelable } else { NotCancelable };
let bubbles = if init.bubbles { EventBubbles::Bubbles } else { EventBubbles::DoesNotBubble };
let cancelable = if init.cancelable { EventCancelable::Cancelable } else { EventCancelable::NotCancelable };
Ok(Event::new(*global, type_, bubbles, cancelable))
}

18
components/script/dom/eventdispatcher.rs
View file

@ -2,12 +2,12 @@
* 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::bindings::callback::ReportExceptions;
use dom::bindings::callback::ExceptionHandling::ReportExceptions;
use dom::bindings::codegen::Bindings::EventBinding::EventMethods;
use dom::bindings::codegen::InheritTypes::{EventTargetCast, NodeCast, NodeDerived};
use dom::bindings::js::{JS, JSRef, OptionalRootable, Root};
use dom::eventtarget::{Capturing, Bubbling, EventTarget};
use dom::event::{Event, PhaseAtTarget, PhaseNone, PhaseBubbling, PhaseCapturing};
use dom::eventtarget::{EventTarget, ListenerPhase};
use dom::event::{Event, EventPhase};
use dom::node::{Node, NodeHelpers};
use dom::virtualmethods::vtable_for;
@ -37,13 +37,13 @@ pub fn dispatch_event<'a, 'b>(target: JSRef<'a, EventTarget>,
vec!()
};
event.set_phase(PhaseCapturing);
event.set_phase(EventPhase::Capturing);
//FIXME: The "callback this value" should be currentTarget
/* capturing */
for cur_target in chain.as_slice().iter().rev() {
let stopped = match cur_target.get_listeners_for(type_.as_slice(), Capturing) {
let stopped = match cur_target.get_listeners_for(type_.as_slice(), ListenerPhase::Capturing) {
Some(listeners) => {
event.set_current_target(cur_target.deref().clone());
for listener in listeners.iter() {
@ -67,7 +67,7 @@ pub fn dispatch_event<'a, 'b>(target: JSRef<'a, EventTarget>,
/* at target */
if !event.stop_propagation() {
event.set_phase(PhaseAtTarget);
event.set_phase(EventPhase::AtTarget);
event.set_current_target(target.clone());
let opt_listeners = target.get_listeners(type_.as_slice());
@ -85,10 +85,10 @@ pub fn dispatch_event<'a, 'b>(target: JSRef<'a, EventTarget>,
/* bubbling */
if event.bubbles() && !event.stop_propagation() {
event.set_phase(PhaseBubbling);
event.set_phase(EventPhase::Bubbling);
for cur_target in chain.iter() {
let stopped = match cur_target.get_listeners_for(type_.as_slice(), Bubbling) {
let stopped = match cur_target.get_listeners_for(type_.as_slice(), ListenerPhase::Bubbling) {
Some(listeners) => {
event.set_current_target(cur_target.deref().clone());
for listener in listeners.iter() {
@ -133,7 +133,7 @@ pub fn dispatch_event<'a, 'b>(target: JSRef<'a, EventTarget>,
}
event.set_dispatching(false);
event.set_phase(PhaseNone);
event.set_phase(EventPhase::None);
event.clear_current_target();
!event.DefaultPrevented()

40
components/script/dom/eventtarget.rs
View file

@ -7,14 +7,15 @@ use dom::bindings::cell::DOMRefCell;
use dom::bindings::codegen::Bindings::EventHandlerBinding::EventHandlerNonNull;
use dom::bindings::codegen::Bindings::EventListenerBinding::EventListener;
use dom::bindings::codegen::Bindings::EventTargetBinding::EventTargetMethods;
use dom::bindings::error::{Fallible, InvalidState, report_pending_exception};
use dom::bindings::error::{Fallible, report_pending_exception};
use dom::bindings::error::Error::InvalidState;
use dom::bindings::js::JSRef;
use dom::bindings::utils::{Reflectable, Reflector};
use dom::event::Event;
use dom::eventdispatcher::dispatch_event;
use dom::node::NodeTypeId;
use dom::workerglobalscope::WorkerGlobalScopeId;
use dom::xmlhttprequest::XMLHttpRequestId;
use dom::workerglobalscope::WorkerGlobalScopeTypeId;
use dom::xmlhttprequesteventtarget::XMLHttpRequestEventTargetTypeId;
use dom::virtualmethods::VirtualMethods;
use js::jsapi::{JS_CompileUCFunction, JS_GetFunctionObject, JS_CloneFunctionObject};
use js::jsapi::{JSContext, JSObject};
@ -37,12 +38,12 @@ pub enum ListenerPhase {
#[deriving(PartialEq)]
#[jstraceable]
pub enum EventTargetTypeId {
NodeTargetTypeId(NodeTypeId),
WebSocketTypeId,
WindowTypeId,
WorkerTypeId,
WorkerGlobalScopeTypeId(WorkerGlobalScopeId),
XMLHttpRequestTargetTypeId(XMLHttpRequestId)
Node(NodeTypeId),
WebSocket,
Window,
Worker,
WorkerGlobalScope(WorkerGlobalScopeTypeId),
XMLHttpRequestEventTarget(XMLHttpRequestEventTargetTypeId)
}
#[deriving(PartialEq)]
@ -55,7 +56,8 @@ pub enum EventListenerType {
impl EventListenerType {
fn get_listener(&self) -> EventListener {
match *self {
Additive(listener) | Inline(listener) => listener
EventListenerType::Additive(listener) |
EventListenerType::Inline(listener) => listener
}
}
}
@ -148,7 +150,7 @@ impl<'a> EventTargetHelpers for JSRef<'a, EventTarget> {
let idx = entries.iter().position(|&entry| {
match entry.listener {
Inline(_) => true,
EventListenerType::Inline(_) => true,
_ => false,
}
});
@ -156,7 +158,7 @@ impl<'a> EventTargetHelpers for JSRef<'a, EventTarget> {
match idx {
Some(idx) => {
match listener {
Some(listener) => entries[idx].listener = Inline(listener),
Some(listener) => entries[idx].listener = EventListenerType::Inline(listener),
None => {
entries.remove(idx);
}
@ -165,8 +167,8 @@ impl<'a> EventTargetHelpers for JSRef<'a, EventTarget> {
None => {
if listener.is_some() {
entries.push(EventListenerEntry {
phase: Bubbling,
listener: Inline(listener.unwrap()),
phase: ListenerPhase::Bubbling,
listener: EventListenerType::Inline(listener.unwrap()),
});
}
}
@ -178,7 +180,7 @@ impl<'a> EventTargetHelpers for JSRef<'a, EventTarget> {
let entries = handlers.get(&ty);
entries.and_then(|entries| entries.iter().find(|entry| {
match entry.listener {
Inline(_) => true,
EventListenerType::Inline(_) => true,
_ => false,
}
}).map(|entry| entry.listener.get_listener()))
@ -254,10 +256,10 @@ impl<'a> EventTargetMethods for JSRef<'a, EventTarget> {
Vacant(entry) => entry.set(vec!()),
};
let phase = if capture { Capturing } else { Bubbling };
let phase = if capture { ListenerPhase::Capturing } else { ListenerPhase::Bubbling };
let new_entry = EventListenerEntry {
phase: phase,
listener: Additive(listener)
listener: EventListenerType::Additive(listener)
};
if entry.as_slice().position_elem(&new_entry).is_none() {
entry.push(new_entry);
@ -276,10 +278,10 @@ impl<'a> EventTargetMethods for JSRef<'a, EventTarget> {
let mut handlers = self.handlers.borrow_mut();
let mut entry = handlers.get_mut(&ty);
for entry in entry.iter_mut() {
let phase = if capture { Capturing } else { Bubbling };
let phase = if capture { ListenerPhase::Capturing } else { ListenerPhase::Bubbling };
let old_entry = EventListenerEntry {
phase: phase,
listener: Additive(listener)
listener: EventListenerType::Additive(listener)
};
let position = entry.as_slice().position_elem(&old_entry);
for &position in position.iter() {

6
components/script/dom/file.rs
View file

@ -7,7 +7,7 @@ use dom::bindings::codegen::Bindings::FileBinding::FileMethods;
use dom::bindings::global::GlobalRef;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::blob::{Blob, BlobType, FileTypeId};
use dom::blob::{Blob, BlobTypeId};
use servo_util::str::DOMString;
#[dom_struct]
@ -17,7 +17,7 @@ pub struct File {
}
impl File {
fn new_inherited(global: &GlobalRef, type_: BlobType,
fn new_inherited(global: &GlobalRef, type_: BlobTypeId,
_file_bits: JSRef<Blob>, name: DOMString) -> File {
File {
blob: Blob::new_inherited(global, type_, None),
@ -28,7 +28,7 @@ impl File {
}
pub fn new(global: &GlobalRef, file_bits: JSRef<Blob>, name: DOMString) -> Temporary<File> {
reflect_dom_object(box File::new_inherited(global, FileTypeId, file_bits, name),
reflect_dom_object(box File::new_inherited(global, BlobTypeId::File, file_bits, name),
*global,
FileBinding::Wrap)
}

17
components/script/dom/formdata.rs
View file

@ -6,7 +6,8 @@ use dom::bindings::cell::DOMRefCell;
use dom::bindings::codegen::Bindings::FormDataBinding;
use dom::bindings::codegen::Bindings::FormDataBinding::FormDataMethods;
use dom::bindings::codegen::InheritTypes::FileCast;
use dom::bindings::codegen::UnionTypes::FileOrString::{FileOrString, eFile, eString};
use dom::bindings::codegen::UnionTypes::FileOrString;
use dom::bindings::codegen::UnionTypes::FileOrString::{eFile, eString};
use dom::bindings::error::{Fallible};
use dom::bindings::global::{GlobalRef, GlobalField};
use dom::bindings::js::{JS, JSRef, Temporary};
@ -57,7 +58,7 @@ impl FormData {
impl<'a> FormDataMethods for JSRef<'a, FormData> {
#[allow(unrooted_must_root)]
fn Append(self, name: DOMString, value: JSRef<Blob>, filename: Option<DOMString>) {
let file = FileData(JS::from_rooted(self.get_file_from_blob(value, filename)));
let file = FormDatum::FileData(JS::from_rooted(self.get_file_from_blob(value, filename)));
let mut data = self.data.borrow_mut();
match data.entry(name) {
Occupied(entry) => entry.into_mut().push(file),
@ -70,8 +71,8 @@ impl<'a> FormDataMethods for JSRef<'a, FormData> {
fn Append_(self, name: DOMString, value: DOMString) {
let mut data = self.data.borrow_mut();
match data.entry(name) {
Occupied(entry) => entry.into_mut().push(StringData(value)),
Vacant (entry) => { entry.set(vec!(StringData(value))); },
Occupied(entry) => entry.into_mut().push(FormDatum::StringData(value)),
Vacant (entry) => { entry.set(vec!(FormDatum::StringData(value))); },
}
}
@ -82,8 +83,8 @@ impl<'a> FormDataMethods for JSRef<'a, FormData> {
fn Get(self, name: DOMString) -> Option<FileOrString> {
if self.data.borrow().contains_key_equiv(&name) {
match (*self.data.borrow())[name][0].clone() {
StringData(ref s) => Some(eString(s.clone())),
FileData(ref f) => {
FormDatum::StringData(ref s) => Some(eString(s.clone())),
FormDatum::FileData(ref f) => {
Some(eFile(f.clone()))
}
}
@ -97,12 +98,12 @@ impl<'a> FormDataMethods for JSRef<'a, FormData> {
}
#[allow(unrooted_must_root)]
fn Set(self, name: DOMString, value: JSRef<Blob>, filename: Option<DOMString>) {
let file = FileData(JS::from_rooted(self.get_file_from_blob(value, filename)));
let file = FormDatum::FileData(JS::from_rooted(self.get_file_from_blob(value, filename)));
self.data.borrow_mut().insert(name, vec!(file));
}
fn Set_(self, name: DOMString, value: DOMString) {
self.data.borrow_mut().insert(name, vec!(StringData(value)));
self.data.borrow_mut().insert(name, vec!(FormDatum::StringData(value)));
}
}

10
components/script/dom/htmlanchorelement.rs
View file

@ -14,11 +14,11 @@ use dom::bindings::js::{MutNullableJS, JSRef, Temporary, OptionalRootable};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::{Document, DocumentHelpers};
use dom::domtokenlist::DOMTokenList;
use dom::element::{Element, AttributeHandlers, HTMLAnchorElementTypeId};
use dom::element::{Element, AttributeHandlers, ElementTypeId};
use dom::event::Event;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, NodeHelpers, ElementNodeTypeId};
use dom::node::{Node, NodeHelpers, NodeTypeId};
use dom::virtualmethods::VirtualMethods;
use std::default::Default;
@ -33,14 +33,14 @@ pub struct HTMLAnchorElement {
impl HTMLAnchorElementDerived for EventTarget {
fn is_htmlanchorelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLAnchorElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLAnchorElement))
}
}
impl HTMLAnchorElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLAnchorElement {
HTMLAnchorElement {
htmlelement: HTMLElement::new_inherited(HTMLAnchorElementTypeId, localName, prefix, document),
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLAnchorElement, localName, prefix, document),
rel_list: Default::default(),
}
}

10
components/script/dom/htmlappletelement.rs
View file

@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLAppletElementDerived;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::HTMLAppletElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::ElementTypeId;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, ElementNodeTypeId};
use dom::node::{Node, NodeTypeId};
use servo_util::str::DOMString;
#[dom_struct]
@ -20,14 +20,14 @@ pub struct HTMLAppletElement {
impl HTMLAppletElementDerived for EventTarget {
fn is_htmlappletelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLAppletElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLAppletElement))
}
}
impl HTMLAppletElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLAppletElement {
HTMLAppletElement {
htmlelement: HTMLElement::new_inherited(HTMLAppletElementTypeId, localName, prefix, document)
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLAppletElement, localName, prefix, document)
}
}

10
components/script/dom/htmlareaelement.rs
View file

@ -11,10 +11,10 @@ use dom::bindings::js::{MutNullableJS, JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::domtokenlist::DOMTokenList;
use dom::element::HTMLAreaElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::ElementTypeId;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, NodeHelpers, ElementNodeTypeId};
use dom::node::{Node, NodeHelpers, NodeTypeId};
use dom::virtualmethods::VirtualMethods;
use std::default::Default;
@ -31,14 +31,14 @@ pub struct HTMLAreaElement {
impl HTMLAreaElementDerived for EventTarget {
fn is_htmlareaelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLAreaElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLAreaElement))
}
}
impl HTMLAreaElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLAreaElement {
HTMLAreaElement {
htmlelement: HTMLElement::new_inherited(HTMLAreaElementTypeId, localName, prefix, document),
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLAreaElement, localName, prefix, document),
rel_list: Default::default(),
}
}

10
components/script/dom/htmlaudioelement.rs
View file

@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLAudioElementDerived;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::HTMLAudioElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::ElementTypeId;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlmediaelement::HTMLMediaElement;
use dom::node::{Node, ElementNodeTypeId};
use dom::node::{Node, NodeTypeId};
use servo_util::str::DOMString;
#[dom_struct]
@ -20,14 +20,14 @@ pub struct HTMLAudioElement {
impl HTMLAudioElementDerived for EventTarget {
fn is_htmlaudioelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLAudioElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLAudioElement))
}
}
impl HTMLAudioElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLAudioElement {
HTMLAudioElement {
htmlmediaelement: HTMLMediaElement::new_inherited(HTMLAudioElementTypeId, localName, prefix, document)
htmlmediaelement: HTMLMediaElement::new_inherited(ElementTypeId::HTMLAudioElement, localName, prefix, document)
}
}

10
components/script/dom/htmlbaseelement.rs
View file

@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLBaseElementDerived;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::HTMLBaseElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::ElementTypeId;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, ElementNodeTypeId};
use dom::node::{Node, NodeTypeId};
use servo_util::str::DOMString;
#[dom_struct]
@ -20,14 +20,14 @@ pub struct HTMLBaseElement {
impl HTMLBaseElementDerived for EventTarget {
fn is_htmlbaseelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLBaseElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLBaseElement))
}
}
impl HTMLBaseElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLBaseElement {
HTMLBaseElement {
htmlelement: HTMLElement::new_inherited(HTMLBaseElementTypeId, localName, prefix, document)
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLBaseElement, localName, prefix, document)
}
}

10
components/script/dom/htmlbodyelement.rs
View file

@ -11,10 +11,10 @@ use dom::bindings::codegen::InheritTypes::{HTMLBodyElementDerived, HTMLElementCa
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::HTMLBodyElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId, EventTargetHelpers};
use dom::element::ElementTypeId;
use dom::eventtarget::{EventTarget, EventTargetTypeId, EventTargetHelpers};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, ElementNodeTypeId, window_from_node};
use dom::node::{Node, NodeTypeId, window_from_node};
use dom::virtualmethods::VirtualMethods;
use cssparser::RGBA;
@ -29,7 +29,7 @@ pub struct HTMLBodyElement {
impl HTMLBodyElementDerived for EventTarget {
fn is_htmlbodyelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLBodyElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLBodyElement))
}
}
@ -37,7 +37,7 @@ impl HTMLBodyElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>)
-> HTMLBodyElement {
HTMLBodyElement {
htmlelement: HTMLElement::new_inherited(HTMLBodyElementTypeId,
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLBodyElement,
localName,
prefix,
document),

10
components/script/dom/htmlbrelement.rs
View file

@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLBRElementDerived;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::HTMLBRElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::ElementTypeId;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, ElementNodeTypeId};
use dom::node::{Node, NodeTypeId};
use servo_util::str::DOMString;
#[dom_struct]
@ -20,14 +20,14 @@ pub struct HTMLBRElement {
impl HTMLBRElementDerived for EventTarget {
fn is_htmlbrelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLBRElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLBRElement))
}
}
impl HTMLBRElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLBRElement {
HTMLBRElement {
htmlelement: HTMLElement::new_inherited(HTMLBRElementTypeId, localName, prefix, document)
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLBRElement, localName, prefix, document)
}
}

10
components/script/dom/htmlbuttonelement.rs
View file

@ -11,10 +11,10 @@ use dom::bindings::codegen::InheritTypes::{HTMLButtonElementDerived, HTMLFieldSe
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::{AttributeHandlers, Element, HTMLButtonElementTypeId};
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::{AttributeHandlers, Element, ElementTypeId};
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{DisabledStateHelpers, Node, NodeHelpers, ElementNodeTypeId, window_from_node};
use dom::node::{DisabledStateHelpers, Node, NodeHelpers, NodeTypeId, window_from_node};
use dom::validitystate::ValidityState;
use dom::virtualmethods::VirtualMethods;
@ -29,14 +29,14 @@ pub struct HTMLButtonElement {
impl HTMLButtonElementDerived for EventTarget {
fn is_htmlbuttonelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLButtonElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLButtonElement))
}
}
impl HTMLButtonElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLButtonElement {
HTMLButtonElement {
htmlelement: HTMLElement::new_inherited(HTMLButtonElementTypeId, localName, prefix, document)
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLButtonElement, localName, prefix, document)
}
}

10
components/script/dom/htmlcanvaselement.rs
View file

@ -13,10 +13,10 @@ use dom::bindings::js::{MutNullableJS, JSRef, Temporary, OptionalSettable};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::canvasrenderingcontext2d::CanvasRenderingContext2D;
use dom::document::Document;
use dom::element::{Element, HTMLCanvasElementTypeId, AttributeHandlers};
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::{Element, ElementTypeId, AttributeHandlers};
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, ElementNodeTypeId, window_from_node};
use dom::node::{Node, NodeTypeId, window_from_node};
use dom::virtualmethods::VirtualMethods;
use servo_util::str::{DOMString, parse_unsigned_integer};
@ -39,14 +39,14 @@ pub struct HTMLCanvasElement {
impl HTMLCanvasElementDerived for EventTarget {
fn is_htmlcanvaselement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLCanvasElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLCanvasElement))
}
}
impl HTMLCanvasElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLCanvasElement {
HTMLCanvasElement {
htmlelement: HTMLElement::new_inherited(HTMLCanvasElementTypeId, localName, prefix, document),
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLCanvasElement, localName, prefix, document),
context: Default::default(),
width: Cell::new(DEFAULT_WIDTH),
height: Cell::new(DEFAULT_HEIGHT),

14
components/script/dom/htmlcollection.rs
View file

@ -53,7 +53,7 @@ impl HTMLCollection {
impl HTMLCollection {
pub fn create(window: JSRef<Window>, root: JSRef<Node>,
filter: Box<CollectionFilter+'static>) -> Temporary<HTMLCollection> {
HTMLCollection::new(window, Live(JS::from_rooted(root), filter))
HTMLCollection::new(window, CollectionTypeId::Live(JS::from_rooted(root), filter))
}
fn all_elements(window: JSRef<Window>, root: JSRef<Node>,
@ -178,8 +178,8 @@ impl<'a> HTMLCollectionMethods for JSRef<'a, HTMLCollection> {
// http://dom.spec.whatwg.org/#dom-htmlcollection-length
fn Length(self) -> u32 {
match self.collection {
Static(ref elems) => elems.len() as u32,
Live(ref root, ref filter) => {
CollectionTypeId::Static(ref elems) => elems.len() as u32,
CollectionTypeId::Live(ref root, ref filter) => {
let root = root.root();
HTMLCollection::traverse(*root)
.filter(|element| filter.filter(*element, *root))
@ -191,11 +191,11 @@ impl<'a> HTMLCollectionMethods for JSRef<'a, HTMLCollection> {
// http://dom.spec.whatwg.org/#dom-htmlcollection-item
fn Item(self, index: u32) -> Option<Temporary<Element>> {
match self.collection {
Static(ref elems) => elems
CollectionTypeId::Static(ref elems) => elems
.as_slice()
.get(index as uint)
.map(|elem| Temporary::new(elem.clone())),
Live(ref root, ref filter) => {
CollectionTypeId::Live(ref root, ref filter) => {
let root = root.root();
HTMLCollection::traverse(*root)
.filter(|element| filter.filter(*element, *root))
@ -215,13 +215,13 @@ impl<'a> HTMLCollectionMethods for JSRef<'a, HTMLCollection> {
// Step 2.
match self.collection {
Static(ref elems) => elems.iter()
CollectionTypeId::Static(ref elems) => elems.iter()
.map(|elem| elem.root())
.find(|elem| {
elem.get_string_attribute(&atom!("name")) == key ||
elem.get_string_attribute(&atom!("id")) == key })
.map(|maybe_elem| Temporary::from_rooted(*maybe_elem)),
Live(ref root, ref filter) => {
CollectionTypeId::Live(ref root, ref filter) => {
let root = root.root();
HTMLCollection::traverse(*root)
.filter(|element| filter.filter(*element, *root))

10
components/script/dom/htmldataelement.rs
View file

@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLDataElementDerived;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::HTMLDataElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::ElementTypeId;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, ElementNodeTypeId};
use dom::node::{Node, NodeTypeId};
use servo_util::str::DOMString;
#[dom_struct]
@ -20,14 +20,14 @@ pub struct HTMLDataElement {
impl HTMLDataElementDerived for EventTarget {
fn is_htmldataelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLDataElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLDataElement))
}
}
impl HTMLDataElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLDataElement {
HTMLDataElement {
htmlelement: HTMLElement::new_inherited(HTMLDataElementTypeId, localName, prefix, document)
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLDataElement, localName, prefix, document)
}
}

10
components/script/dom/htmldatalistelement.rs
View file

@ -9,11 +9,11 @@ use dom::bindings::codegen::InheritTypes::NodeCast;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::{Element, HTMLDataListElementTypeId};
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::{Element, ElementTypeId};
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlcollection::{HTMLCollection, CollectionFilter};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, ElementNodeTypeId, window_from_node};
use dom::node::{Node, NodeTypeId, window_from_node};
use servo_util::str::DOMString;
#[dom_struct]
@ -23,14 +23,14 @@ pub struct HTMLDataListElement {
impl HTMLDataListElementDerived for EventTarget {
fn is_htmldatalistelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLDataListElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLDataListElement))
}
}
impl HTMLDataListElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLDataListElement {
HTMLDataListElement {
htmlelement: HTMLElement::new_inherited(HTMLDataListElementTypeId, localName, prefix, document)
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLDataListElement, localName, prefix, document)
}
}

10
components/script/dom/htmldirectoryelement.rs
View file

@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLDirectoryElementDerived;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::HTMLDirectoryElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::ElementTypeId;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, ElementNodeTypeId};
use dom::node::{Node, NodeTypeId};
use servo_util::str::DOMString;
#[dom_struct]
@ -20,14 +20,14 @@ pub struct HTMLDirectoryElement {
impl HTMLDirectoryElementDerived for EventTarget {
fn is_htmldirectoryelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLDirectoryElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLDirectoryElement))
}
}
impl HTMLDirectoryElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLDirectoryElement {
HTMLDirectoryElement {
htmlelement: HTMLElement::new_inherited(HTMLDirectoryElementTypeId, localName, prefix, document)
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLDirectoryElement, localName, prefix, document)
}
}

10
components/script/dom/htmldivelement.rs
View file

@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLDivElementDerived;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::HTMLDivElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::ElementTypeId;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, ElementNodeTypeId};
use dom::node::{Node, NodeTypeId};
use servo_util::str::DOMString;
#[dom_struct]
@ -20,14 +20,14 @@ pub struct HTMLDivElement {
impl HTMLDivElementDerived for EventTarget {
fn is_htmldivelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLDivElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLDivElement))
}
}
impl HTMLDivElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLDivElement {
HTMLDivElement {
htmlelement: HTMLElement::new_inherited(HTMLDivElementTypeId, localName, prefix, document)
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLDivElement, localName, prefix, document)
}
}

10
components/script/dom/htmldlistelement.rs
View file

@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLDListElementDerived;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::HTMLDListElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::ElementTypeId;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, ElementNodeTypeId};
use dom::node::{Node, NodeTypeId};
use servo_util::str::DOMString;
#[dom_struct]
@ -20,14 +20,14 @@ pub struct HTMLDListElement {
impl HTMLDListElementDerived for EventTarget {
fn is_htmldlistelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLDListElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLDListElement))
}
}
impl HTMLDListElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLDListElement {
HTMLDListElement {
htmlelement: HTMLElement::new_inherited(HTMLDListElementTypeId, localName, prefix, document)
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLDListElement, localName, prefix, document)
}
}

12
components/script/dom/htmlelement.rs
View file

@ -15,9 +15,9 @@ use dom::bindings::codegen::InheritTypes::{HTMLElementDerived, HTMLBodyElementDe
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::{Element, ElementTypeId, ElementTypeId_, HTMLElementTypeId, ActivationElementHelpers};
use dom::eventtarget::{EventTarget, EventTargetHelpers, NodeTargetTypeId};
use dom::node::{Node, ElementNodeTypeId, window_from_node};
use dom::element::{Element, ElementTypeId, ActivationElementHelpers};
use dom::eventtarget::{EventTarget, EventTargetHelpers, EventTargetTypeId};
use dom::node::{Node, NodeTypeId, window_from_node};
use dom::virtualmethods::VirtualMethods;
use servo_util::str::DOMString;
@ -32,8 +32,8 @@ pub struct HTMLElement {
impl HTMLElementDerived for EventTarget {
fn is_htmlelement(&self) -> bool {
match *self.type_id() {
NodeTargetTypeId(ElementNodeTypeId(ElementTypeId_)) => false,
NodeTargetTypeId(ElementNodeTypeId(_)) => true,
EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::Element)) => false,
EventTargetTypeId::Node(NodeTypeId::Element(_)) => true,
_ => false
}
}
@ -48,7 +48,7 @@ impl HTMLElement {
#[allow(unrooted_must_root)]
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLElement> {
let element = HTMLElement::new_inherited(HTMLElementTypeId, localName, prefix, document);
let element = HTMLElement::new_inherited(ElementTypeId::HTMLElement, localName, prefix, document);
Node::reflect_node(box element, document, HTMLElementBinding::Wrap)
}
}

10
components/script/dom/htmlembedelement.rs
View file

@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLEmbedElementDerived;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::HTMLEmbedElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::ElementTypeId;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, ElementNodeTypeId};
use dom::node::{Node, NodeTypeId};
use servo_util::str::DOMString;
#[dom_struct]
@ -20,14 +20,14 @@ pub struct HTMLEmbedElement {
impl HTMLEmbedElementDerived for EventTarget {
fn is_htmlembedelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLEmbedElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLEmbedElement))
}
}
impl HTMLEmbedElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLEmbedElement {
HTMLEmbedElement {
htmlelement: HTMLElement::new_inherited(HTMLEmbedElementTypeId, localName, prefix, document)
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLEmbedElement, localName, prefix, document)
}
}

27
components/script/dom/htmlfieldsetelement.rs
View file

@ -11,12 +11,11 @@ use dom::bindings::codegen::InheritTypes::{HTMLElementCast, HTMLLegendElementDer
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::{AttributeHandlers, Element, ElementHelpers, HTMLFieldSetElementTypeId, HTMLButtonElementTypeId};
use dom::element::{HTMLInputElementTypeId, HTMLSelectElementTypeId, HTMLTextAreaElementTypeId};
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::{AttributeHandlers, Element, ElementHelpers, ElementTypeId};
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlcollection::{HTMLCollection, CollectionFilter};
use dom::htmlelement::HTMLElement;
use dom::node::{DisabledStateHelpers, Node, NodeHelpers, ElementNodeTypeId, window_from_node};
use dom::node::{DisabledStateHelpers, Node, NodeHelpers, NodeTypeId, window_from_node};
use dom::validitystate::ValidityState;
use dom::virtualmethods::VirtualMethods;
@ -30,14 +29,14 @@ pub struct HTMLFieldSetElement {
impl HTMLFieldSetElementDerived for EventTarget {
fn is_htmlfieldsetelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLFieldSetElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLFieldSetElement))
}
}
impl HTMLFieldSetElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLFieldSetElement {
HTMLFieldSetElement {
htmlelement: HTMLElement::new_inherited(HTMLFieldSetElementTypeId, localName, prefix, document)
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLFieldSetElement, localName, prefix, document)
}
}
@ -101,10 +100,10 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLFieldSetElement> {
}).collect();
for descendant in filtered.iter().flat_map(|child| child.traverse_preorder()) {
match descendant.type_id() {
ElementNodeTypeId(HTMLButtonElementTypeId) |
ElementNodeTypeId(HTMLInputElementTypeId) |
ElementNodeTypeId(HTMLSelectElementTypeId) |
ElementNodeTypeId(HTMLTextAreaElementTypeId) => {
NodeTypeId::Element(ElementTypeId::HTMLButtonElement) |
NodeTypeId::Element(ElementTypeId::HTMLInputElement) |
NodeTypeId::Element(ElementTypeId::HTMLSelectElement) |
NodeTypeId::Element(ElementTypeId::HTMLTextAreaElement) => {
descendant.set_disabled_state(true);
descendant.set_enabled_state(false);
},
@ -133,10 +132,10 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLFieldSetElement> {
}).collect();
for descendant in filtered.iter().flat_map(|child| child.traverse_preorder()) {
match descendant.type_id() {
ElementNodeTypeId(HTMLButtonElementTypeId) |
ElementNodeTypeId(HTMLInputElementTypeId) |
ElementNodeTypeId(HTMLSelectElementTypeId) |
ElementNodeTypeId(HTMLTextAreaElementTypeId) => {
NodeTypeId::Element(ElementTypeId::HTMLButtonElement) |
NodeTypeId::Element(ElementTypeId::HTMLInputElement) |
NodeTypeId::Element(ElementTypeId::HTMLSelectElement) |
NodeTypeId::Element(ElementTypeId::HTMLTextAreaElement) => {
descendant.check_disabled_attribute();
descendant.check_ancestors_disabled_state_for_form_control();
},

10
components/script/dom/htmlfontelement.rs
View file

@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLFontElementDerived;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::HTMLFontElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::ElementTypeId;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, ElementNodeTypeId};
use dom::node::{Node, NodeTypeId};
use servo_util::str::DOMString;
#[dom_struct]
@ -20,14 +20,14 @@ pub struct HTMLFontElement {
impl HTMLFontElementDerived for EventTarget {
fn is_htmlfontelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLFontElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLFontElement))
}
}
impl HTMLFontElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLFontElement {
HTMLFontElement {
htmlelement: HTMLElement::new_inherited(HTMLFontElementTypeId, localName, prefix, document)
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLFontElement, localName, prefix, document)
}
}

89
components/script/dom/htmlformelement.rs
View file

@ -14,19 +14,18 @@ use dom::bindings::global::Window;
use dom::bindings::js::{JSRef, Temporary, OptionalRootable};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::{Document, DocumentHelpers};
use dom::element::{Element, AttributeHandlers, HTMLFormElementTypeId, HTMLTextAreaElementTypeId, HTMLDataListElementTypeId};
use dom::element::{HTMLInputElementTypeId, HTMLButtonElementTypeId, HTMLObjectElementTypeId, HTMLSelectElementTypeId};
use dom::element::{HTMLOutputElementTypeId};
use dom::event::{Event, EventHelpers, Bubbles, Cancelable};
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::{Element, AttributeHandlers, ElementTypeId};
use dom::event::{Event, EventHelpers, EventBubbles, EventCancelable};
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::htmlinputelement::HTMLInputElement;
use dom::htmltextareaelement::HTMLTextAreaElement;
use dom::node::{Node, NodeHelpers, ElementNodeTypeId, document_from_node, window_from_node};
use dom::node::{Node, NodeHelpers, NodeTypeId, document_from_node, window_from_node};
use hyper::method::Post;
use servo_msg::constellation_msg::LoadData;
use servo_util::str::DOMString;
use script_task::{ScriptChan, TriggerLoadMsg};
use script_task::ScriptChan;
use script_task::ScriptMsg::TriggerLoadMsg;
use std::ascii::OwnedAsciiExt;
use url::UrlParser;
use url::form_urlencoded::serialize;
@ -42,14 +41,14 @@ pub struct HTMLFormElement {
impl HTMLFormElementDerived for EventTarget {
fn is_htmlformelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLFormElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLFormElement))
}
}
impl HTMLFormElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLFormElement {
HTMLFormElement {
htmlelement: HTMLElement::new_inherited(HTMLFormElementTypeId, localName, prefix, document),
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLFormElement, localName, prefix, document),
marked_for_reset: Cell::new(false),
}
}
@ -122,12 +121,12 @@ impl<'a> HTMLFormElementMethods for JSRef<'a, HTMLFormElement> {
// https://html.spec.whatwg.org/multipage/forms.html#the-form-element:concept-form-submit
fn Submit(self) {
self.submit(FromFormSubmitMethod, FormElement(self));
self.submit(SubmittedFrom::FromFormSubmitMethod, FormSubmitter::FormElement(self));
}
// https://html.spec.whatwg.org/multipage/forms.html#dom-form-reset
fn Reset(self) {
self.reset(FromFormResetMethod);
self.reset(ResetFrom::FromFormResetMethod);
}
}
@ -160,7 +159,8 @@ impl<'a> HTMLFormElementHelpers for JSRef<'a, HTMLFormElement> {
// TODO: Handle validation
let event = Event::new(Window(*win),
"submit".to_string(),
Bubbles, Cancelable).root();
EventBubbles::Bubbles,
EventCancelable::Cancelable).root();
event.set_trusted(true);
let target: JSRef<EventTarget> = EventTargetCast::from_ref(self);
target.DispatchEvent(*event).ok();
@ -185,23 +185,23 @@ impl<'a> HTMLFormElementHelpers for JSRef<'a, HTMLFormElement> {
// TODO: Handle browsing contexts, partially loaded documents (step 16-17)
let parsed_data = match enctype {
UrlEncoded => serialize(form_data.iter().map(|d| (d.name.as_slice(), d.value.as_slice())), None),
FormEncType::UrlEncoded => serialize(form_data.iter().map(|d| (d.name.as_slice(), d.value.as_slice()))),
_ => "".to_string() // TODO: Add serializers for the other encoding types
};
let mut load_data = LoadData::new(action_components);
// Step 18
match (scheme.as_slice(), method) {
(_, FormDialog) => return, // Unimplemented
("http", FormGet) | ("https", FormGet) => {
(_, FormMethod::FormDialog) => return, // Unimplemented
("http", FormMethod::FormGet) | ("https", FormMethod::FormGet) => {
load_data.url.query = Some(parsed_data);
},
("http", FormPost) | ("https", FormPost) => {
("http", FormMethod::FormPost) | ("https", FormMethod::FormPost) => {
load_data.method = Post;
load_data.data = Some(parsed_data.into_bytes());
},
// https://html.spec.whatwg.org/multipage/forms.html#submit-get-action
("ftp", _) | ("javascript", _) | ("data", FormGet) => (),
("ftp", _) | ("javascript", _) | ("data", FormMethod::FormGet) => (),
_ => return // Unimplemented (data and mailto)
}
@ -250,12 +250,12 @@ impl<'a> HTMLFormElementHelpers for JSRef<'a, HTMLFormElement> {
if child.get_disabled_state() {
return None;
}
if child.ancestors().any(|a| a.type_id() == ElementNodeTypeId(HTMLDataListElementTypeId)) {
if child.ancestors().any(|a| a.type_id() == NodeTypeId::Element(ElementTypeId::HTMLDataListElement)) {
return None;
}
// XXXManishearth don't include it if it is a button but not the submitter
match child.type_id() {
ElementNodeTypeId(HTMLInputElementTypeId) => {
NodeTypeId::Element(ElementTypeId::HTMLInputElement) => {
let input: JSRef<HTMLInputElement> = HTMLInputElementCast::to_ref(child).unwrap();
let ty = input.Type();
let name = input.Name();
@ -275,7 +275,7 @@ impl<'a> HTMLFormElementHelpers for JSRef<'a, HTMLFormElement> {
let mut value = input.Value();
let is_submitter = match submitter {
Some(InputElement(s)) => {
Some(FormSubmitter::InputElement(s)) => {
input == s
},
_ => false
@ -302,19 +302,19 @@ impl<'a> HTMLFormElementHelpers for JSRef<'a, HTMLFormElement> {
})
}
}
ElementNodeTypeId(HTMLButtonElementTypeId) => {
NodeTypeId::Element(ElementTypeId::HTMLButtonElement) => {
// Unimplemented
None
}
ElementNodeTypeId(HTMLSelectElementTypeId) => {
NodeTypeId::Element(ElementTypeId::HTMLSelectElement) => {
// Unimplemented
None
}
ElementNodeTypeId(HTMLObjectElementTypeId) => {
NodeTypeId::Element(ElementTypeId::HTMLObjectElement) => {
// Unimplemented
None
}
ElementNodeTypeId(HTMLTextAreaElementTypeId) => {
NodeTypeId::Element(ElementTypeId::HTMLTextAreaElement) => {
// Unimplemented
None
}
@ -347,7 +347,8 @@ impl<'a> HTMLFormElementHelpers for JSRef<'a, HTMLFormElement> {
let win = window_from_node(self).root();
let event = Event::new(Window(*win),
"reset".to_string(),
Bubbles, Cancelable).root();
EventBubbles::Bubbles,
EventCancelable::Cancelable).root();
let target: JSRef<EventTarget> = EventTargetCast::from_ref(self);
target.DispatchEvent(*event).ok();
if event.DefaultPrevented() {
@ -360,26 +361,26 @@ impl<'a> HTMLFormElementHelpers for JSRef<'a, HTMLFormElement> {
// by the form, but good enough until html5ever lands
for child in node.traverse_preorder() {
match child.type_id() {
ElementNodeTypeId(HTMLInputElementTypeId) => {
NodeTypeId::Element(ElementTypeId::HTMLInputElement) => {
let input: JSRef<HTMLInputElement> = HTMLInputElementCast::to_ref(child)
.unwrap();
input.reset()
}
// TODO HTMLKeygenElement unimplemented
//ElementNodeTypeID(HTMLKeygenElementTypeId) => {
//NodeTypeId::Element(ElementTypeId::HTMLKeygenElement) => {
// // Unimplemented
// {}
//}
ElementNodeTypeId(HTMLSelectElementTypeId) => {
NodeTypeId::Element(ElementTypeId::HTMLSelectElement) => {
// Unimplemented
{}
}
ElementNodeTypeId(HTMLTextAreaElementTypeId) => {
NodeTypeId::Element(ElementTypeId::HTMLTextAreaElement) => {
let textarea: JSRef<HTMLTextAreaElement> = HTMLTextAreaElementCast::to_ref(child)
.unwrap();
textarea.reset()
}
ElementNodeTypeId(HTMLOutputElementTypeId) => {
NodeTypeId::Element(ElementTypeId::HTMLOutputElement) => {
// Unimplemented
{}
}
@ -424,8 +425,8 @@ pub enum FormSubmitter<'a> {
impl<'a> FormSubmitter<'a> {
fn action(&self) -> DOMString {
match *self {
FormElement(form) => form.Action(),
InputElement(input_element) => {
FormSubmitter::FormElement(form) => form.Action(),
FormSubmitter::InputElement(input_element) => {
// FIXME(pcwalton): Make this a static atom.
input_element.get_form_attribute(&Atom::from_slice("formaction"),
|i| i.FormAction(),
@ -436,8 +437,8 @@ impl<'a> FormSubmitter<'a> {
fn enctype(&self) -> FormEncType {
let attr = match *self {
FormElement(form) => form.Enctype(),
InputElement(input_element) => {
FormSubmitter::FormElement(form) => form.Enctype(),
FormSubmitter::InputElement(input_element) => {
// FIXME(pcwalton): Make this a static atom.
input_element.get_form_attribute(&Atom::from_slice("formenctype"),
|i| i.FormEnctype(),
@ -445,18 +446,18 @@ impl<'a> FormSubmitter<'a> {
}
};
match attr.as_slice() {
"multipart/form-data" => FormDataEncoded,
"text/plain" => TextPlainEncoded,
"multipart/form-data" => FormEncType::FormDataEncoded,
"text/plain" => FormEncType::TextPlainEncoded,
// https://html.spec.whatwg.org/multipage/forms.html#attr-fs-enctype
// urlencoded is the default
_ => UrlEncoded
_ => FormEncType::UrlEncoded
}
}
fn method(&self) -> FormMethod {
let attr = match *self {
FormElement(form) => form.Method(),
InputElement(input_element) => {
FormSubmitter::FormElement(form) => form.Method(),
FormSubmitter::InputElement(input_element) => {
// FIXME(pcwalton): Make this a static atom.
input_element.get_form_attribute(&Atom::from_slice("formmethod"),
|i| i.FormMethod(),
@ -464,16 +465,16 @@ impl<'a> FormSubmitter<'a> {
}
};
match attr.as_slice() {
"dialog" => FormDialog,
"post" => FormPost,
_ => FormGet
"dialog" => FormMethod::FormDialog,
"post" => FormMethod::FormPost,
_ => FormMethod::FormGet
}
}
fn target(&self) -> DOMString {
match *self {
FormElement(form) => form.Target(),
InputElement(input_element) => {
FormSubmitter::FormElement(form) => form.Target(),
FormSubmitter::InputElement(input_element) => {
// FIXME(pcwalton): Make this a static atom.
input_element.get_form_attribute(&Atom::from_slice("formtarget"),
|i| i.FormTarget(),

10
components/script/dom/htmlframeelement.rs
View file

@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLFrameElementDerived;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::HTMLFrameElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::ElementTypeId;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, ElementNodeTypeId};
use dom::node::{Node, NodeTypeId};
use servo_util::str::DOMString;
#[dom_struct]
@ -20,14 +20,14 @@ pub struct HTMLFrameElement {
impl HTMLFrameElementDerived for EventTarget {
fn is_htmlframeelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLFrameElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLFrameElement))
}
}
impl HTMLFrameElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLFrameElement {
HTMLFrameElement {
htmlelement: HTMLElement::new_inherited(HTMLFrameElementTypeId, localName, prefix, document)
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLFrameElement, localName, prefix, document)
}
}

10
components/script/dom/htmlframesetelement.rs
View file

@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLFrameSetElementDerived;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::HTMLFrameSetElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::ElementTypeId;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, ElementNodeTypeId};
use dom::node::{Node, NodeTypeId};
use servo_util::str::DOMString;
#[dom_struct]
@ -20,14 +20,14 @@ pub struct HTMLFrameSetElement {
impl HTMLFrameSetElementDerived for EventTarget {
fn is_htmlframesetelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLFrameSetElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLFrameSetElement))
}
}
impl HTMLFrameSetElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLFrameSetElement {
HTMLFrameSetElement {
htmlelement: HTMLElement::new_inherited(HTMLFrameSetElementTypeId, localName, prefix, document)
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLFrameSetElement, localName, prefix, document)
}
}

10
components/script/dom/htmlheadelement.rs
View file

@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLHeadElementDerived;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::HTMLHeadElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::ElementTypeId;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, ElementNodeTypeId};
use dom::node::{Node, NodeTypeId};
use servo_util::str::DOMString;
#[dom_struct]
@ -20,14 +20,14 @@ pub struct HTMLHeadElement {
impl HTMLHeadElementDerived for EventTarget {
fn is_htmlheadelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLHeadElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLHeadElement))
}
}
impl HTMLHeadElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLHeadElement {
HTMLHeadElement {
htmlelement: HTMLElement::new_inherited(HTMLHeadElementTypeId, localName, prefix, document)
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLHeadElement, localName, prefix, document)
}
}

10
components/script/dom/htmlheadingelement.rs
View file

@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLHeadingElementDerived;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::HTMLHeadingElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::ElementTypeId;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, ElementNodeTypeId};
use dom::node::{Node, NodeTypeId};
use servo_util::str::DOMString;
#[jstraceable]
@ -31,14 +31,14 @@ pub struct HTMLHeadingElement {
impl HTMLHeadingElementDerived for EventTarget {
fn is_htmlheadingelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLHeadingElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLHeadingElement))
}
}
impl HTMLHeadingElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>, level: HeadingLevel) -> HTMLHeadingElement {
HTMLHeadingElement {
htmlelement: HTMLElement::new_inherited(HTMLHeadingElementTypeId, localName, prefix, document),
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLHeadingElement, localName, prefix, document),
level: level,
}
}

10
components/script/dom/htmlhrelement.rs
View file

@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLHRElementDerived;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::HTMLHRElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::ElementTypeId;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, ElementNodeTypeId};
use dom::node::{Node, NodeTypeId};
use servo_util::str::DOMString;
#[dom_struct]
@ -20,14 +20,14 @@ pub struct HTMLHRElement {
impl HTMLHRElementDerived for EventTarget {
fn is_htmlhrelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLHRElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLHRElement))
}
}
impl HTMLHRElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLHRElement {
HTMLHRElement {
htmlelement: HTMLElement::new_inherited(HTMLHRElementTypeId, localName, prefix, document)
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLHRElement, localName, prefix, document)
}
}

10
components/script/dom/htmlhtmlelement.rs
View file

@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLHtmlElementDerived;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::HTMLHtmlElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::ElementTypeId;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, ElementNodeTypeId};
use dom::node::{Node, NodeTypeId};
use servo_util::str::DOMString;
#[dom_struct]
@ -20,14 +20,14 @@ pub struct HTMLHtmlElement {
impl HTMLHtmlElementDerived for EventTarget {
fn is_htmlhtmlelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLHtmlElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLHtmlElement))
}
}
impl HTMLHtmlElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLHtmlElement {
HTMLHtmlElement {
htmlelement: HTMLElement::new_inherited(HTMLHtmlElementTypeId, localName, prefix, document)
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLHtmlElement, localName, prefix, document)
}
}

26
components/script/dom/htmliframeelement.rs
View file

@ -12,11 +12,11 @@ use dom::bindings::codegen::InheritTypes::{HTMLElementCast, HTMLIFrameElementDer
use dom::bindings::js::{JSRef, Temporary, OptionalRootable};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::{HTMLIFrameElementTypeId, Element};
use dom::element::{ElementTypeId, Element};
use dom::element::AttributeHandlers;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, NodeHelpers, ElementNodeTypeId, window_from_node};
use dom::node::{Node, NodeHelpers, NodeTypeId, window_from_node};
use dom::urlhelper::UrlHelper;
use dom::virtualmethods::VirtualMethods;
use dom::window::Window;
@ -50,7 +50,7 @@ pub struct HTMLIFrameElement {
impl HTMLIFrameElementDerived for EventTarget {
fn is_htmliframeelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLIFrameElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLIFrameElement))
}
}
@ -129,7 +129,7 @@ impl<'a> HTMLIFrameElementHelpers for JSRef<'a, HTMLIFrameElement> {
impl HTMLIFrameElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLIFrameElement {
HTMLIFrameElement {
htmlelement: HTMLElement::new_inherited(HTMLIFrameElementTypeId, localName, prefix, document),
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLIFrameElement, localName, prefix, document),
size: Cell::new(None),
sandbox: Cell::new(None),
}
@ -214,16 +214,16 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLIFrameElement> {
match attr.local_name() {
&atom!("sandbox") => {
let mut modes = AllowNothing as u8;
let mut modes = SandboxAllowance::AllowNothing as u8;
for word in attr.value().as_slice().split(' ') {
modes |= match word.to_ascii_lower().as_slice() {
"allow-same-origin" => AllowSameOrigin,
"allow-forms" => AllowForms,
"allow-pointer-lock" => AllowPointerLock,
"allow-popups" => AllowPopups,
"allow-scripts" => AllowScripts,
"allow-top-navigation" => AllowTopNavigation,
_ => AllowNothing
"allow-same-origin" => SandboxAllowance::AllowSameOrigin,
"allow-forms" => SandboxAllowance::AllowForms,
"allow-pointer-lock" => SandboxAllowance::AllowPointerLock,
"allow-popups" => SandboxAllowance::AllowPopups,
"allow-scripts" => SandboxAllowance::AllowScripts,
"allow-top-navigation" => SandboxAllowance::AllowTopNavigation,
_ => SandboxAllowance::AllowNothing
} as u8;
}
self.sandbox.set(Some(modes));

14
components/script/dom/htmlimageelement.rs
View file

@ -11,11 +11,11 @@ use dom::bindings::codegen::InheritTypes::{NodeCast, ElementCast, HTMLElementCas
use dom::bindings::js::{JS, JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::{Document, DocumentHelpers};
use dom::element::{Element, HTMLImageElementTypeId};
use dom::element::{Element, ElementTypeId};
use dom::element::AttributeHandlers;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, ElementNodeTypeId, NodeHelpers, OtherNodeDamage, window_from_node};
use dom::node::{Node, NodeTypeId, NodeHelpers, NodeDamage, window_from_node};
use dom::virtualmethods::VirtualMethods;
use servo_net::image_cache_task;
use servo_util::geometry::to_px;
@ -32,7 +32,7 @@ pub struct HTMLImageElement {
impl HTMLImageElementDerived for EventTarget {
fn is_htmlimageelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLImageElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLImageElement))
}
}
@ -69,7 +69,7 @@ impl<'a> PrivateHTMLImageElementHelpers for JSRef<'a, HTMLImageElement> {
impl HTMLImageElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLImageElement {
HTMLImageElement {
htmlelement: HTMLElement::new_inherited(HTMLImageElementTypeId, localName, prefix, document),
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLImageElement, localName, prefix, document),
image: DOMRefCell::new(None),
}
}
@ -118,7 +118,7 @@ impl<'a> HTMLImageElementMethods for JSRef<'a, HTMLImageElement> {
// recreate the flow (picking up image changes on the way). The image cache task needs a
// rewrite to modern Rust.
let node: JSRef<Node> = NodeCast::from_ref(self);
node.dirty(OtherNodeDamage);
node.dirty(NodeDamage::OtherNodeDamage);
let rect = node.get_bounding_content_box();
to_px(rect.size.width) as u32
@ -136,7 +136,7 @@ impl<'a> HTMLImageElementMethods for JSRef<'a, HTMLImageElement> {
// recreate the flow (picking up image changes on the way). The image cache task needs a
// rewrite to modern Rust.
let node: JSRef<Node> = NodeCast::from_ref(self);
node.dirty(OtherNodeDamage);
node.dirty(NodeDamage::OtherNodeDamage);
let rect = node.get_bounding_content_box();
to_px(rect.size.height) as u32

118
components/script/dom/htmlinputelement.rs
View file

@ -3,7 +3,7 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use dom::activation::Activatable;
use dom::attr::{Attr, AttrValue, UIntAttrValue};
use dom::attr::{Attr, AttrValue};
use dom::attr::AttrHelpers;
use dom::bindings::cell::DOMRefCell;
use dom::bindings::codegen::Bindings::AttrBinding::AttrMethods;
@ -19,18 +19,20 @@ use dom::bindings::js::{Comparable, JS, JSRef, Root, Temporary, OptionalRootable
use dom::bindings::js::{ResultRootable, RootedReference, MutNullableJS};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::{Document, DocumentHelpers};
use dom::element::{AttributeHandlers, Element, HTMLInputElementTypeId};
use dom::element::{AttributeHandlers, Element, ElementTypeId};
use dom::element::{RawLayoutElementHelpers, ActivationElementHelpers};
use dom::event::{Event, Bubbles, NotCancelable, EventHelpers};
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::event::{Event, EventBubbles, EventCancelable, EventHelpers};
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::keyboardevent::KeyboardEvent;
use dom::htmlformelement::{InputElement, FormControl, HTMLFormElement, HTMLFormElementHelpers};
use dom::htmlformelement::{NotFromFormSubmitMethod, NotFromFormResetMethod};
use dom::node::{DisabledStateHelpers, Node, NodeHelpers, ElementNodeTypeId, OtherNodeDamage};
use dom::htmlformelement::{FormSubmitter, FormControl, HTMLFormElement, HTMLFormElementHelpers};
use dom::htmlformelement::{SubmittedFrom, ResetFrom};
use dom::node::{DisabledStateHelpers, Node, NodeHelpers, NodeDamage, NodeTypeId};
use dom::node::{document_from_node, window_from_node};
use dom::virtualmethods::VirtualMethods;
use textinput::{Single, TextInput, TriggerDefaultAction, DispatchInput, Nothing};
use textinput::TextInput;
use textinput::KeyReaction::{TriggerDefaultAction, DispatchInput, Nothing};
use textinput::Lines::Single;
use servo_util::str::DOMString;
use string_cache::Atom;
@ -91,14 +93,14 @@ impl InputActivationState {
checked_changed: false,
checked_radio: Default::default(),
was_mutable: false,
old_type: InputText
old_type: InputType::InputText
}
}
}
impl HTMLInputElementDerived for EventTarget {
fn is_htmlinputelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLInputElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLInputElement))
}
}
@ -107,8 +109,8 @@ static DEFAULT_INPUT_SIZE: u32 = 20;
impl HTMLInputElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLInputElement {
HTMLInputElement {
htmlelement: HTMLElement::new_inherited(HTMLInputElementTypeId, localName, prefix, document),
input_type: Cell::new(InputText),
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLInputElement, localName, prefix, document),
input_type: Cell::new(InputType::InputText),
checked: Cell::new(false),
indeterminate: Cell::new(false),
checked_changed: Cell::new(false),
@ -151,12 +153,12 @@ impl LayoutHTMLInputElementHelpers for JS<HTMLInputElement> {
}
match (*self.unsafe_get()).input_type.get() {
InputCheckbox | InputRadio => "".to_string(),
InputFile | InputImage => "".to_string(),
InputButton => get_raw_attr_value(self).unwrap_or_else(|| "".to_string()),
InputSubmit => get_raw_attr_value(self).unwrap_or_else(|| DEFAULT_SUBMIT_VALUE.to_string()),
InputReset => get_raw_attr_value(self).unwrap_or_else(|| DEFAULT_RESET_VALUE.to_string()),
InputPassword => {
InputType::InputCheckbox | InputType::InputRadio => "".to_string(),
InputType::InputFile | InputType::InputImage => "".to_string(),
InputType::InputButton => get_raw_attr_value(self).unwrap_or_else(|| "".to_string()),
InputType::InputSubmit => get_raw_attr_value(self).unwrap_or_else(|| DEFAULT_SUBMIT_VALUE.to_string()),
InputType::InputReset => get_raw_attr_value(self).unwrap_or_else(|| DEFAULT_RESET_VALUE.to_string()),
InputType::InputPassword => {
let raw = get_raw_textinput_value(self);
String::from_char(raw.char_len(), '●')
}
@ -326,7 +328,7 @@ fn in_same_group<'a,'b>(other: JSRef<'a, HTMLInputElement>,
group: Option<&str>) -> bool {
let other_owner = other.form_owner().root();
let other_owner = other_owner.root_ref();
other.input_type.get() == InputRadio &&
other.input_type.get() == InputType::InputRadio &&
// TODO Both a and b are in the same home subtree.
other_owner.equals(owner) &&
// TODO should be a unicode compatibility caseless match
@ -341,7 +343,7 @@ impl<'a> HTMLInputElementHelpers for JSRef<'a, HTMLInputElement> {
fn force_relayout(self) {
let doc = document_from_node(self).root();
let node: JSRef<Node> = NodeCast::from_ref(self);
doc.content_changed(node, OtherNodeDamage)
doc.content_changed(node, NodeDamage::OtherNodeDamage)
}
fn radio_group_updated(self, group: Option<&str>) {
@ -365,7 +367,7 @@ impl<'a> HTMLInputElementHelpers for JSRef<'a, HTMLInputElement> {
self.checked_changed.set(true);
}
if self.input_type.get() == InputRadio && checked {
if self.input_type.get() == InputType::InputRadio && checked {
broadcast_radio_checked(self,
self.get_radio_group_name()
.as_ref()
@ -410,24 +412,24 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLInputElement> {
}
&atom!("size") => {
match *attr.value() {
UIntAttrValue(_, value) => self.size.set(value),
_ => panic!("Expected a UIntAttrValue"),
AttrValue::UInt(_, value) => self.size.set(value),
_ => panic!("Expected an AttrValue::UInt"),
}
self.force_relayout();
}
&atom!("type") => {
let value = attr.value();
self.input_type.set(match value.as_slice() {
"button" => InputButton,
"submit" => InputSubmit,
"reset" => InputReset,
"file" => InputFile,
"radio" => InputRadio,
"checkbox" => InputCheckbox,
"password" => InputPassword,
_ => InputText,
"button" => InputType::InputButton,
"submit" => InputType::InputSubmit,
"reset" => InputType::InputReset,
"file" => InputType::InputFile,
"radio" => InputType::InputRadio,
"checkbox" => InputType::InputCheckbox,
"password" => InputType::InputPassword,
_ => InputType::InputText,
});
if self.input_type.get() == InputRadio {
if self.input_type.get() == InputType::InputRadio {
self.radio_group_updated(self.get_radio_group_name()
.as_ref()
.map(|group| group.as_slice()));
@ -441,7 +443,7 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLInputElement> {
}
}
&atom!("name") => {
if self.input_type.get() == InputRadio {
if self.input_type.get() == InputType::InputRadio {
let value = attr.value();
self.radio_group_updated(Some(value.as_slice()));
}
@ -474,13 +476,13 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLInputElement> {
self.force_relayout();
}
&atom!("type") => {
if self.input_type.get() == InputRadio {
if self.input_type.get() == InputType::InputRadio {
broadcast_radio_checked(*self,
self.get_radio_group_name()
.as_ref()
.map(|group| group.as_slice()));
}
self.input_type.set(InputText);
self.input_type.set(InputType::InputText);
self.force_relayout();
}
&atom!("value") => {
@ -490,7 +492,7 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLInputElement> {
}
}
&atom!("name") => {
if self.input_type.get() == InputRadio {
if self.input_type.get() == InputType::InputRadio {
self.radio_group_updated(None);
}
}
@ -539,7 +541,7 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLInputElement> {
if "click" == event.Type().as_slice() && !event.DefaultPrevented() {
match self.input_type.get() {
InputRadio => self.update_checked_state(true, true),
InputType::InputRadio => self.update_checked_state(true, true),
_ => {}
}
@ -551,7 +553,8 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLInputElement> {
let doc = document_from_node(*self).root();
doc.request_focus(ElementCast::from_ref(*self));
} else if "keydown" == event.Type().as_slice() && !event.DefaultPrevented() &&
(self.input_type.get() == InputText || self.input_type.get() == InputPassword) {
(self.input_type.get() == InputType::InputText ||
self.input_type.get() == InputType::InputPassword) {
let keyevent: Option<JSRef<KeyboardEvent>> = KeyboardEventCast::to_ref(event);
keyevent.map(|keyevent| {
match self.textinput.borrow_mut().handle_keydown(keyevent) {
@ -589,11 +592,11 @@ impl<'a> FormControl<'a> for JSRef<'a, HTMLInputElement> {
// https://html.spec.whatwg.org/multipage/forms.html#the-input-element:concept-form-reset-control
fn reset(self) {
match self.input_type.get() {
InputRadio | InputCheckbox => {
InputType::InputRadio | InputType::InputCheckbox => {
self.update_checked_state(self.DefaultChecked(), false);
self.checked_changed.set(false);
},
InputImage => (),
InputType::InputImage => (),
_ => ()
}
@ -617,10 +620,10 @@ impl<'a> Activatable for JSRef<'a, HTMLInputElement> {
if cache.was_mutable {
match ty {
// https://html.spec.whatwg.org/multipage/forms.html#submit-button-state-(type=submit):activation-behavior
// InputSubmit => (), // No behavior defined
// InputType::InputSubmit => (), // No behavior defined
// https://html.spec.whatwg.org/multipage/forms.html#reset-button-state-(type=reset):activation-behavior
// InputSubmit => (), // No behavior defined
InputCheckbox => {
// InputType::InputSubmit => (), // No behavior defined
InputType::InputCheckbox => {
// https://html.spec.whatwg.org/multipage/forms.html#checkbox-state-(type=checkbox):pre-click-activation-steps
// cache current values of `checked` and `indeterminate`
// we may need to restore them later
@ -631,7 +634,7 @@ impl<'a> Activatable for JSRef<'a, HTMLInputElement> {
self.SetChecked(!cache.checked);
},
// https://html.spec.whatwg.org/multipage/forms.html#radio-button-state-(type=radio):pre-click-activation-steps
InputRadio => {
InputType::InputRadio => {
//TODO: if not in document, use root ancestor instead of document
let owner = self.form_owner().root();
let doc = document_from_node(*self).root();
@ -666,11 +669,11 @@ impl<'a> Activatable for JSRef<'a, HTMLInputElement> {
}
match ty {
// https://html.spec.whatwg.org/multipage/forms.html#submit-button-state-(type=submit):activation-behavior
// InputSubmit => (), // No behavior defined
// InputType::InputSubmit => (), // No behavior defined
// https://html.spec.whatwg.org/multipage/forms.html#reset-button-state-(type=reset):activation-behavior
// InputReset => (), // No behavior defined
// InputType::InputReset => (), // No behavior defined
// https://html.spec.whatwg.org/multipage/forms.html#checkbox-state-(type=checkbox):canceled-activation-steps
InputCheckbox => {
InputType::InputCheckbox => {
// We want to restore state only if the element had been changed in the first place
if cache.was_mutable {
self.SetIndeterminate(cache.indeterminate);
@ -679,7 +682,7 @@ impl<'a> Activatable for JSRef<'a, HTMLInputElement> {
}
},
// https://html.spec.whatwg.org/multipage/forms.html#radio-button-state-(type=radio):canceled-activation-steps
InputRadio => {
InputType::InputRadio => {
// We want to restore state only if the element had been changed in the first place
if cache.was_mutable {
let old_checked: Option<Root<HTMLInputElement>> = cache.checked_radio.get().root();
@ -691,7 +694,7 @@ impl<'a> Activatable for JSRef<'a, HTMLInputElement> {
if name == o.get_radio_group_name() && // TODO should be compatibility caseless
self.form_owner() == o.form_owner() &&
// TODO Both a and b are in the same home subtree
o.input_type.get() == InputRadio {
o.input_type.get() == InputType::InputRadio {
o.SetChecked(true);
} else {
self.SetChecked(false);
@ -715,39 +718,42 @@ impl<'a> Activatable for JSRef<'a, HTMLInputElement> {
return;
}
match ty {
InputSubmit => {
InputType::InputSubmit => {
// https://html.spec.whatwg.org/multipage/forms.html#submit-button-state-(type=submit):activation-behavior
// FIXME (Manishearth): support document owners (needs ability to get parent browsing context)
if self.mutable() /* and document owner is fully active */ {
self.form_owner().map(|o| {
o.root().submit(NotFromFormSubmitMethod, InputElement(self.clone()))
o.root().submit(SubmittedFrom::NotFromFormSubmitMethod,
FormSubmitter::InputElement(self.clone()))
});
}
},
InputReset => {
InputType::InputReset => {
// https://html.spec.whatwg.org/multipage/forms.html#reset-button-state-(type=reset):activation-behavior
// FIXME (Manishearth): support document owners (needs ability to get parent browsing context)
if self.mutable() /* and document owner is fully active */ {
self.form_owner().map(|o| {
o.root().reset(NotFromFormResetMethod)
o.root().reset(ResetFrom::NotFromFormResetMethod)
});
}
},
InputCheckbox | InputRadio => {
InputType::InputCheckbox | InputType::InputRadio => {
// https://html.spec.whatwg.org/multipage/forms.html#checkbox-state-(type=checkbox):activation-behavior
// https://html.spec.whatwg.org/multipage/forms.html#radio-button-state-(type=radio):activation-behavior
if self.mutable() {
let win = window_from_node(*self).root();
let event = Event::new(Window(*win),
"input".to_string(),
Bubbles, NotCancelable).root();
EventBubbles::Bubbles,
EventCancelable::NotCancelable).root();
event.set_trusted(true);
let target: JSRef<EventTarget> = EventTargetCast::from_ref(*self);
target.DispatchEvent(*event).ok();
let event = Event::new(Window(*win),
"change".to_string(),
Bubbles, NotCancelable).root();
EventBubbles::Bubbles,
EventCancelable::NotCancelable).root();
event.set_trusted(true);
let target: JSRef<EventTarget> = EventTargetCast::from_ref(*self);
target.DispatchEvent(*event).ok();

10
components/script/dom/htmllabelelement.rs
View file

@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLLabelElementDerived;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::HTMLLabelElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::ElementTypeId;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, ElementNodeTypeId};
use dom::node::{Node, NodeTypeId};
use servo_util::str::DOMString;
#[dom_struct]
@ -20,14 +20,14 @@ pub struct HTMLLabelElement {
impl HTMLLabelElementDerived for EventTarget {
fn is_htmllabelelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLLabelElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLLabelElement))
}
}
impl HTMLLabelElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLLabelElement {
HTMLLabelElement {
htmlelement: HTMLElement::new_inherited(HTMLLabelElementTypeId, localName, prefix, document)
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLLabelElement, localName, prefix, document)
}
}

10
components/script/dom/htmllegendelement.rs
View file

@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLLegendElementDerived;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::HTMLLegendElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::ElementTypeId;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, ElementNodeTypeId};
use dom::node::{Node, NodeTypeId};
use servo_util::str::DOMString;
#[dom_struct]
@ -20,14 +20,14 @@ pub struct HTMLLegendElement {
impl HTMLLegendElementDerived for EventTarget {
fn is_htmllegendelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLLegendElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLLegendElement))
}
}
impl HTMLLegendElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLLegendElement {
HTMLLegendElement {
htmlelement: HTMLElement::new_inherited(HTMLLegendElementTypeId, localName, prefix, document)
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLLegendElement, localName, prefix, document)
}
}

10
components/script/dom/htmllielement.rs
View file

@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLLIElementDerived;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::HTMLLIElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::ElementTypeId;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, ElementNodeTypeId};
use dom::node::{Node, NodeTypeId};
use servo_util::str::DOMString;
#[dom_struct]
@ -20,14 +20,14 @@ pub struct HTMLLIElement {
impl HTMLLIElementDerived for EventTarget {
fn is_htmllielement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLLIElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLLIElement))
}
}
impl HTMLLIElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLLIElement {
HTMLLIElement {
htmlelement: HTMLElement::new_inherited(HTMLLIElementTypeId, localName, prefix, document)
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLLIElement, localName, prefix, document)
}
}

10
components/script/dom/htmllinkelement.rs
View file

@ -12,10 +12,10 @@ use dom::bindings::js::{MutNullableJS, JSRef, Temporary, OptionalRootable};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::domtokenlist::DOMTokenList;
use dom::element::{AttributeHandlers, Element, HTMLLinkElementTypeId};
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::{AttributeHandlers, Element, ElementTypeId};
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, NodeHelpers, ElementNodeTypeId, window_from_node};
use dom::node::{Node, NodeHelpers, NodeTypeId, window_from_node};
use dom::virtualmethods::VirtualMethods;
use layout_interface::{LayoutChan, LoadStylesheetMsg};
use servo_util::str::{DOMString, HTML_SPACE_CHARACTERS};
@ -33,14 +33,14 @@ pub struct HTMLLinkElement {
impl HTMLLinkElementDerived for EventTarget {
fn is_htmllinkelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLLinkElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLLinkElement))
}
}
impl HTMLLinkElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLLinkElement {
HTMLLinkElement {
htmlelement: HTMLElement::new_inherited(HTMLLinkElementTypeId, localName, prefix, document),
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLLinkElement, localName, prefix, document),
rel_list: Default::default(),
}
}

10
components/script/dom/htmlmapelement.rs
View file

@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLMapElementDerived;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::HTMLMapElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::ElementTypeId;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, ElementNodeTypeId};
use dom::node::{Node, NodeTypeId};
use servo_util::str::DOMString;
#[dom_struct]
@ -20,14 +20,14 @@ pub struct HTMLMapElement {
impl HTMLMapElementDerived for EventTarget {
fn is_htmlmapelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLMapElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLMapElement))
}
}
impl HTMLMapElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLMapElement {
HTMLMapElement {
htmlelement: HTMLElement::new_inherited(HTMLMapElementTypeId, localName, prefix, document)
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLMapElement, localName, prefix, document)
}
}

10
components/script/dom/htmlmediaelement.rs
View file

@ -6,10 +6,10 @@ use dom::bindings::js::{JSRef};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::bindings::codegen::InheritTypes::HTMLMediaElementDerived;
use dom::document::Document;
use dom::element::{ElementTypeId, HTMLAudioElementTypeId, HTMLVideoElementTypeId};
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::ElementTypeId;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::ElementNodeTypeId;
use dom::node::NodeTypeId;
use servo_util::str::DOMString;
#[dom_struct]
@ -20,8 +20,8 @@ pub struct HTMLMediaElement {
impl HTMLMediaElementDerived for EventTarget {
fn is_htmlmediaelement(&self) -> bool {
match *self.type_id() {
NodeTargetTypeId(ElementNodeTypeId(HTMLVideoElementTypeId)) |
NodeTargetTypeId(ElementNodeTypeId(HTMLAudioElementTypeId)) => true,
EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLVideoElement)) |
EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLAudioElement)) => true,
_ => false
}
}

10
components/script/dom/htmlmetaelement.rs
View file

@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLMetaElementDerived;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::HTMLMetaElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::ElementTypeId;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, ElementNodeTypeId};
use dom::node::{Node, NodeTypeId};
use servo_util::str::DOMString;
#[dom_struct]
@ -20,14 +20,14 @@ pub struct HTMLMetaElement {
impl HTMLMetaElementDerived for EventTarget {
fn is_htmlmetaelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLMetaElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLMetaElement))
}
}
impl HTMLMetaElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLMetaElement {
HTMLMetaElement {
htmlelement: HTMLElement::new_inherited(HTMLMetaElementTypeId, localName, prefix, document)
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLMetaElement, localName, prefix, document)
}
}

10
components/script/dom/htmlmeterelement.rs
View file

@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLMeterElementDerived;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::HTMLMeterElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::ElementTypeId;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, ElementNodeTypeId};
use dom::node::{Node, NodeTypeId};
use servo_util::str::DOMString;
#[dom_struct]
@ -20,14 +20,14 @@ pub struct HTMLMeterElement {
impl HTMLMeterElementDerived for EventTarget {
fn is_htmlmeterelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLMeterElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLMeterElement))
}
}
impl HTMLMeterElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLMeterElement {
HTMLMeterElement {
htmlelement: HTMLElement::new_inherited(HTMLMeterElementTypeId, localName, prefix, document)
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLMeterElement, localName, prefix, document)
}
}

10
components/script/dom/htmlmodelement.rs
View file

@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLModElementDerived;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::HTMLModElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::ElementTypeId;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, ElementNodeTypeId};
use dom::node::{Node, NodeTypeId};
use servo_util::str::DOMString;
#[dom_struct]
@ -20,14 +20,14 @@ pub struct HTMLModElement {
impl HTMLModElementDerived for EventTarget {
fn is_htmlmodelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLModElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLModElement))
}
}
impl HTMLModElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLModElement {
HTMLModElement {
htmlelement: HTMLElement::new_inherited(HTMLModElementTypeId, localName, prefix, document)
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLModElement, localName, prefix, document)
}
}

10
components/script/dom/htmlobjectelement.rs
View file

@ -12,11 +12,11 @@ use dom::bindings::codegen::InheritTypes::{ElementCast, HTMLElementCast};
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::{Element, HTMLObjectElementTypeId};
use dom::element::{Element, ElementTypeId};
use dom::element::AttributeHandlers;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, ElementNodeTypeId, NodeHelpers, window_from_node};
use dom::node::{Node, NodeTypeId, NodeHelpers, window_from_node};
use dom::validitystate::ValidityState;
use dom::virtualmethods::VirtualMethods;
@ -34,14 +34,14 @@ pub struct HTMLObjectElement {
impl HTMLObjectElementDerived for EventTarget {
fn is_htmlobjectelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLObjectElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLObjectElement))
}
}
impl HTMLObjectElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLObjectElement {
HTMLObjectElement {
htmlelement: HTMLElement::new_inherited(HTMLObjectElementTypeId, localName, prefix, document),
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLObjectElement, localName, prefix, document),
}
}

10
components/script/dom/htmlolistelement.rs
View file

@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLOListElementDerived;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::HTMLOListElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::ElementTypeId;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, ElementNodeTypeId};
use dom::node::{Node, NodeTypeId};
use servo_util::str::DOMString;
#[dom_struct]
@ -20,14 +20,14 @@ pub struct HTMLOListElement {
impl HTMLOListElementDerived for EventTarget {
fn is_htmlolistelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLOListElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLOListElement))
}
}
impl HTMLOListElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLOListElement {
HTMLOListElement {
htmlelement: HTMLElement::new_inherited(HTMLOListElementTypeId, localName, prefix, document)
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLOListElement, localName, prefix, document)
}
}

10
components/script/dom/htmloptgroupelement.rs
View file

@ -11,10 +11,10 @@ use dom::bindings::codegen::InheritTypes::{HTMLOptGroupElementDerived, HTMLOptio
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::{AttributeHandlers, HTMLOptGroupElementTypeId};
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::{AttributeHandlers, ElementTypeId};
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{DisabledStateHelpers, Node, NodeHelpers, ElementNodeTypeId};
use dom::node::{DisabledStateHelpers, Node, NodeHelpers, NodeTypeId};
use dom::virtualmethods::VirtualMethods;
use servo_util::str::DOMString;
@ -27,14 +27,14 @@ pub struct HTMLOptGroupElement {
impl HTMLOptGroupElementDerived for EventTarget {
fn is_htmloptgroupelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLOptGroupElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLOptGroupElement))
}
}
impl HTMLOptGroupElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLOptGroupElement {
HTMLOptGroupElement {
htmlelement: HTMLElement::new_inherited(HTMLOptGroupElementTypeId, localName, prefix, document)
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLOptGroupElement, localName, prefix, document)
}
}

10
components/script/dom/htmloptionelement.rs
View file

@ -15,10 +15,10 @@ use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::characterdata::CharacterData;
use dom::document::Document;
use dom::element::{AttributeHandlers, Element, ElementHelpers, HTMLOptionElementTypeId};
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::{AttributeHandlers, Element, ElementHelpers, ElementTypeId};
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{DisabledStateHelpers, Node, NodeHelpers, ElementNodeTypeId};
use dom::node::{DisabledStateHelpers, Node, NodeHelpers, NodeTypeId};
use dom::virtualmethods::VirtualMethods;
use servo_util::str::{DOMString, split_html_space_chars};
@ -31,14 +31,14 @@ pub struct HTMLOptionElement {
impl HTMLOptionElementDerived for EventTarget {
fn is_htmloptionelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLOptionElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLOptionElement))
}
}
impl HTMLOptionElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLOptionElement {
HTMLOptionElement {
htmlelement: HTMLElement::new_inherited(HTMLOptionElementTypeId, localName, prefix, document)
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLOptionElement, localName, prefix, document)
}
}

10
components/script/dom/htmloutputelement.rs
View file

@ -8,10 +8,10 @@ use dom::bindings::codegen::InheritTypes::HTMLOutputElementDerived;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::HTMLOutputElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::ElementTypeId;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, ElementNodeTypeId, window_from_node};
use dom::node::{Node, NodeTypeId, window_from_node};
use dom::validitystate::ValidityState;
use servo_util::str::DOMString;
@ -22,14 +22,14 @@ pub struct HTMLOutputElement {
impl HTMLOutputElementDerived for EventTarget {
fn is_htmloutputelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLOutputElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLOutputElement))
}
}
impl HTMLOutputElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLOutputElement {
HTMLOutputElement {
htmlelement: HTMLElement::new_inherited(HTMLOutputElementTypeId, localName, prefix, document)
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLOutputElement, localName, prefix, document)
}
}

10
components/script/dom/htmlparagraphelement.rs
View file

@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLParagraphElementDerived;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::HTMLParagraphElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::ElementTypeId;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, ElementNodeTypeId};
use dom::node::{Node, NodeTypeId};
use servo_util::str::DOMString;
#[dom_struct]
@ -20,14 +20,14 @@ pub struct HTMLParagraphElement {
impl HTMLParagraphElementDerived for EventTarget {
fn is_htmlparagraphelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLParagraphElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLParagraphElement))
}
}
impl HTMLParagraphElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLParagraphElement {
HTMLParagraphElement {
htmlelement: HTMLElement::new_inherited(HTMLParagraphElementTypeId, localName, prefix, document)
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLParagraphElement, localName, prefix, document)
}
}

10
components/script/dom/htmlparamelement.rs
View file

@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLParamElementDerived;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::HTMLParamElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::ElementTypeId;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, ElementNodeTypeId};
use dom::node::{Node, NodeTypeId};
use servo_util::str::DOMString;
#[dom_struct]
@ -20,14 +20,14 @@ pub struct HTMLParamElement {
impl HTMLParamElementDerived for EventTarget {
fn is_htmlparamelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLParamElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLParamElement))
}
}
impl HTMLParamElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLParamElement {
HTMLParamElement {
htmlelement: HTMLElement::new_inherited(HTMLParamElementTypeId, localName, prefix, document)
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLParamElement, localName, prefix, document)
}
}

10
components/script/dom/htmlpreelement.rs
View file

@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLPreElementDerived;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::HTMLPreElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::ElementTypeId;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, ElementNodeTypeId};
use dom::node::{Node, NodeTypeId};
use servo_util::str::DOMString;
#[dom_struct]
@ -20,14 +20,14 @@ pub struct HTMLPreElement {
impl HTMLPreElementDerived for EventTarget {
fn is_htmlpreelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLPreElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLPreElement))
}
}
impl HTMLPreElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLPreElement {
HTMLPreElement {
htmlelement: HTMLElement::new_inherited(HTMLPreElementTypeId, localName, prefix, document)
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLPreElement, localName, prefix, document)
}
}

10
components/script/dom/htmlprogresselement.rs
View file

@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLProgressElementDerived;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::HTMLProgressElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::ElementTypeId;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, ElementNodeTypeId};
use dom::node::{Node, NodeTypeId};
use servo_util::str::DOMString;
#[dom_struct]
@ -20,14 +20,14 @@ pub struct HTMLProgressElement {
impl HTMLProgressElementDerived for EventTarget {
fn is_htmlprogresselement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLProgressElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLProgressElement))
}
}
impl HTMLProgressElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLProgressElement {
HTMLProgressElement {
htmlelement: HTMLElement::new_inherited(HTMLProgressElementTypeId, localName, prefix, document)
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLProgressElement, localName, prefix, document)
}
}

10
components/script/dom/htmlquoteelement.rs
View file

@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLQuoteElementDerived;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::HTMLQuoteElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::ElementTypeId;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, ElementNodeTypeId};
use dom::node::{Node, NodeTypeId};
use servo_util::str::DOMString;
#[dom_struct]
@ -20,14 +20,14 @@ pub struct HTMLQuoteElement {
impl HTMLQuoteElementDerived for EventTarget {
fn is_htmlquoteelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLQuoteElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLQuoteElement))
}
}
impl HTMLQuoteElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLQuoteElement {
HTMLQuoteElement {
htmlelement: HTMLElement::new_inherited(HTMLQuoteElementTypeId, localName, prefix, document)
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLQuoteElement, localName, prefix, document)
}
}

19
components/script/dom/htmlscriptelement.rs
View file

@ -15,16 +15,15 @@ use dom::bindings::codegen::InheritTypes::{ElementCast, HTMLElementCast, NodeCas
use dom::bindings::js::{JSRef, Temporary, OptionalRootable};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::{HTMLScriptElementTypeId, Element, AttributeHandlers};
use dom::element::{ElementCreator, ParserCreated};
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::{ElementTypeId, Element, AttributeHandlers, ElementCreator};
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, NodeHelpers, ElementNodeTypeId, window_from_node, CloneChildrenFlag};
use dom::node::{Node, NodeHelpers, NodeTypeId, window_from_node, CloneChildrenFlag};
use dom::virtualmethods::VirtualMethods;
use dom::window::WindowHelpers;
use encoding::all::UTF_8;
use encoding::types::{Encoding, DecodeReplace};
use encoding::types::{Encoding, DecoderTrap};
use servo_net::resource_task::load_whole_resource;
use servo_util::str::{DOMString, HTML_SPACE_CHARACTERS, StaticStringVec};
use std::cell::Cell;
@ -54,7 +53,7 @@ pub struct HTMLScriptElement {
impl HTMLScriptElementDerived for EventTarget {
fn is_htmlscriptelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLScriptElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLScriptElement))
}
}
@ -62,10 +61,10 @@ impl HTMLScriptElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>,
creator: ElementCreator) -> HTMLScriptElement {
HTMLScriptElement {
htmlelement: HTMLElement::new_inherited(HTMLScriptElementTypeId, localName, prefix, document),
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLScriptElement, localName, prefix, document),
already_started: Cell::new(false),
parser_inserted: Cell::new(creator == ParserCreated),
non_blocking: Cell::new(creator != ParserCreated),
parser_inserted: Cell::new(creator == ElementCreator::ParserCreated),
non_blocking: Cell::new(creator != ElementCreator::ParserCreated),
ready_to_be_parser_executed: Cell::new(false),
}
}
@ -187,7 +186,7 @@ impl<'a> HTMLScriptElementHelpers for JSRef<'a, HTMLScriptElement> {
match load_whole_resource(&page.resource_task, url) {
Ok((metadata, bytes)) => {
// TODO: use the charset from step 13.
let source = UTF_8.decode(bytes.as_slice(), DecodeReplace).unwrap();
let source = UTF_8.decode(bytes.as_slice(), DecoderTrap::Replace).unwrap();
(source, metadata.final_url)
}
Err(_) => {

14
components/script/dom/htmlselectelement.rs
View file

@ -8,15 +8,15 @@ use dom::bindings::codegen::Bindings::HTMLSelectElementBinding;
use dom::bindings::codegen::Bindings::HTMLSelectElementBinding::HTMLSelectElementMethods;
use dom::bindings::codegen::InheritTypes::{HTMLElementCast, NodeCast};
use dom::bindings::codegen::InheritTypes::{ElementCast, HTMLSelectElementDerived, HTMLFieldSetElementDerived};
use dom::bindings::codegen::UnionTypes::HTMLElementOrLong::HTMLElementOrLong;
use dom::bindings::codegen::UnionTypes::HTMLOptionElementOrHTMLOptGroupElement::HTMLOptionElementOrHTMLOptGroupElement;
use dom::bindings::codegen::UnionTypes::HTMLElementOrLong;
use dom::bindings::codegen::UnionTypes::HTMLOptionElementOrHTMLOptGroupElement;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::{AttributeHandlers, Element, HTMLSelectElementTypeId};
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::{AttributeHandlers, Element, ElementTypeId};
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{DisabledStateHelpers, Node, NodeHelpers, ElementNodeTypeId, window_from_node};
use dom::node::{DisabledStateHelpers, Node, NodeHelpers, NodeTypeId, window_from_node};
use dom::validitystate::ValidityState;
use dom::virtualmethods::VirtualMethods;
@ -30,14 +30,14 @@ pub struct HTMLSelectElement {
impl HTMLSelectElementDerived for EventTarget {
fn is_htmlselectelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLSelectElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLSelectElement))
}
}
impl HTMLSelectElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLSelectElement {
HTMLSelectElement {
htmlelement: HTMLElement::new_inherited(HTMLSelectElementTypeId, localName, prefix, document)
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLSelectElement, localName, prefix, document)
}
}

19
components/script/dom/htmlserializer.rs
View file

@ -11,10 +11,7 @@ use dom::characterdata::CharacterData;
use dom::comment::Comment;
use dom::documenttype::DocumentType;
use dom::element::{Element, ElementHelpers};
use dom::node::{Node, NodeIterator};
use dom::node::{DoctypeNodeTypeId, DocumentFragmentNodeTypeId, CommentNodeTypeId};
use dom::node::{DocumentNodeTypeId, ElementNodeTypeId, ProcessingInstructionNodeTypeId};
use dom::node::{TextNodeTypeId, NodeHelpers};
use dom::node::{Node, NodeHelpers, NodeTypeId, NodeIterator};
use dom::processinginstruction::ProcessingInstruction;
use dom::text::Text;
@ -30,29 +27,29 @@ pub fn serialize(iterator: &mut NodeIterator) -> String {
html.push_str(">");
}
match node.type_id() {
ElementNodeTypeId(..) => {
NodeTypeId::Element(..) => {
let elem: JSRef<Element> = ElementCast::to_ref(node).unwrap();
serialize_elem(elem, &mut open_elements, &mut html)
}
CommentNodeTypeId => {
NodeTypeId::Comment => {
let comment: JSRef<Comment> = CommentCast::to_ref(node).unwrap();
serialize_comment(comment, &mut html)
}
TextNodeTypeId => {
NodeTypeId::Text => {
let text: JSRef<Text> = TextCast::to_ref(node).unwrap();
serialize_text(text, &mut html)
}
DoctypeNodeTypeId => {
NodeTypeId::DocumentType => {
let doctype: JSRef<DocumentType> = DocumentTypeCast::to_ref(node).unwrap();
serialize_doctype(doctype, &mut html)
}
ProcessingInstructionNodeTypeId => {
NodeTypeId::ProcessingInstruction => {
let processing_instruction: JSRef<ProcessingInstruction> =
ProcessingInstructionCast::to_ref(node).unwrap();
serialize_processing_instruction(processing_instruction, &mut html)
}
DocumentFragmentNodeTypeId => {}
DocumentNodeTypeId => {
NodeTypeId::DocumentFragment => {}
NodeTypeId::Document => {
panic!("It shouldn't be possible to serialize a document node")
}
}

10
components/script/dom/htmlsourceelement.rs
View file

@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLSourceElementDerived;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::HTMLSourceElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::ElementTypeId;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, ElementNodeTypeId};
use dom::node::{Node, NodeTypeId};
use servo_util::str::DOMString;
#[dom_struct]
@ -20,14 +20,14 @@ pub struct HTMLSourceElement {
impl HTMLSourceElementDerived for EventTarget {
fn is_htmlsourceelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLSourceElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLSourceElement))
}
}
impl HTMLSourceElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLSourceElement {
HTMLSourceElement {
htmlelement: HTMLElement::new_inherited(HTMLSourceElementTypeId, localName, prefix, document)
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLSourceElement, localName, prefix, document)
}
}

10
components/script/dom/htmlspanelement.rs
View file

@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLSpanElementDerived;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::HTMLSpanElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::ElementTypeId;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, ElementNodeTypeId};
use dom::node::{Node, NodeTypeId};
use servo_util::str::DOMString;
#[dom_struct]
@ -20,14 +20,14 @@ pub struct HTMLSpanElement {
impl HTMLSpanElementDerived for EventTarget {
fn is_htmlspanelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLSpanElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLSpanElement))
}
}
impl HTMLSpanElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLSpanElement {
HTMLSpanElement {
htmlelement: HTMLElement::new_inherited(HTMLSpanElementTypeId, localName, prefix, document)
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLSpanElement, localName, prefix, document)
}
}

15
components/script/dom/htmlstyleelement.rs
View file

@ -8,14 +8,14 @@ use dom::bindings::codegen::InheritTypes::{HTMLElementCast, HTMLStyleElementDeri
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::HTMLStyleElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::ElementTypeId;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, NodeHelpers, ElementNodeTypeId, window_from_node};
use dom::node::{Node, NodeHelpers, NodeTypeId, window_from_node};
use dom::virtualmethods::VirtualMethods;
use layout_interface::{AddStylesheetMsg, LayoutChan};
use servo_util::str::DOMString;
use style::{AuthorOrigin, Stylesheet};
use style::{StylesheetOrigin, Stylesheet};
#[dom_struct]
pub struct HTMLStyleElement {
@ -24,14 +24,14 @@ pub struct HTMLStyleElement {
impl HTMLStyleElementDerived for EventTarget {
fn is_htmlstyleelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLStyleElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLStyleElement))
}
}
impl HTMLStyleElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLStyleElement {
HTMLStyleElement {
htmlelement: HTMLElement::new_inherited(HTMLStyleElementTypeId, localName, prefix, document)
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLStyleElement, localName, prefix, document)
}
}
@ -55,7 +55,8 @@ impl<'a> StyleElementHelpers for JSRef<'a, HTMLStyleElement> {
let url = win.page().get_url();
let data = node.GetTextContent().expect("Element.textContent must be a string");
let sheet = Stylesheet::from_str(data.as_slice(), url, AuthorOrigin);
let sheet = Stylesheet::from_str(data.as_slice(), url,
StylesheetOrigin::Author);
let LayoutChan(ref layout_chan) = win.page().layout_chan;
layout_chan.send(AddStylesheetMsg(sheet));
}

10
components/script/dom/htmltablecaptionelement.rs
View file

@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLTableCaptionElementDerived;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::HTMLTableCaptionElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::ElementTypeId;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, ElementNodeTypeId};
use dom::node::{Node, NodeTypeId};
use servo_util::str::DOMString;
#[dom_struct]
@ -20,14 +20,14 @@ pub struct HTMLTableCaptionElement {
impl HTMLTableCaptionElementDerived for EventTarget {
fn is_htmltablecaptionelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLTableCaptionElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLTableCaptionElement))
}
}
impl HTMLTableCaptionElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLTableCaptionElement {
HTMLTableCaptionElement {
htmlelement: HTMLElement::new_inherited(HTMLTableCaptionElementTypeId, localName, prefix, document)
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLTableCaptionElement, localName, prefix, document)
}
}

17
components/script/dom/htmltablecellelement.rs
View file

@ -7,15 +7,14 @@ use dom::bindings::codegen::InheritTypes::{HTMLElementCast, HTMLTableCellElement
use dom::bindings::js::JSRef;
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::{ElementTypeId, HTMLTableDataCellElementTypeId};
use dom::element::{HTMLTableHeaderCellElementTypeId};
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::ElementTypeId;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::ElementNodeTypeId;
use dom::node::NodeTypeId;
use dom::virtualmethods::VirtualMethods;
use cssparser::RGBA;
use servo_util::str::{mod, AutoLpa, DOMString, LengthOrPercentageOrAuto};
use servo_util::str::{mod, DOMString, LengthOrPercentageOrAuto};
use std::cell::Cell;
#[dom_struct]
@ -29,8 +28,8 @@ pub struct HTMLTableCellElement {
impl HTMLTableCellElementDerived for EventTarget {
fn is_htmltablecellelement(&self) -> bool {
match *self.type_id() {
NodeTargetTypeId(ElementNodeTypeId(HTMLTableDataCellElementTypeId)) |
NodeTargetTypeId(ElementNodeTypeId(HTMLTableHeaderCellElementTypeId)) => true,
EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLTableDataCellElement)) |
EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLTableHeaderCellElement)) => true,
_ => false
}
}
@ -46,7 +45,7 @@ impl HTMLTableCellElement {
htmlelement: HTMLElement::new_inherited(type_id, tag_name, prefix, document),
background_color: Cell::new(None),
colspan: Cell::new(None),
width: Cell::new(AutoLpa),
width: Cell::new(LengthOrPercentageOrAuto::Auto),
}
}
@ -109,7 +108,7 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLTableCellElement> {
match attr.local_name() {
&atom!("bgcolor") => self.background_color.set(None),
&atom!("colspan") => self.colspan.set(None),
&atom!("width") => self.width.set(AutoLpa),
&atom!("width") => self.width.set(LengthOrPercentageOrAuto::Auto),
_ => ()
}
}

10
components/script/dom/htmltablecolelement.rs
View file

@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLTableColElementDerived;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::HTMLTableColElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::ElementTypeId;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, ElementNodeTypeId};
use dom::node::{Node, NodeTypeId};
use servo_util::str::DOMString;
#[dom_struct]
@ -20,14 +20,14 @@ pub struct HTMLTableColElement {
impl HTMLTableColElementDerived for EventTarget {
fn is_htmltablecolelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLTableColElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLTableColElement))
}
}
impl HTMLTableColElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLTableColElement {
HTMLTableColElement {
htmlelement: HTMLElement::new_inherited(HTMLTableColElementTypeId, localName, prefix, document)
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLTableColElement, localName, prefix, document)
}
}

10
components/script/dom/htmltabledatacellelement.rs
View file

@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLTableDataCellElementDerived;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::HTMLTableDataCellElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::ElementTypeId;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmltablecellelement::HTMLTableCellElement;
use dom::node::{Node, ElementNodeTypeId};
use dom::node::{Node, NodeTypeId};
use servo_util::str::DOMString;
#[dom_struct]
@ -20,14 +20,14 @@ pub struct HTMLTableDataCellElement {
impl HTMLTableDataCellElementDerived for EventTarget {
fn is_htmltabledatacellelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLTableDataCellElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLTableDataCellElement))
}
}
impl HTMLTableDataCellElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLTableDataCellElement {
HTMLTableDataCellElement {
htmltablecellelement: HTMLTableCellElement::new_inherited(HTMLTableDataCellElementTypeId, localName, prefix, document)
htmltablecellelement: HTMLTableCellElement::new_inherited(ElementTypeId::HTMLTableDataCellElement, localName, prefix, document)
}
}

16
components/script/dom/htmltableelement.rs
View file

@ -11,15 +11,15 @@ use dom::bindings::codegen::InheritTypes::{HTMLTableElementDerived, NodeCast};
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::HTMLTableElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::ElementTypeId;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::htmltablecaptionelement::HTMLTableCaptionElement;
use dom::node::{Node, NodeHelpers, ElementNodeTypeId};
use dom::node::{Node, NodeHelpers, NodeTypeId};
use dom::virtualmethods::VirtualMethods;
use cssparser::RGBA;
use servo_util::str::{mod, AutoLpa, DOMString, LengthOrPercentageOrAuto};
use servo_util::str::{mod, DOMString, LengthOrPercentageOrAuto};
use std::cell::Cell;
#[dom_struct]
@ -32,7 +32,7 @@ pub struct HTMLTableElement {
impl HTMLTableElementDerived for EventTarget {
fn is_htmltableelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLTableElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLTableElement))
}
}
@ -40,13 +40,13 @@ impl HTMLTableElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>)
-> HTMLTableElement {
HTMLTableElement {
htmlelement: HTMLElement::new_inherited(HTMLTableElementTypeId,
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLTableElement,
localName,
prefix,
document),
background_color: Cell::new(None),
border: Cell::new(None),
width: Cell::new(AutoLpa),
width: Cell::new(LengthOrPercentageOrAuto::Auto),
}
}
@ -151,7 +151,7 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLTableElement> {
match attr.local_name() {
&atom!("bgcolor") => self.background_color.set(None),
&atom!("border") => self.border.set(None),
&atom!("width") => self.width.set(AutoLpa),
&atom!("width") => self.width.set(LengthOrPercentageOrAuto::Auto),
_ => ()
}
}

10
components/script/dom/htmltableheadercellelement.rs
View file

@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLTableHeaderCellElementDerived;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::HTMLTableHeaderCellElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::ElementTypeId;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmltablecellelement::HTMLTableCellElement;
use dom::node::{Node, ElementNodeTypeId};
use dom::node::{Node, NodeTypeId};
use servo_util::str::DOMString;
#[dom_struct]
@ -20,14 +20,14 @@ pub struct HTMLTableHeaderCellElement {
impl HTMLTableHeaderCellElementDerived for EventTarget {
fn is_htmltableheadercellelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLTableHeaderCellElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLTableHeaderCellElement))
}
}
impl HTMLTableHeaderCellElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLTableHeaderCellElement {
HTMLTableHeaderCellElement {
htmltablecellelement: HTMLTableCellElement::new_inherited(HTMLTableHeaderCellElementTypeId, localName, prefix, document)
htmltablecellelement: HTMLTableCellElement::new_inherited(ElementTypeId::HTMLTableHeaderCellElement, localName, prefix, document)
}
}

10
components/script/dom/htmltablerowelement.rs
View file

@ -8,10 +8,10 @@ use dom::bindings::codegen::InheritTypes::{HTMLElementCast, HTMLTableRowElementD
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::HTMLTableRowElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::ElementTypeId;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, ElementNodeTypeId};
use dom::node::{Node, NodeTypeId};
use dom::virtualmethods::VirtualMethods;
use cssparser::RGBA;
@ -26,7 +26,7 @@ pub struct HTMLTableRowElement {
impl HTMLTableRowElementDerived for EventTarget {
fn is_htmltablerowelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLTableRowElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLTableRowElement))
}
}
@ -34,7 +34,7 @@ impl HTMLTableRowElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>)
-> HTMLTableRowElement {
HTMLTableRowElement {
htmlelement: HTMLElement::new_inherited(HTMLTableRowElementTypeId,
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLTableRowElement,
localName,
prefix,
document),

10
components/script/dom/htmltablesectionelement.rs
View file

@ -8,10 +8,10 @@ use dom::bindings::codegen::InheritTypes::{HTMLElementCast, HTMLTableSectionElem
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::HTMLTableSectionElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::ElementTypeId;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, ElementNodeTypeId};
use dom::node::{Node, NodeTypeId};
use dom::virtualmethods::VirtualMethods;
use cssparser::RGBA;
@ -26,7 +26,7 @@ pub struct HTMLTableSectionElement {
impl HTMLTableSectionElementDerived for EventTarget {
fn is_htmltablesectionelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLTableSectionElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLTableSectionElement))
}
}
@ -34,7 +34,7 @@ impl HTMLTableSectionElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>)
-> HTMLTableSectionElement {
HTMLTableSectionElement {
htmlelement: HTMLElement::new_inherited(HTMLTableSectionElementTypeId,
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLTableSectionElement,
localName,
prefix,
document),

10
components/script/dom/htmltemplateelement.rs
View file

@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLTemplateElementDerived;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::HTMLTemplateElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::ElementTypeId;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, ElementNodeTypeId};
use dom::node::{Node, NodeTypeId};
use servo_util::str::DOMString;
#[dom_struct]
@ -20,14 +20,14 @@ pub struct HTMLTemplateElement {
impl HTMLTemplateElementDerived for EventTarget {
fn is_htmltemplateelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLTemplateElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLTemplateElement))
}
}
impl HTMLTemplateElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLTemplateElement {
HTMLTemplateElement {
htmlelement: HTMLElement::new_inherited(HTMLTemplateElementTypeId, localName, prefix, document)
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLTemplateElement, localName, prefix, document)
}
}

32
components/script/dom/htmltextareaelement.rs
View file

@ -2,7 +2,7 @@
* 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::attr::{Attr, AttrValue, UIntAttrValue};
use dom::attr::{Attr, AttrValue};
use dom::attr::AttrHelpers;
use dom::bindings::cell::DOMRefCell;
use dom::bindings::codegen::Bindings::EventBinding::EventMethods;
@ -15,15 +15,15 @@ use dom::bindings::codegen::InheritTypes::{KeyboardEventCast, TextDerived};
use dom::bindings::js::{JS, JSRef, Temporary, OptionalRootable};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::{Document, DocumentHelpers};
use dom::element::{AttributeHandlers, HTMLTextAreaElementTypeId, Element};
use dom::element::{Element, AttributeHandlers, ElementTypeId};
use dom::event::Event;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::htmlformelement::FormControl;
use dom::keyboardevent::KeyboardEvent;
use dom::node::{DisabledStateHelpers, Node, NodeHelpers, OtherNodeDamage, ElementNodeTypeId};
use dom::node::{DisabledStateHelpers, Node, NodeHelpers, NodeDamage, NodeTypeId};
use dom::node::{document_from_node};
use textinput::{Multiple, TextInput, TriggerDefaultAction, DispatchInput, Nothing};
use textinput::{TextInput, Lines, KeyReaction};
use dom::virtualmethods::VirtualMethods;
use servo_util::str::DOMString;
@ -44,7 +44,7 @@ pub struct HTMLTextAreaElement {
impl HTMLTextAreaElementDerived for EventTarget {
fn is_htmltextareaelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLTextAreaElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLTextAreaElement))
}
}
@ -82,8 +82,8 @@ static DEFAULT_ROWS: u32 = 2;
impl HTMLTextAreaElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLTextAreaElement {
HTMLTextAreaElement {
htmlelement: HTMLElement::new_inherited(HTMLTextAreaElementTypeId, localName, prefix, document),
textinput: DOMRefCell::new(TextInput::new(Multiple, "".to_string())),
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLTextAreaElement, localName, prefix, document),
textinput: DOMRefCell::new(TextInput::new(Lines::Multiple, "".to_string())),
cols: Cell::new(DEFAULT_COLS),
rows: Cell::new(DEFAULT_ROWS),
value_changed: Cell::new(false),
@ -194,7 +194,7 @@ impl<'a> PrivateHTMLTextAreaElementHelpers for JSRef<'a, HTMLTextAreaElement> {
fn force_relayout(self) {
let doc = document_from_node(self).root();
let node: JSRef<Node> = NodeCast::from_ref(self);
doc.content_changed(node, OtherNodeDamage)
doc.content_changed(node, NodeDamage::OtherNodeDamage)
}
}
@ -218,14 +218,14 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLTextAreaElement> {
},
&atom!("cols") => {
match *attr.value() {
UIntAttrValue(_, value) => self.cols.set(value),
_ => panic!("Expected a UIntAttrValue"),
AttrValue::UInt(_, value) => self.cols.set(value),
_ => panic!("Expected an AttrValue::UInt"),
}
},
&atom!("rows") => {
match *attr.value() {
UIntAttrValue(_, value) => self.rows.set(value),
_ => panic!("Expected a UIntAttrValue"),
AttrValue::UInt(_, value) => self.rows.set(value),
_ => panic!("Expected an AttrValue::UInt"),
}
},
_ => ()
@ -318,12 +318,12 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLTextAreaElement> {
let keyevent: Option<JSRef<KeyboardEvent>> = KeyboardEventCast::to_ref(event);
keyevent.map(|event| {
match self.textinput.borrow_mut().handle_keydown(event) {
TriggerDefaultAction => (),
DispatchInput => {
KeyReaction::TriggerDefaultAction => (),
KeyReaction::DispatchInput => {
self.force_relayout();
self.value_changed.set(true);
}
Nothing => (),
KeyReaction::Nothing => (),
}
});
}

10
components/script/dom/htmltimeelement.rs
View file

@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLTimeElementDerived;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::HTMLTimeElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::ElementTypeId;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, ElementNodeTypeId};
use dom::node::{Node, NodeTypeId};
use servo_util::str::DOMString;
#[dom_struct]
@ -20,14 +20,14 @@ pub struct HTMLTimeElement {
impl HTMLTimeElementDerived for EventTarget {
fn is_htmltimeelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLTimeElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLTimeElement))
}
}
impl HTMLTimeElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLTimeElement {
HTMLTimeElement {
htmlelement: HTMLElement::new_inherited(HTMLTimeElementTypeId, localName, prefix, document)
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLTimeElement, localName, prefix, document)
}
}

10
components/script/dom/htmltitleelement.rs
View file

@ -10,10 +10,10 @@ use dom::bindings::codegen::InheritTypes::{TextCast};
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::{Document, DocumentHelpers};
use dom::element::HTMLTitleElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::ElementTypeId;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, NodeHelpers, ElementNodeTypeId};
use dom::node::{Node, NodeHelpers, NodeTypeId};
use dom::text::Text;
use dom::virtualmethods::VirtualMethods;
use servo_util::str::DOMString;
@ -25,14 +25,14 @@ pub struct HTMLTitleElement {
impl HTMLTitleElementDerived for EventTarget {
fn is_htmltitleelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLTitleElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLTitleElement))
}
}
impl HTMLTitleElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLTitleElement {
HTMLTitleElement {
htmlelement: HTMLElement::new_inherited(HTMLTitleElementTypeId, localName, prefix, document)
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLTitleElement, localName, prefix, document)
}
}

10
components/script/dom/htmltrackelement.rs
View file

@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLTrackElementDerived;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::HTMLTrackElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::ElementTypeId;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, ElementNodeTypeId};
use dom::node::{Node, NodeTypeId};
use servo_util::str::DOMString;
#[dom_struct]
@ -20,14 +20,14 @@ pub struct HTMLTrackElement {
impl HTMLTrackElementDerived for EventTarget {
fn is_htmltrackelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLTrackElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLTrackElement))
}
}
impl HTMLTrackElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLTrackElement {
HTMLTrackElement {
htmlelement: HTMLElement::new_inherited(HTMLTrackElementTypeId, localName, prefix, document)
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLTrackElement, localName, prefix, document)
}
}

10
components/script/dom/htmlulistelement.rs
View file

@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLUListElementDerived;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::HTMLUListElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::ElementTypeId;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, ElementNodeTypeId};
use dom::node::{Node, NodeTypeId};
use servo_util::str::DOMString;
#[dom_struct]
@ -20,14 +20,14 @@ pub struct HTMLUListElement {
impl HTMLUListElementDerived for EventTarget {
fn is_htmlulistelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLUListElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLUListElement))
}
}
impl HTMLUListElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLUListElement {
HTMLUListElement {
htmlelement: HTMLElement::new_inherited(HTMLUListElementTypeId, localName, prefix, document)
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLUListElement, localName, prefix, document)
}
}

10
components/script/dom/htmlunknownelement.rs
View file

@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLUnknownElementDerived;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::HTMLUnknownElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::ElementTypeId;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, ElementNodeTypeId};
use dom::node::{Node, NodeTypeId};
use servo_util::str::DOMString;
#[dom_struct]
@ -20,14 +20,14 @@ pub struct HTMLUnknownElement {
impl HTMLUnknownElementDerived for EventTarget {
fn is_htmlunknownelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLUnknownElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLUnknownElement))
}
}
impl HTMLUnknownElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLUnknownElement {
HTMLUnknownElement {
htmlelement: HTMLElement::new_inherited(HTMLUnknownElementTypeId, localName, prefix, document)
htmlelement: HTMLElement::new_inherited(ElementTypeId::HTMLUnknownElement, localName, prefix, document)
}
}

10
components/script/dom/htmlvideoelement.rs
View file

@ -7,10 +7,10 @@ use dom::bindings::codegen::InheritTypes::HTMLVideoElementDerived;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::HTMLVideoElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::element::ElementTypeId;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlmediaelement::HTMLMediaElement;
use dom::node::{Node, ElementNodeTypeId};
use dom::node::{Node, NodeTypeId};
use servo_util::str::DOMString;
#[dom_struct]
@ -20,14 +20,14 @@ pub struct HTMLVideoElement {
impl HTMLVideoElementDerived for EventTarget {
fn is_htmlvideoelement(&self) -> bool {
*self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLVideoElementTypeId))
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLVideoElement))
}
}
impl HTMLVideoElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLVideoElement {
HTMLVideoElement {
htmlmediaelement: HTMLMediaElement::new_inherited(HTMLVideoElementTypeId, localName, prefix, document)
htmlmediaelement: HTMLMediaElement::new_inherited(ElementTypeId::HTMLVideoElement, localName, prefix, document)
}
}

720
components/script/dom/keyboardevent.rs
View file

@ -11,7 +11,7 @@ use dom::bindings::global::GlobalRef;
use dom::bindings::global;
use dom::bindings::js::{JSRef, Temporary, RootedReference};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::event::{Event, KeyboardEventTypeId};
use dom::event::{Event, EventTypeId};
use dom::uievent::UIEvent;
use dom::window::Window;
use servo_msg::constellation_msg;
@ -37,14 +37,14 @@ pub struct KeyboardEvent {
impl KeyboardEventDerived for Event {
fn is_keyboardevent(&self) -> bool {
*self.type_id() == KeyboardEventTypeId
*self.type_id() == EventTypeId::KeyboardEvent
}
}
impl KeyboardEvent {
fn new_inherited() -> KeyboardEvent {
KeyboardEvent {
uievent: UIEvent::new_inherited(KeyboardEventTypeId),
uievent: UIEvent::new_inherited(EventTypeId::KeyboardEvent),
key: RefCell::new("".to_string()),
code: RefCell::new("".to_string()),
location: Cell::new(0),
@ -127,316 +127,316 @@ impl KeyboardEvent {
fn key_value(key: constellation_msg::Key, mods: constellation_msg::KeyModifiers) -> &'static str {
let shift = mods.contains(constellation_msg::SHIFT);
match key {
constellation_msg::KeySpace => " ",
constellation_msg::KeyApostrophe if shift => "\"",
constellation_msg::KeyApostrophe => "'",
constellation_msg::KeyComma if shift => "<",
constellation_msg::KeyComma => ",",
constellation_msg::KeyMinus if shift => "_",
constellation_msg::KeyMinus => "-",
constellation_msg::KeyPeriod if shift => ">",
constellation_msg::KeyPeriod => ".",
constellation_msg::KeySlash if shift => "?",
constellation_msg::KeySlash => "/",
constellation_msg::Key0 if shift => ")",
constellation_msg::Key0 => "0",
constellation_msg::Key1 if shift => "!",
constellation_msg::Key1 => "1",
constellation_msg::Key2 if shift => "@",
constellation_msg::Key2 => "2",
constellation_msg::Key3 if shift => "#",
constellation_msg::Key3 => "3",
constellation_msg::Key4 if shift => "$",
constellation_msg::Key4 => "4",
constellation_msg::Key5 if shift => "%",
constellation_msg::Key5 => "5",
constellation_msg::Key6 if shift => "^",
constellation_msg::Key6 => "6",
constellation_msg::Key7 if shift => "&",
constellation_msg::Key7 => "7",
constellation_msg::Key8 if shift => "*",
constellation_msg::Key8 => "8",
constellation_msg::Key9 if shift => "(",
constellation_msg::Key9 => "9",
constellation_msg::KeySemicolon if shift => ":",
constellation_msg::KeySemicolon => ";",
constellation_msg::KeyEqual if shift => "+",
constellation_msg::KeyEqual => "=",
constellation_msg::KeyA if shift => "A",
constellation_msg::KeyA => "a",
constellation_msg::KeyB if shift => "B",
constellation_msg::KeyB => "b",
constellation_msg::KeyC if shift => "C",
constellation_msg::KeyC => "c",
constellation_msg::KeyD if shift => "D",
constellation_msg::KeyD => "d",
constellation_msg::KeyE if shift => "E",
constellation_msg::KeyE => "e",
constellation_msg::KeyF if shift => "F",
constellation_msg::KeyF => "f",
constellation_msg::KeyG if shift => "G",
constellation_msg::KeyG => "g",
constellation_msg::KeyH if shift => "H",
constellation_msg::KeyH => "h",
constellation_msg::KeyI if shift => "I",
constellation_msg::KeyI => "i",
constellation_msg::KeyJ if shift => "J",
constellation_msg::KeyJ => "j",
constellation_msg::KeyK if shift => "K",
constellation_msg::KeyK => "k",
constellation_msg::KeyL if shift => "L",
constellation_msg::KeyL => "l",
constellation_msg::KeyM if shift => "M",
constellation_msg::KeyM => "m",
constellation_msg::KeyN if shift => "N",
constellation_msg::KeyN => "n",
constellation_msg::KeyO if shift => "O",
constellation_msg::KeyO => "o",
constellation_msg::KeyP if shift => "P",
constellation_msg::KeyP => "p",
constellation_msg::KeyQ if shift => "Q",
constellation_msg::KeyQ => "q",
constellation_msg::KeyR if shift => "R",
constellation_msg::KeyR => "r",
constellation_msg::KeyS if shift => "S",
constellation_msg::KeyS => "s",
constellation_msg::KeyT if shift => "T",
constellation_msg::KeyT => "t",
constellation_msg::KeyU if shift => "U",
constellation_msg::KeyU => "u",
constellation_msg::KeyV if shift => "V",
constellation_msg::KeyV => "v",
constellation_msg::KeyW if shift => "W",
constellation_msg::KeyW => "w",
constellation_msg::KeyX if shift => "X",
constellation_msg::KeyX => "x",
constellation_msg::KeyY if shift => "Y",
constellation_msg::KeyY => "y",
constellation_msg::KeyZ if shift => "Z",
constellation_msg::KeyZ => "z",
constellation_msg::KeyLeftBracket if shift => "{",
constellation_msg::KeyLeftBracket => "[",
constellation_msg::KeyBackslash if shift => "|",
constellation_msg::KeyBackslash => "\\",
constellation_msg::KeyRightBracket if shift => "}",
constellation_msg::KeyRightBracket => "]",
constellation_msg::KeyGraveAccent => "Dead",
constellation_msg::KeyWorld1 => "Unidentified",
constellation_msg::KeyWorld2 => "Unidentified",
constellation_msg::KeyEscape => "Escape",
constellation_msg::KeyEnter => "Enter",
constellation_msg::KeyTab => "Tab",
constellation_msg::KeyBackspace => "Backspace",
constellation_msg::KeyInsert => "Insert",
constellation_msg::KeyDelete => "Delete",
constellation_msg::KeyRight => "ArrowRight",
constellation_msg::KeyLeft => "ArrowLeft",
constellation_msg::KeyDown => "ArrowDown",
constellation_msg::KeyUp => "ArrowUp",
constellation_msg::KeyPageUp => "PageUp",
constellation_msg::KeyPageDown => "PageDown",
constellation_msg::KeyHome => "Home",
constellation_msg::KeyEnd => "End",
constellation_msg::KeyCapsLock => "CapsLock",
constellation_msg::KeyScrollLock => "ScrollLock",
constellation_msg::KeyNumLock => "NumLock",
constellation_msg::KeyPrintScreen => "PrintScreen",
constellation_msg::KeyPause => "Pause",
constellation_msg::KeyF1 => "F1",
constellation_msg::KeyF2 => "F2",
constellation_msg::KeyF3 => "F3",
constellation_msg::KeyF4 => "F4",
constellation_msg::KeyF5 => "F5",
constellation_msg::KeyF6 => "F6",
constellation_msg::KeyF7 => "F7",
constellation_msg::KeyF8 => "F8",
constellation_msg::KeyF9 => "F9",
constellation_msg::KeyF10 => "F10",
constellation_msg::KeyF11 => "F11",
constellation_msg::KeyF12 => "F12",
constellation_msg::KeyF13 => "F13",
constellation_msg::KeyF14 => "F14",
constellation_msg::KeyF15 => "F15",
constellation_msg::KeyF16 => "F16",
constellation_msg::KeyF17 => "F17",
constellation_msg::KeyF18 => "F18",
constellation_msg::KeyF19 => "F19",
constellation_msg::KeyF20 => "F20",
constellation_msg::KeyF21 => "F21",
constellation_msg::KeyF22 => "F22",
constellation_msg::KeyF23 => "F23",
constellation_msg::KeyF24 => "F24",
constellation_msg::KeyF25 => "F25",
constellation_msg::KeyKp0 => "0",
constellation_msg::KeyKp1 => "1",
constellation_msg::KeyKp2 => "2",
constellation_msg::KeyKp3 => "3",
constellation_msg::KeyKp4 => "4",
constellation_msg::KeyKp5 => "5",
constellation_msg::KeyKp6 => "6",
constellation_msg::KeyKp7 => "7",
constellation_msg::KeyKp8 => "8",
constellation_msg::KeyKp9 => "9",
constellation_msg::KeyKpDecimal => ".",
constellation_msg::KeyKpDivide => "/",
constellation_msg::KeyKpMultiply => "*",
constellation_msg::KeyKpSubtract => "-",
constellation_msg::KeyKpAdd => "+",
constellation_msg::KeyKpEnter => "Enter",
constellation_msg::KeyKpEqual => "=",
constellation_msg::KeyLeftShift => "Shift",
constellation_msg::KeyLeftControl => "Control",
constellation_msg::KeyLeftAlt => "Alt",
constellation_msg::KeyLeftSuper => "Super",
constellation_msg::KeyRightShift => "Shift",
constellation_msg::KeyRightControl => "Control",
constellation_msg::KeyRightAlt => "Alt",
constellation_msg::KeyRightSuper => "Super",
constellation_msg::KeyMenu => "ContextMenu",
constellation_msg::Key::Space => " ",
constellation_msg::Key::Apostrophe if shift => "\"",
constellation_msg::Key::Apostrophe => "'",
constellation_msg::Key::Comma if shift => "<",
constellation_msg::Key::Comma => ",",
constellation_msg::Key::Minus if shift => "_",
constellation_msg::Key::Minus => "-",
constellation_msg::Key::Period if shift => ">",
constellation_msg::Key::Period => ".",
constellation_msg::Key::Slash if shift => "?",
constellation_msg::Key::Slash => "/",
constellation_msg::Key::Num0 if shift => ")",
constellation_msg::Key::Num0 => "0",
constellation_msg::Key::Num1 if shift => "!",
constellation_msg::Key::Num1 => "1",
constellation_msg::Key::Num2 if shift => "@",
constellation_msg::Key::Num2 => "2",
constellation_msg::Key::Num3 if shift => "#",
constellation_msg::Key::Num3 => "3",
constellation_msg::Key::Num4 if shift => "$",
constellation_msg::Key::Num4 => "4",
constellation_msg::Key::Num5 if shift => "%",
constellation_msg::Key::Num5 => "5",
constellation_msg::Key::Num6 if shift => "^",
constellation_msg::Key::Num6 => "6",
constellation_msg::Key::Num7 if shift => "&",
constellation_msg::Key::Num7 => "7",
constellation_msg::Key::Num8 if shift => "*",
constellation_msg::Key::Num8 => "8",
constellation_msg::Key::Num9 if shift => "(",
constellation_msg::Key::Num9 => "9",
constellation_msg::Key::Semicolon if shift => ":",
constellation_msg::Key::Semicolon => ";",
constellation_msg::Key::Equal if shift => "+",
constellation_msg::Key::Equal => "=",
constellation_msg::Key::A if shift => "A",
constellation_msg::Key::A => "a",
constellation_msg::Key::B if shift => "B",
constellation_msg::Key::B => "b",
constellation_msg::Key::C if shift => "C",
constellation_msg::Key::C => "c",
constellation_msg::Key::D if shift => "D",
constellation_msg::Key::D => "d",
constellation_msg::Key::E if shift => "E",
constellation_msg::Key::E => "e",
constellation_msg::Key::F if shift => "F",
constellation_msg::Key::F => "f",
constellation_msg::Key::G if shift => "G",
constellation_msg::Key::G => "g",
constellation_msg::Key::H if shift => "H",
constellation_msg::Key::H => "h",
constellation_msg::Key::I if shift => "I",
constellation_msg::Key::I => "i",
constellation_msg::Key::J if shift => "J",
constellation_msg::Key::J => "j",
constellation_msg::Key::K if shift => "K",
constellation_msg::Key::K => "k",
constellation_msg::Key::L if shift => "L",
constellation_msg::Key::L => "l",
constellation_msg::Key::M if shift => "M",
constellation_msg::Key::M => "m",
constellation_msg::Key::N if shift => "N",
constellation_msg::Key::N => "n",
constellation_msg::Key::O if shift => "O",
constellation_msg::Key::O => "o",
constellation_msg::Key::P if shift => "P",
constellation_msg::Key::P => "p",
constellation_msg::Key::Q if shift => "Q",
constellation_msg::Key::Q => "q",
constellation_msg::Key::R if shift => "R",
constellation_msg::Key::R => "r",
constellation_msg::Key::S if shift => "S",
constellation_msg::Key::S => "s",
constellation_msg::Key::T if shift => "T",
constellation_msg::Key::T => "t",
constellation_msg::Key::U if shift => "U",
constellation_msg::Key::U => "u",
constellation_msg::Key::V if shift => "V",
constellation_msg::Key::V => "v",
constellation_msg::Key::W if shift => "W",
constellation_msg::Key::W => "w",
constellation_msg::Key::X if shift => "X",
constellation_msg::Key::X => "x",
constellation_msg::Key::Y if shift => "Y",
constellation_msg::Key::Y => "y",
constellation_msg::Key::Z if shift => "Z",
constellation_msg::Key::Z => "z",
constellation_msg::Key::LeftBracket if shift => "{",
constellation_msg::Key::LeftBracket => "[",
constellation_msg::Key::Backslash if shift => "|",
constellation_msg::Key::Backslash => "\\",
constellation_msg::Key::RightBracket if shift => "}",
constellation_msg::Key::RightBracket => "]",
constellation_msg::Key::GraveAccent => "Dead",
constellation_msg::Key::World1 => "Unidentified",
constellation_msg::Key::World2 => "Unidentified",
constellation_msg::Key::Escape => "Escape",
constellation_msg::Key::Enter => "Enter",
constellation_msg::Key::Tab => "Tab",
constellation_msg::Key::Backspace => "Backspace",
constellation_msg::Key::Insert => "Insert",
constellation_msg::Key::Delete => "Delete",
constellation_msg::Key::Right => "ArrowRight",
constellation_msg::Key::Left => "ArrowLeft",
constellation_msg::Key::Down => "ArrowDown",
constellation_msg::Key::Up => "ArrowUp",
constellation_msg::Key::PageUp => "PageUp",
constellation_msg::Key::PageDown => "PageDown",
constellation_msg::Key::Home => "Home",
constellation_msg::Key::End => "End",
constellation_msg::Key::CapsLock => "CapsLock",
constellation_msg::Key::ScrollLock => "ScrollLock",
constellation_msg::Key::NumLock => "NumLock",
constellation_msg::Key::PrintScreen => "PrintScreen",
constellation_msg::Key::Pause => "Pause",
constellation_msg::Key::F1 => "F1",
constellation_msg::Key::F2 => "F2",
constellation_msg::Key::F3 => "F3",
constellation_msg::Key::F4 => "F4",
constellation_msg::Key::F5 => "F5",
constellation_msg::Key::F6 => "F6",
constellation_msg::Key::F7 => "F7",
constellation_msg::Key::F8 => "F8",
constellation_msg::Key::F9 => "F9",
constellation_msg::Key::F10 => "F10",
constellation_msg::Key::F11 => "F11",
constellation_msg::Key::F12 => "F12",
constellation_msg::Key::F13 => "F13",
constellation_msg::Key::F14 => "F14",
constellation_msg::Key::F15 => "F15",
constellation_msg::Key::F16 => "F16",
constellation_msg::Key::F17 => "F17",
constellation_msg::Key::F18 => "F18",
constellation_msg::Key::F19 => "F19",
constellation_msg::Key::F20 => "F20",
constellation_msg::Key::F21 => "F21",
constellation_msg::Key::F22 => "F22",
constellation_msg::Key::F23 => "F23",
constellation_msg::Key::F24 => "F24",
constellation_msg::Key::F25 => "F25",
constellation_msg::Key::Kp0 => "0",
constellation_msg::Key::Kp1 => "1",
constellation_msg::Key::Kp2 => "2",
constellation_msg::Key::Kp3 => "3",
constellation_msg::Key::Kp4 => "4",
constellation_msg::Key::Kp5 => "5",
constellation_msg::Key::Kp6 => "6",
constellation_msg::Key::Kp7 => "7",
constellation_msg::Key::Kp8 => "8",
constellation_msg::Key::Kp9 => "9",
constellation_msg::Key::KpDecimal => ".",
constellation_msg::Key::KpDivide => "/",
constellation_msg::Key::KpMultiply => "*",
constellation_msg::Key::KpSubtract => "-",
constellation_msg::Key::KpAdd => "+",
constellation_msg::Key::KpEnter => "Enter",
constellation_msg::Key::KpEqual => "=",
constellation_msg::Key::LeftShift => "Shift",
constellation_msg::Key::LeftControl => "Control",
constellation_msg::Key::LeftAlt => "Alt",
constellation_msg::Key::LeftSuper => "Super",
constellation_msg::Key::RightShift => "Shift",
constellation_msg::Key::RightControl => "Control",
constellation_msg::Key::RightAlt => "Alt",
constellation_msg::Key::RightSuper => "Super",
constellation_msg::Key::Menu => "ContextMenu",
}
}
// https://dvcs.w3.org/hg/dom3events/raw-file/tip/html/DOM3Events-code.html
fn code_value(key: constellation_msg::Key) -> &'static str {
match key {
constellation_msg::KeySpace => "Space",
constellation_msg::KeyApostrophe => "Quote",
constellation_msg::KeyComma => "Comma",
constellation_msg::KeyMinus => "Minus",
constellation_msg::KeyPeriod => "Period",
constellation_msg::KeySlash => "Slash",
constellation_msg::Key0 => "Digit0",
constellation_msg::Key1 => "Digit1",
constellation_msg::Key2 => "Digit2",
constellation_msg::Key3 => "Digit3",
constellation_msg::Key4 => "Digit4",
constellation_msg::Key5 => "Digit5",
constellation_msg::Key6 => "Digit6",
constellation_msg::Key7 => "Digit7",
constellation_msg::Key8 => "Digit8",
constellation_msg::Key9 => "Digit9",
constellation_msg::KeySemicolon => "Semicolon",
constellation_msg::KeyEqual => "Equals",
constellation_msg::KeyA => "KeyA",
constellation_msg::KeyB => "KeyB",
constellation_msg::KeyC => "KeyC",
constellation_msg::KeyD => "KeyD",
constellation_msg::KeyE => "KeyE",
constellation_msg::KeyF => "KeyF",
constellation_msg::KeyG => "KeyG",
constellation_msg::KeyH => "KeyH",
constellation_msg::KeyI => "KeyI",
constellation_msg::KeyJ => "KeyJ",
constellation_msg::KeyK => "KeyK",
constellation_msg::KeyL => "KeyL",
constellation_msg::KeyM => "KeyM",
constellation_msg::KeyN => "KeyN",
constellation_msg::KeyO => "KeyO",
constellation_msg::KeyP => "KeyP",
constellation_msg::KeyQ => "KeyQ",
constellation_msg::KeyR => "KeyR",
constellation_msg::KeyS => "KeyS",
constellation_msg::KeyT => "KeyT",
constellation_msg::KeyU => "KeyU",
constellation_msg::KeyV => "KeyV",
constellation_msg::KeyW => "KeyW",
constellation_msg::KeyX => "KeyX",
constellation_msg::KeyY => "KeyY",
constellation_msg::KeyZ => "KeyZ",
constellation_msg::KeyLeftBracket => "BracketLeft",
constellation_msg::KeyBackslash => "Backslash",
constellation_msg::KeyRightBracket => "BracketRight",
constellation_msg::Key::Space => "Space",
constellation_msg::Key::Apostrophe => "Quote",
constellation_msg::Key::Comma => "Comma",
constellation_msg::Key::Minus => "Minus",
constellation_msg::Key::Period => "Period",
constellation_msg::Key::Slash => "Slash",
constellation_msg::Key::Num0 => "Digit0",
constellation_msg::Key::Num1 => "Digit1",
constellation_msg::Key::Num2 => "Digit2",
constellation_msg::Key::Num3 => "Digit3",
constellation_msg::Key::Num4 => "Digit4",
constellation_msg::Key::Num5 => "Digit5",
constellation_msg::Key::Num6 => "Digit6",
constellation_msg::Key::Num7 => "Digit7",
constellation_msg::Key::Num8 => "Digit8",
constellation_msg::Key::Num9 => "Digit9",
constellation_msg::Key::Semicolon => "Semicolon",
constellation_msg::Key::Equal => "Equals",
constellation_msg::Key::A => "Key::A",
constellation_msg::Key::B => "Key::B",
constellation_msg::Key::C => "Key::C",
constellation_msg::Key::D => "Key::D",
constellation_msg::Key::E => "Key::E",
constellation_msg::Key::F => "Key::F",
constellation_msg::Key::G => "Key::G",
constellation_msg::Key::H => "Key::H",
constellation_msg::Key::I => "Key::I",
constellation_msg::Key::J => "Key::J",
constellation_msg::Key::K => "Key::K",
constellation_msg::Key::L => "Key::L",
constellation_msg::Key::M => "Key::M",
constellation_msg::Key::N => "Key::N",
constellation_msg::Key::O => "Key::O",
constellation_msg::Key::P => "Key::P",
constellation_msg::Key::Q => "Key::Q",
constellation_msg::Key::R => "Key::R",
constellation_msg::Key::S => "Key::S",
constellation_msg::Key::T => "Key::T",
constellation_msg::Key::U => "Key::U",
constellation_msg::Key::V => "Key::V",
constellation_msg::Key::W => "Key::W",
constellation_msg::Key::X => "Key::X",
constellation_msg::Key::Y => "Key::Y",
constellation_msg::Key::Z => "Key::Z",
constellation_msg::Key::LeftBracket => "BracketLeft",
constellation_msg::Key::Backslash => "Backslash",
constellation_msg::Key::RightBracket => "BracketRight",
constellation_msg::KeyGraveAccent |
constellation_msg::KeyWorld1 |
constellation_msg::KeyWorld2 => panic!("unknown char code for {}", key),
constellation_msg::Key::GraveAccent |
constellation_msg::Key::World1 |
constellation_msg::Key::World2 => panic!("unknown char code for {}", key),
constellation_msg::KeyEscape => "Escape",
constellation_msg::KeyEnter => "Enter",
constellation_msg::KeyTab => "Tab",
constellation_msg::KeyBackspace => "Backspace",
constellation_msg::KeyInsert => "Insert",
constellation_msg::KeyDelete => "Delete",
constellation_msg::KeyRight => "ArrowRight",
constellation_msg::KeyLeft => "ArrowLeft",
constellation_msg::KeyDown => "ArrowDown",
constellation_msg::KeyUp => "ArrowUp",
constellation_msg::KeyPageUp => "PageUp",
constellation_msg::KeyPageDown => "PageDown",
constellation_msg::KeyHome => "Home",
constellation_msg::KeyEnd => "End",
constellation_msg::KeyCapsLock => "CapsLock",
constellation_msg::KeyScrollLock => "ScrollLock",
constellation_msg::KeyNumLock => "NumLock",
constellation_msg::KeyPrintScreen => "PrintScreen",
constellation_msg::KeyPause => "Pause",
constellation_msg::KeyF1 => "F1",
constellation_msg::KeyF2 => "F2",
constellation_msg::KeyF3 => "F3",
constellation_msg::KeyF4 => "F4",
constellation_msg::KeyF5 => "F5",
constellation_msg::KeyF6 => "F6",
constellation_msg::KeyF7 => "F7",
constellation_msg::KeyF8 => "F8",
constellation_msg::KeyF9 => "F9",
constellation_msg::KeyF10 => "F10",
constellation_msg::KeyF11 => "F11",
constellation_msg::KeyF12 => "F12",
constellation_msg::KeyF13 => "F13",
constellation_msg::KeyF14 => "F14",
constellation_msg::KeyF15 => "F15",
constellation_msg::KeyF16 => "F16",
constellation_msg::KeyF17 => "F17",
constellation_msg::KeyF18 => "F18",
constellation_msg::KeyF19 => "F19",
constellation_msg::KeyF20 => "F20",
constellation_msg::KeyF21 => "F21",
constellation_msg::KeyF22 => "F22",
constellation_msg::KeyF23 => "F23",
constellation_msg::KeyF24 => "F24",
constellation_msg::KeyF25 => "F25",
constellation_msg::KeyKp0 => "Numpad0",
constellation_msg::KeyKp1 => "Numpad1",
constellation_msg::KeyKp2 => "Numpad2",
constellation_msg::KeyKp3 => "Numpad3",
constellation_msg::KeyKp4 => "Numpad4",
constellation_msg::KeyKp5 => "Numpad5",
constellation_msg::KeyKp6 => "Numpad6",
constellation_msg::KeyKp7 => "Numpad7",
constellation_msg::KeyKp8 => "Numpad8",
constellation_msg::KeyKp9 => "Numpad9",
constellation_msg::KeyKpDecimal => "NumpadDecimal",
constellation_msg::KeyKpDivide => "NumpadDivide",
constellation_msg::KeyKpMultiply => "NumpadMultiply",
constellation_msg::KeyKpSubtract => "NumpadSubtract",
constellation_msg::KeyKpAdd => "NumpadAdd",
constellation_msg::KeyKpEnter => "NumpadEnter",
constellation_msg::KeyKpEqual => "NumpadEquals",
constellation_msg::KeyLeftShift | constellation_msg::KeyRightShift => "Shift",
constellation_msg::KeyLeftControl | constellation_msg::KeyRightControl => "Control",
constellation_msg::KeyLeftAlt | constellation_msg::KeyRightAlt => "Alt",
constellation_msg::KeyLeftSuper | constellation_msg::KeyRightSuper => "Super",
constellation_msg::KeyMenu => "Menu",
constellation_msg::Key::Escape => "Escape",
constellation_msg::Key::Enter => "Enter",
constellation_msg::Key::Tab => "Tab",
constellation_msg::Key::Backspace => "Backspace",
constellation_msg::Key::Insert => "Insert",
constellation_msg::Key::Delete => "Delete",
constellation_msg::Key::Right => "ArrowRight",
constellation_msg::Key::Left => "ArrowLeft",
constellation_msg::Key::Down => "ArrowDown",
constellation_msg::Key::Up => "ArrowUp",
constellation_msg::Key::PageUp => "PageUp",
constellation_msg::Key::PageDown => "PageDown",
constellation_msg::Key::Home => "Home",
constellation_msg::Key::End => "End",
constellation_msg::Key::CapsLock => "CapsLock",
constellation_msg::Key::ScrollLock => "ScrollLock",
constellation_msg::Key::NumLock => "NumLock",
constellation_msg::Key::PrintScreen => "PrintScreen",
constellation_msg::Key::Pause => "Pause",
constellation_msg::Key::F1 => "F1",
constellation_msg::Key::F2 => "F2",
constellation_msg::Key::F3 => "F3",
constellation_msg::Key::F4 => "F4",
constellation_msg::Key::F5 => "F5",
constellation_msg::Key::F6 => "F6",
constellation_msg::Key::F7 => "F7",
constellation_msg::Key::F8 => "F8",
constellation_msg::Key::F9 => "F9",
constellation_msg::Key::F10 => "F10",
constellation_msg::Key::F11 => "F11",
constellation_msg::Key::F12 => "F12",
constellation_msg::Key::F13 => "F13",
constellation_msg::Key::F14 => "F14",
constellation_msg::Key::F15 => "F15",
constellation_msg::Key::F16 => "F16",
constellation_msg::Key::F17 => "F17",
constellation_msg::Key::F18 => "F18",
constellation_msg::Key::F19 => "F19",
constellation_msg::Key::F20 => "F20",
constellation_msg::Key::F21 => "F21",
constellation_msg::Key::F22 => "F22",
constellation_msg::Key::F23 => "F23",
constellation_msg::Key::F24 => "F24",
constellation_msg::Key::F25 => "F25",
constellation_msg::Key::Kp0 => "Numpad0",
constellation_msg::Key::Kp1 => "Numpad1",
constellation_msg::Key::Kp2 => "Numpad2",
constellation_msg::Key::Kp3 => "Numpad3",
constellation_msg::Key::Kp4 => "Numpad4",
constellation_msg::Key::Kp5 => "Numpad5",
constellation_msg::Key::Kp6 => "Numpad6",
constellation_msg::Key::Kp7 => "Numpad7",
constellation_msg::Key::Kp8 => "Numpad8",
constellation_msg::Key::Kp9 => "Numpad9",
constellation_msg::Key::KpDecimal => "NumpadDecimal",
constellation_msg::Key::KpDivide => "NumpadDivide",
constellation_msg::Key::KpMultiply => "NumpadMultiply",
constellation_msg::Key::KpSubtract => "NumpadSubtract",
constellation_msg::Key::KpAdd => "NumpadAdd",
constellation_msg::Key::KpEnter => "NumpadEnter",
constellation_msg::Key::KpEqual => "NumpadEquals",
constellation_msg::Key::LeftShift | constellation_msg::Key::RightShift => "Shift",
constellation_msg::Key::LeftControl | constellation_msg::Key::RightControl => "Control",
constellation_msg::Key::LeftAlt | constellation_msg::Key::RightAlt => "Alt",
constellation_msg::Key::LeftSuper | constellation_msg::Key::RightSuper => "Super",
constellation_msg::Key::Menu => "Menu",
}
}
fn key_location(key: constellation_msg::Key) -> u32 {
match key {
constellation_msg::KeyKp0 | constellation_msg::KeyKp1 | constellation_msg::KeyKp2 |
constellation_msg::KeyKp3 | constellation_msg::KeyKp4 | constellation_msg::KeyKp5 |
constellation_msg::KeyKp6 | constellation_msg::KeyKp7 | constellation_msg::KeyKp8 |
constellation_msg::KeyKp9 | constellation_msg::KeyKpDecimal |
constellation_msg::KeyKpDivide | constellation_msg::KeyKpMultiply |
constellation_msg::KeyKpSubtract | constellation_msg::KeyKpAdd |
constellation_msg::KeyKpEnter | constellation_msg::KeyKpEqual =>
constellation_msg::Key::Kp0 | constellation_msg::Key::Kp1 | constellation_msg::Key::Kp2 |
constellation_msg::Key::Kp3 | constellation_msg::Key::Kp4 | constellation_msg::Key::Kp5 |
constellation_msg::Key::Kp6 | constellation_msg::Key::Kp7 | constellation_msg::Key::Kp8 |
constellation_msg::Key::Kp9 | constellation_msg::Key::KpDecimal |
constellation_msg::Key::KpDivide | constellation_msg::Key::KpMultiply |
constellation_msg::Key::KpSubtract | constellation_msg::Key::KpAdd |
constellation_msg::Key::KpEnter | constellation_msg::Key::KpEqual =>
KeyboardEventConstants::DOM_KEY_LOCATION_NUMPAD,
constellation_msg::KeyLeftShift | constellation_msg::KeyLeftAlt |
constellation_msg::KeyLeftControl | constellation_msg::KeyLeftSuper =>
constellation_msg::Key::LeftShift | constellation_msg::Key::LeftAlt |
constellation_msg::Key::LeftControl | constellation_msg::Key::LeftSuper =>
KeyboardEventConstants::DOM_KEY_LOCATION_LEFT,
constellation_msg::KeyRightShift | constellation_msg::KeyRightAlt |
constellation_msg::KeyRightControl | constellation_msg::KeyRightSuper =>
constellation_msg::Key::RightShift | constellation_msg::Key::RightAlt |
constellation_msg::Key::RightControl | constellation_msg::Key::RightSuper =>
KeyboardEventConstants::DOM_KEY_LOCATION_RIGHT,
_ => KeyboardEventConstants::DOM_KEY_LOCATION_STANDARD,
@ -457,76 +457,76 @@ fn key_charcode(key: constellation_msg::Key, mods: constellation_msg::KeyModifie
fn key_keycode(key: constellation_msg::Key) -> u32 {
match key {
// https://dvcs.w3.org/hg/dom3events/raw-file/tip/html/DOM3-Events.html#legacy-key-models
constellation_msg::KeyBackspace => 8,
constellation_msg::KeyTab => 9,
constellation_msg::KeyEnter => 13,
constellation_msg::KeyLeftShift | constellation_msg::KeyRightShift => 16,
constellation_msg::KeyLeftControl | constellation_msg::KeyRightControl => 17,
constellation_msg::KeyLeftAlt | constellation_msg::KeyRightAlt => 18,
constellation_msg::KeyCapsLock => 20,
constellation_msg::KeyEscape => 27,
constellation_msg::KeySpace => 32,
constellation_msg::KeyPageUp => 33,
constellation_msg::KeyPageDown => 34,
constellation_msg::KeyEnd => 35,
constellation_msg::KeyHome => 36,
constellation_msg::KeyLeft => 37,
constellation_msg::KeyUp => 38,
constellation_msg::KeyRight => 39,
constellation_msg::KeyDown => 40,
constellation_msg::KeyDelete => 46,
constellation_msg::Key::Backspace => 8,
constellation_msg::Key::Tab => 9,
constellation_msg::Key::Enter => 13,
constellation_msg::Key::LeftShift | constellation_msg::Key::RightShift => 16,
constellation_msg::Key::LeftControl | constellation_msg::Key::RightControl => 17,
constellation_msg::Key::LeftAlt | constellation_msg::Key::RightAlt => 18,
constellation_msg::Key::CapsLock => 20,
constellation_msg::Key::Escape => 27,
constellation_msg::Key::Space => 32,
constellation_msg::Key::PageUp => 33,
constellation_msg::Key::PageDown => 34,
constellation_msg::Key::End => 35,
constellation_msg::Key::Home => 36,
constellation_msg::Key::Left => 37,
constellation_msg::Key::Up => 38,
constellation_msg::Key::Right => 39,
constellation_msg::Key::Down => 40,
constellation_msg::Key::Delete => 46,
// https://dvcs.w3.org/hg/dom3events/raw-file/tip/html/DOM3-Events.html#optionally-fixed-virtual-key-codes
constellation_msg::KeySemicolon => 186,
constellation_msg::KeyEqual => 187,
constellation_msg::KeyComma => 188,
constellation_msg::KeyMinus => 189,
constellation_msg::KeyPeriod => 190,
constellation_msg::KeySlash => 191,
constellation_msg::KeyLeftBracket => 219,
constellation_msg::KeyBackslash => 220,
constellation_msg::KeyRightBracket => 221,
constellation_msg::KeyApostrophe => 222,
constellation_msg::Key::Semicolon => 186,
constellation_msg::Key::Equal => 187,
constellation_msg::Key::Comma => 188,
constellation_msg::Key::Minus => 189,
constellation_msg::Key::Period => 190,
constellation_msg::Key::Slash => 191,
constellation_msg::Key::LeftBracket => 219,
constellation_msg::Key::Backslash => 220,
constellation_msg::Key::RightBracket => 221,
constellation_msg::Key::Apostrophe => 222,
//§ B.2.1.3
constellation_msg::Key0 |
constellation_msg::Key1 |
constellation_msg::Key2 |
constellation_msg::Key3 |
constellation_msg::Key4 |
constellation_msg::Key5 |
constellation_msg::Key6 |
constellation_msg::Key7 |
constellation_msg::Key8 |
constellation_msg::Key9 => key as u32 - constellation_msg::Key0 as u32 + '0' as u32,
constellation_msg::Key::Num0 |
constellation_msg::Key::Num1 |
constellation_msg::Key::Num2 |
constellation_msg::Key::Num3 |
constellation_msg::Key::Num4 |
constellation_msg::Key::Num5 |
constellation_msg::Key::Num6 |
constellation_msg::Key::Num7 |
constellation_msg::Key::Num8 |
constellation_msg::Key::Num9 => key as u32 - constellation_msg::Key::Num0 as u32 + '0' as u32,
//§ B.2.1.4
constellation_msg::KeyA |
constellation_msg::KeyB |
constellation_msg::KeyC |
constellation_msg::KeyD |
constellation_msg::KeyE |
constellation_msg::KeyF |
constellation_msg::KeyG |
constellation_msg::KeyH |
constellation_msg::KeyI |
constellation_msg::KeyJ |
constellation_msg::KeyK |
constellation_msg::KeyL |
constellation_msg::KeyM |
constellation_msg::KeyN |
constellation_msg::KeyO |
constellation_msg::KeyP |
constellation_msg::KeyQ |
constellation_msg::KeyR |
constellation_msg::KeyS |
constellation_msg::KeyT |
constellation_msg::KeyU |
constellation_msg::KeyV |
constellation_msg::KeyW |
constellation_msg::KeyX |
constellation_msg::KeyY |
constellation_msg::KeyZ => key as u32 - constellation_msg::KeyA as u32 + 'A' as u32,
constellation_msg::Key::A |
constellation_msg::Key::B |
constellation_msg::Key::C |
constellation_msg::Key::D |
constellation_msg::Key::E |
constellation_msg::Key::F |
constellation_msg::Key::G |
constellation_msg::Key::H |
constellation_msg::Key::I |
constellation_msg::Key::J |
constellation_msg::Key::K |
constellation_msg::Key::L |
constellation_msg::Key::M |
constellation_msg::Key::N |
constellation_msg::Key::O |
constellation_msg::Key::P |
constellation_msg::Key::Q |
constellation_msg::Key::R |
constellation_msg::Key::S |
constellation_msg::Key::T |
constellation_msg::Key::U |
constellation_msg::Key::V |
constellation_msg::Key::W |
constellation_msg::Key::X |
constellation_msg::Key::Y |
constellation_msg::Key::Z => key as u32 - constellation_msg::Key::A as u32 + 'A' as u32,
//§ B.2.1.8
_ => 0

6
components/script/dom/messageevent.rs
View file

@ -10,7 +10,7 @@ use dom::bindings::error::Fallible;
use dom::bindings::global::GlobalRef;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::event::{Event, MessageEventTypeId};
use dom::event::{Event, EventTypeId};
use dom::eventtarget::{EventTarget, EventTargetHelpers};
use servo_util::str::DOMString;
@ -28,7 +28,7 @@ pub struct MessageEvent {
impl MessageEventDerived for Event {
fn is_messageevent(&self) -> bool {
*self.type_id() == MessageEventTypeId
*self.type_id() == EventTypeId::MessageEvent
}
}
@ -36,7 +36,7 @@ impl MessageEvent {
fn new_inherited(data: JSVal, origin: DOMString, lastEventId: DOMString)
-> MessageEvent {
MessageEvent {
event: Event::new_inherited(MessageEventTypeId),
event: Event::new_inherited(EventTypeId::MessageEvent),
data: data,
origin: origin,
lastEventId: lastEventId,

6
components/script/dom/mouseevent.rs
View file

@ -11,7 +11,7 @@ use dom::bindings::global::GlobalRef;
use dom::bindings::global;
use dom::bindings::js::{MutNullableJS, JSRef, RootedReference, Temporary, OptionalSettable};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::event::{Event, MouseEventTypeId};
use dom::event::{Event, EventTypeId};
use dom::eventtarget::EventTarget;
use dom::uievent::UIEvent;
use dom::window::Window;
@ -36,14 +36,14 @@ pub struct MouseEvent {
impl MouseEventDerived for Event {
fn is_mouseevent(&self) -> bool {
*self.type_id() == MouseEventTypeId
*self.type_id() == EventTypeId::MouseEvent
}
}
impl MouseEvent {
fn new_inherited() -> MouseEvent {
MouseEvent {
uievent: UIEvent::new_inherited(MouseEventTypeId),
uievent: UIEvent::new_inherited(EventTypeId::MouseEvent),
screen_x: Cell::new(0),
screen_y: Cell::new(0),
client_x: Cell::new(0),

Some files were not shown because too many files have changed in this diff Show more