mirror of
https://github.com/servo/servo.git
synced 2025-08-03 20:50:07 +01:00
Auto merge of #6174 - frewsxcv:cleanup-long-lines, r=SimonSapin
Part of https://github.com/servo/servo/issues/6041 <!-- Reviewable:start --> [<img src="https://reviewable.io/review_button.png" height=40 alt="Review on Reviewable"/>](https://reviewable.io/reviews/servo/servo/6174) <!-- Reviewable:end -->
This commit is contained in:
commit
542519ebfd
141 changed files with 1161 additions and 497 deletions
|
@ -378,7 +378,8 @@ impl RootedCollectionSet {
|
|||
}
|
||||
}
|
||||
|
||||
let dom_collections = &self.set[CollectionType::DOMObjects as usize] as *const _ as *const HashSet<*const RootedVec<JS<Void>>>;
|
||||
let dom_collections =
|
||||
&self.set[CollectionType::DOMObjects as usize] as *const _ as *const HashSet<*const RootedVec<JS<Void>>>;
|
||||
for dom_collection in (*dom_collections).iter() {
|
||||
for reflector in (**dom_collection).iter() {
|
||||
trace_reflector(tracer, "", reflector.reflector());
|
||||
|
|
|
@ -66,7 +66,8 @@ impl Blob {
|
|||
}
|
||||
|
||||
// http://dev.w3.org/2006/webapi/FileAPI/#constructorBlob
|
||||
pub fn Constructor_(global: GlobalRef, blobParts: DOMString, blobPropertyBag: &BlobBinding::BlobPropertyBag) -> Fallible<Temporary<Blob>> {
|
||||
pub fn Constructor_(global: GlobalRef, blobParts: DOMString,
|
||||
blobPropertyBag: &BlobBinding::BlobPropertyBag) -> Fallible<Temporary<Blob>> {
|
||||
//TODO: accept other blobParts types - ArrayBuffer or ArrayBufferView or Blob
|
||||
let bytes: Option<Vec<u8>> = Some(blobParts.into_bytes());
|
||||
let typeString = if is_ascii_printable(&blobPropertyBag.type_) {
|
||||
|
|
|
@ -118,7 +118,8 @@ unsafe fn GetSubframeWindow(cx: *mut JSContext, proxy: *mut JSObject, id: jsid)
|
|||
}
|
||||
|
||||
#[allow(unsafe_code)]
|
||||
unsafe extern fn getOwnPropertyDescriptor(cx: *mut JSContext, proxy: *mut JSObject, id: jsid, set: bool, desc: *mut JSPropertyDescriptor) -> bool {
|
||||
unsafe extern fn getOwnPropertyDescriptor(cx: *mut JSContext, proxy: *mut JSObject, id: jsid,
|
||||
set: bool, desc: *mut JSPropertyDescriptor) -> bool {
|
||||
let window = GetSubframeWindow(cx, proxy, id);
|
||||
if let Some(window) = window {
|
||||
let window = window.root();
|
||||
|
@ -145,7 +146,8 @@ unsafe extern fn getOwnPropertyDescriptor(cx: *mut JSContext, proxy: *mut JSObje
|
|||
}
|
||||
|
||||
#[allow(unsafe_code)]
|
||||
unsafe extern fn defineProperty(cx: *mut JSContext, proxy: *mut JSObject, id: jsid, desc: *mut JSPropertyDescriptor) -> bool {
|
||||
unsafe extern fn defineProperty(cx: *mut JSContext, proxy: *mut JSObject, id: jsid,
|
||||
desc: *mut JSPropertyDescriptor) -> bool {
|
||||
if get_array_index_from_id(cx, id).is_some() {
|
||||
// Spec says to Reject whether this is a supported index or not,
|
||||
// since we have no indexed setter or indexed creator. That means
|
||||
|
@ -178,7 +180,8 @@ unsafe extern fn hasOwn(cx: *mut JSContext, proxy: *mut JSObject, id: jsid, bp:
|
|||
}
|
||||
|
||||
#[allow(unsafe_code)]
|
||||
unsafe extern fn get(cx: *mut JSContext, proxy: *mut JSObject, receiver: *mut JSObject, id: jsid, vp: *mut JSVal) -> bool {
|
||||
unsafe extern fn get(cx: *mut JSContext, proxy: *mut JSObject, receiver: *mut JSObject, id: jsid,
|
||||
vp: *mut JSVal) -> bool {
|
||||
let window = GetSubframeWindow(cx, proxy, id);
|
||||
if let Some(window) = window {
|
||||
let window = window.root();
|
||||
|
@ -191,7 +194,8 @@ unsafe extern fn get(cx: *mut JSContext, proxy: *mut JSObject, receiver: *mut JS
|
|||
}
|
||||
|
||||
#[allow(unsafe_code)]
|
||||
unsafe extern fn set(cx: *mut JSContext, proxy: *mut JSObject, _receiver: *mut JSObject, id: jsid, _strict: bool, vp: *mut JSVal) -> bool {
|
||||
unsafe extern fn set(cx: *mut JSContext, proxy: *mut JSObject, _receiver: *mut JSObject,
|
||||
id: jsid, _strict: bool, vp: *mut JSVal) -> bool {
|
||||
if get_array_index_from_id(cx, id).is_some() {
|
||||
// Reject (which means throw if and only if strict) the set.
|
||||
// FIXME: Throw
|
||||
|
@ -205,12 +209,14 @@ unsafe extern fn set(cx: *mut JSContext, proxy: *mut JSObject, _receiver: *mut J
|
|||
|
||||
static PROXY_HANDLER: ProxyTraps = ProxyTraps {
|
||||
getPropertyDescriptor: Some(get_property_descriptor
|
||||
as unsafe extern "C" fn(*mut JSContext, *mut JSObject, jsid, bool, *mut JSPropertyDescriptor) -> bool),
|
||||
as unsafe extern "C" fn(*mut JSContext, *mut JSObject, jsid, bool,
|
||||
*mut JSPropertyDescriptor) -> bool),
|
||||
getOwnPropertyDescriptor: Some(getOwnPropertyDescriptor
|
||||
as unsafe extern "C" fn(*mut JSContext, *mut JSObject,
|
||||
jsid, bool, *mut JSPropertyDescriptor)
|
||||
-> bool),
|
||||
defineProperty: Some(defineProperty as unsafe extern "C" fn(*mut JSContext, *mut JSObject, jsid, *mut JSPropertyDescriptor) -> bool),
|
||||
defineProperty: Some(defineProperty as unsafe extern "C" fn(*mut JSContext, *mut JSObject, jsid,
|
||||
*mut JSPropertyDescriptor) -> bool),
|
||||
getOwnPropertyNames: None,
|
||||
delete_: None,
|
||||
enumerate: None,
|
||||
|
@ -218,7 +224,8 @@ static PROXY_HANDLER: ProxyTraps = ProxyTraps {
|
|||
has: None,
|
||||
hasOwn: Some(hasOwn as unsafe extern "C" fn(*mut JSContext, *mut JSObject, jsid, *mut bool) -> bool),
|
||||
get: Some(get as unsafe extern "C" fn(*mut JSContext, *mut JSObject, *mut JSObject, jsid, *mut JSVal) -> bool),
|
||||
set: Some(set as unsafe extern "C" fn(*mut JSContext, *mut JSObject, *mut JSObject, jsid, bool, *mut JSVal) -> bool),
|
||||
set: Some(set as unsafe extern "C" fn(*mut JSContext, *mut JSObject, *mut JSObject,
|
||||
jsid, bool, *mut JSVal) -> bool),
|
||||
keys: None,
|
||||
iterate: None,
|
||||
|
||||
|
|
|
@ -221,7 +221,8 @@ impl CanvasRenderingContext2D {
|
|||
renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::GetImageData(source_rect, image_size, sender))).unwrap();
|
||||
let imagedata = receiver.recv().unwrap();
|
||||
// Writes pixels to destination canvas
|
||||
CanvasMsg::Canvas2d(Canvas2dMsg::DrawImage(imagedata, source_rect.size, dest_rect, source_rect, smoothing_enabled))
|
||||
CanvasMsg::Canvas2d(
|
||||
Canvas2dMsg::DrawImage(imagedata, source_rect.size, dest_rect, source_rect, smoothing_enabled))
|
||||
};
|
||||
|
||||
self.renderer.send(msg).unwrap();
|
||||
|
@ -820,7 +821,9 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D>
|
|||
}
|
||||
}
|
||||
StringOrCanvasGradientOrCanvasPattern::eCanvasGradient(gradient) => {
|
||||
self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::SetFillStyle(gradient.root().r().to_fill_or_stroke_style()))).unwrap();
|
||||
let msg = CanvasMsg::Canvas2d(
|
||||
Canvas2dMsg::SetFillStyle(gradient.root().r().to_fill_or_stroke_style()));
|
||||
self.renderer.send(msg).unwrap();
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
|
@ -845,7 +848,11 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D>
|
|||
}
|
||||
|
||||
// https://html.spec.whatwg.org/multipage/#dom-context-2d-getimagedata
|
||||
fn GetImageData(self, sx: Finite<f64>, sy: Finite<f64>, sw: Finite<f64>, sh: Finite<f64>) -> Fallible<Temporary<ImageData>> {
|
||||
fn GetImageData(self,
|
||||
sx: Finite<f64>,
|
||||
sy: Finite<f64>,
|
||||
sw: Finite<f64>,
|
||||
sh: Finite<f64>) -> Fallible<Temporary<ImageData>> {
|
||||
let sx = *sx;
|
||||
let sy = *sy;
|
||||
let sw = *sw;
|
||||
|
@ -871,7 +878,8 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D>
|
|||
|
||||
// XXX:
|
||||
// By the spec: http://www.w3.org/html/wg/drafts/2dcontext/html5_canvas_CR/#dom-context-2d-putimagedata
|
||||
// "If any of the arguments to the method are infinite or NaN, the method must throw a NotSupportedError exception"
|
||||
// "If any of the arguments to the method are infinite or NaN, the method must throw a NotSupportedError
|
||||
// exception"
|
||||
// But this arguments are stricted value, so if they are not finite values,
|
||||
// they will be TypeError by WebIDL spec before call this methods.
|
||||
|
||||
|
@ -880,7 +888,8 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D>
|
|||
let image_data_size = Size2D(image_data_size.width as f64, image_data_size.height as f64);
|
||||
let image_data_rect = Rect(Point2D(dx, dy), image_data_size);
|
||||
let dirty_rect = None;
|
||||
self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::PutImageData(data, image_data_rect, dirty_rect))).unwrap();
|
||||
let msg = CanvasMsg::Canvas2d(Canvas2dMsg::PutImageData(data, image_data_rect, dirty_rect));
|
||||
self.renderer.send(msg).unwrap();
|
||||
self.mark_as_dirty();
|
||||
}
|
||||
|
||||
|
@ -896,7 +905,8 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D>
|
|||
|
||||
// XXX:
|
||||
// By the spec: http://www.w3.org/html/wg/drafts/2dcontext/html5_canvas_CR/#dom-context-2d-putimagedata
|
||||
// "If any of the arguments to the method are infinite or NaN, the method must throw a NotSupportedError exception"
|
||||
// "If any of the arguments to the method are infinite or NaN, the method must throw a NotSupportedError
|
||||
// exception"
|
||||
// But this arguments are stricted value, so if they are not finite values,
|
||||
// they will be TypeError by WebIDL spec before call this methods.
|
||||
|
||||
|
@ -906,7 +916,8 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D>
|
|||
imagedata.Height() as f64));
|
||||
let dirty_rect = Some(Rect(Point2D(dirtyX, dirtyY),
|
||||
Size2D(dirtyWidth, dirtyHeight)));
|
||||
self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::PutImageData(data, image_data_rect, dirty_rect))).unwrap();
|
||||
let msg = CanvasMsg::Canvas2d(Canvas2dMsg::PutImageData(data, image_data_rect, dirty_rect));
|
||||
self.renderer.send(msg).unwrap();
|
||||
self.mark_as_dirty();
|
||||
}
|
||||
|
||||
|
@ -919,7 +930,8 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D>
|
|||
let y1 = *y1;
|
||||
|
||||
if [x0, y0, x1, y1].iter().any(|x| x.is_nan() || x.is_infinite()) {
|
||||
return Err(Type("One of the arguments of createLinearGradient() is not a finite floating-point value.".to_owned()));
|
||||
return Err(Type("One of the arguments of createLinearGradient() is not a finite \
|
||||
floating-point value.".to_owned()));
|
||||
}
|
||||
Ok(CanvasGradient::new(self.global.root().r(),
|
||||
CanvasGradientStyle::Linear(LinearGradientStyle::new(x0, y0, x1, y1, Vec::new()))))
|
||||
|
@ -927,7 +939,8 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D>
|
|||
|
||||
// https://html.spec.whatwg.org/multipage/#dom-context-2d-createradialgradient
|
||||
fn CreateRadialGradient(self, x0: Finite<f64>, y0: Finite<f64>, r0: Finite<f64>,
|
||||
x1: Finite<f64>, y1: Finite<f64>, r1: Finite<f64>) -> Fallible<Temporary<CanvasGradient>> {
|
||||
x1: Finite<f64>, y1: Finite<f64>, r1: Finite<f64>)
|
||||
-> Fallible<Temporary<CanvasGradient>> {
|
||||
let x0 = *x0;
|
||||
let y0 = *y0;
|
||||
let r0 = *r0;
|
||||
|
@ -936,10 +949,12 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D>
|
|||
let r1 = *r1;
|
||||
|
||||
if [x0, y0, r0, x1, y1, r1].iter().any(|x| x.is_nan() || x.is_infinite()) {
|
||||
return Err(Type("One of the arguments of createRadialGradient() is not a finite floating-point value.".to_owned()));
|
||||
return Err(Type("One of the arguments of createRadialGradient() is not a \
|
||||
finite floating-point value.".to_owned()));
|
||||
}
|
||||
Ok(CanvasGradient::new(self.global.root().r(),
|
||||
CanvasGradientStyle::Radial(RadialGradientStyle::new(x0, y0, r0, x1, y1, r1, Vec::new()))))
|
||||
CanvasGradientStyle::Radial(
|
||||
RadialGradientStyle::new(x0, y0, r0, x1, y1, r1, Vec::new()))))
|
||||
}
|
||||
|
||||
// https://html.spec.whatwg.org/multipage/#dom-context-2d-linewidth
|
||||
|
|
|
@ -56,7 +56,11 @@ impl CloseEvent {
|
|||
init: &CloseEventBinding::CloseEventInit)
|
||||
-> Fallible<Temporary<CloseEvent>> {
|
||||
let bubbles = if init.parent.bubbles { EventBubbles::Bubbles } else { EventBubbles::DoesNotBubble };
|
||||
let cancelable = if init.parent.cancelable { EventCancelable::Cancelable } else { EventCancelable::NotCancelable };
|
||||
let cancelable = if init.parent.cancelable {
|
||||
EventCancelable::Cancelable
|
||||
} else {
|
||||
EventCancelable::NotCancelable
|
||||
};
|
||||
Ok(CloseEvent::new(global, type_, bubbles, cancelable, init.wasClean,
|
||||
init.code, init.reason.clone()))
|
||||
}
|
||||
|
|
|
@ -41,7 +41,11 @@ impl CustomEvent {
|
|||
global,
|
||||
CustomEventBinding::Wrap)
|
||||
}
|
||||
pub fn new(global: GlobalRef, type_: DOMString, bubbles: bool, cancelable: bool, detail: JSVal) -> Temporary<CustomEvent> {
|
||||
pub fn new(global: GlobalRef,
|
||||
type_: DOMString,
|
||||
bubbles: bool,
|
||||
cancelable: bool,
|
||||
detail: JSVal) -> Temporary<CustomEvent> {
|
||||
let ev = CustomEvent::new_uninitialized(global).root();
|
||||
ev.r().InitCustomEvent(global.get_cx(), type_, bubbles, cancelable, detail);
|
||||
Temporary::from_rooted(ev.r())
|
||||
|
|
|
@ -381,7 +381,8 @@ impl<'a> DocumentHelpers<'a> for JSRef<'a, Document> {
|
|||
|
||||
let mut idmap = self.idmap.borrow_mut();
|
||||
|
||||
let root = self.GetDocumentElement().expect("The element is in the document, so there must be a document element.").root();
|
||||
let root = self.GetDocumentElement().expect(
|
||||
"The element is in the document, so there must be a document element.").root();
|
||||
|
||||
match idmap.entry(id) {
|
||||
Vacant(entry) => {
|
||||
|
@ -764,7 +765,8 @@ impl<'a> DocumentHelpers<'a> for JSRef<'a, Document> {
|
|||
match key {
|
||||
Key::Space if !prevented && state == KeyState::Released => {
|
||||
let maybe_elem: Option<JSRef<Element>> = ElementCast::to_ref(target);
|
||||
maybe_elem.map(|el| el.as_maybe_activatable().map(|a| a.synthetic_click_activation(ctrl, alt, shift, meta)));
|
||||
maybe_elem.map(
|
||||
|el| el.as_maybe_activatable().map(|a| a.synthetic_click_activation(ctrl, alt, shift, meta)));
|
||||
}
|
||||
Key::Enter if !prevented && state == KeyState::Released => {
|
||||
let maybe_elem: Option<JSRef<Element>> = ElementCast::to_ref(target);
|
||||
|
@ -1077,7 +1079,8 @@ impl<'a> PrivateClickEventHelpers for JSRef<'a, Node> {
|
|||
// NodeTypeId::Element(ElementTypeId::HTMLKeygenElement) |
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLOptionElement)) |
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLSelectElement)) |
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTextAreaElement)) if self.get_disabled_state() => true,
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTextAreaElement))
|
||||
if self.get_disabled_state() => true,
|
||||
_ => false
|
||||
}
|
||||
}
|
||||
|
|
|
@ -96,7 +96,8 @@ impl<'a> DOMExceptionMethods for JSRef<'a, DOMException> {
|
|||
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::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."
|
||||
};
|
||||
|
|
|
@ -129,12 +129,14 @@ impl<'a> DOMImplementationMethods for JSRef<'a, DOMImplementation> {
|
|||
|
||||
{
|
||||
// Step 4.
|
||||
let doc_html: Root<Node> = NodeCast::from_temporary(HTMLHtmlElement::new("html".to_owned(), None, doc.r())).root();
|
||||
let doc_html: Root<Node> = NodeCast::from_temporary(
|
||||
HTMLHtmlElement::new("html".to_owned(), None, doc.r())).root();
|
||||
assert!(doc_node.AppendChild(doc_html.r()).is_ok());
|
||||
|
||||
{
|
||||
// Step 5.
|
||||
let doc_head: Root<Node> = NodeCast::from_temporary(HTMLHeadElement::new("head".to_owned(), None, doc.r())).root();
|
||||
let doc_head: Root<Node> = NodeCast::from_temporary(
|
||||
HTMLHeadElement::new("head".to_owned(), None, doc.r())).root();
|
||||
assert!(doc_html.r().AppendChild(doc_head.r()).is_ok());
|
||||
|
||||
// Step 6.
|
||||
|
@ -142,7 +144,8 @@ impl<'a> DOMImplementationMethods for JSRef<'a, DOMImplementation> {
|
|||
None => (),
|
||||
Some(title_str) => {
|
||||
// Step 6.1.
|
||||
let doc_title: Root<Node> = NodeCast::from_temporary(HTMLTitleElement::new("title".to_owned(), None, doc.r())).root();
|
||||
let doc_title: Root<Node> = NodeCast::from_temporary(
|
||||
HTMLTitleElement::new("title".to_owned(), None, doc.r())).root();
|
||||
assert!(doc_head.r().AppendChild(doc_title.r()).is_ok());
|
||||
|
||||
// Step 6.2.
|
||||
|
|
|
@ -151,9 +151,14 @@ 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::Element, local_name, namespace, prefix, document),
|
||||
document, ElementBinding::Wrap)
|
||||
pub fn new(local_name: DOMString,
|
||||
namespace: Namespace,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<Element> {
|
||||
Node::reflect_node(
|
||||
box Element::new_inherited(ElementTypeId::Element, local_name, namespace, prefix, document),
|
||||
document,
|
||||
ElementBinding::Wrap)
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -846,7 +851,10 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
|
|||
fn get_attribute(self, namespace: &Namespace, local_name: &Atom) -> Option<Temporary<Attr>> {
|
||||
let mut attributes = RootedVec::new();
|
||||
self.get_attributes(local_name, &mut attributes);
|
||||
attributes.iter().map(|attr| attr.root()).find(|attr| attr.r().namespace() == namespace).map(|x| Temporary::from_rooted(x.r()))
|
||||
attributes.iter()
|
||||
.map(|attr| attr.root())
|
||||
.find(|attr| attr.r().namespace() == namespace)
|
||||
.map(|x| Temporary::from_rooted(x.r()))
|
||||
}
|
||||
|
||||
// https://dom.spec.whatwg.org/#concept-element-attributes-get-by-name
|
||||
|
|
|
@ -97,7 +97,11 @@ impl ErrorEvent {
|
|||
|
||||
let bubbles = if init.parent.bubbles { EventBubbles::Bubbles } else { EventBubbles::DoesNotBubble };
|
||||
|
||||
let cancelable = if init.parent.cancelable { EventCancelable::Cancelable } else { EventCancelable::NotCancelable };
|
||||
let cancelable = if init.parent.cancelable {
|
||||
EventCancelable::Cancelable
|
||||
} else {
|
||||
EventCancelable::NotCancelable
|
||||
};
|
||||
|
||||
let event = ErrorEvent::new(global, type_,
|
||||
bubbles, cancelable,
|
||||
|
|
|
@ -38,20 +38,27 @@ pub struct HTMLAnchorElement {
|
|||
|
||||
impl HTMLAnchorElementDerived for EventTarget {
|
||||
fn is_htmlanchorelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLAnchorElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLAnchorElement)))
|
||||
}
|
||||
}
|
||||
|
||||
impl HTMLAnchorElement {
|
||||
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLAnchorElement {
|
||||
fn new_inherited(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> HTMLAnchorElement {
|
||||
HTMLAnchorElement {
|
||||
htmlelement: HTMLElement::new_inherited(HTMLElementTypeId::HTMLAnchorElement, localName, prefix, document),
|
||||
htmlelement:
|
||||
HTMLElement::new_inherited(HTMLElementTypeId::HTMLAnchorElement, localName, prefix, document),
|
||||
rel_list: Default::default(),
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLAnchorElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLAnchorElement> {
|
||||
let element = HTMLAnchorElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLAnchorElementBinding::Wrap)
|
||||
}
|
||||
|
@ -133,7 +140,8 @@ impl<'a> Activatable for JSRef<'a, HTMLAnchorElement> {
|
|||
if target.is_htmlimageelement() && element.has_attribute(&atom!("ismap")) {
|
||||
|
||||
let target_node = NodeCast::to_ref(target).unwrap();
|
||||
let rect = window_from_node(target_node).root().r().content_box_query(target_node.to_trusted_node_address());
|
||||
let rect = window_from_node(target_node).root().r().content_box_query(
|
||||
target_node.to_trusted_node_address());
|
||||
ismap_suffix = Some(
|
||||
format!("?{},{}", mouse_event.ClientX().to_f32().unwrap() - rect.origin.x.to_f32_px(),
|
||||
mouse_event.ClientY().to_f32().unwrap() - rect.origin.y.to_f32_px())
|
||||
|
|
|
@ -26,19 +26,26 @@ pub struct HTMLAppletElement {
|
|||
|
||||
impl HTMLAppletElementDerived for EventTarget {
|
||||
fn is_htmlappletelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLAppletElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLAppletElement)))
|
||||
}
|
||||
}
|
||||
|
||||
impl HTMLAppletElement {
|
||||
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLAppletElement {
|
||||
fn new_inherited(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> HTMLAppletElement {
|
||||
HTMLAppletElement {
|
||||
htmlelement: HTMLElement::new_inherited(HTMLElementTypeId::HTMLAppletElement, localName, prefix, document)
|
||||
htmlelement:
|
||||
HTMLElement::new_inherited(HTMLElementTypeId::HTMLAppletElement, localName, prefix, document)
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLAppletElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLAppletElement> {
|
||||
let element = HTMLAppletElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLAppletElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -29,7 +29,9 @@ pub struct HTMLAreaElement {
|
|||
|
||||
impl HTMLAreaElementDerived for EventTarget {
|
||||
fn is_htmlareaelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLAreaElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLAreaElement)))
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -42,7 +44,9 @@ impl HTMLAreaElement {
|
|||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLAreaElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLAreaElement> {
|
||||
let element = HTMLAreaElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLAreaElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -28,14 +28,19 @@ impl HTMLAudioElementDerived for EventTarget {
|
|||
}
|
||||
|
||||
impl HTMLAudioElement {
|
||||
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLAudioElement {
|
||||
fn new_inherited(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> HTMLAudioElement {
|
||||
HTMLAudioElement {
|
||||
htmlmediaelement: HTMLMediaElement::new_inherited(HTMLMediaElementTypeId::HTMLAudioElement, localName, prefix, document)
|
||||
htmlmediaelement:
|
||||
HTMLMediaElement::new_inherited(HTMLMediaElementTypeId::HTMLAudioElement, localName, prefix, document)
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLAudioElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLAudioElement> {
|
||||
let element = HTMLAudioElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLAudioElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -19,7 +19,9 @@ pub struct HTMLBaseElement {
|
|||
|
||||
impl HTMLBaseElementDerived for EventTarget {
|
||||
fn is_htmlbaseelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLBaseElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLBaseElement)))
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -31,7 +33,9 @@ impl HTMLBaseElement {
|
|||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLBaseElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLBaseElement> {
|
||||
let element = HTMLBaseElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLBaseElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -32,7 +32,9 @@ pub struct HTMLBodyElement {
|
|||
|
||||
impl HTMLBodyElementDerived for EventTarget {
|
||||
fn is_htmlbodyelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLBodyElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLBodyElement)))
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -19,7 +19,9 @@ pub struct HTMLBRElement {
|
|||
|
||||
impl HTMLBRElementDerived for EventTarget {
|
||||
fn is_htmlbrelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLBRElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLBRElement)))
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -31,7 +33,9 @@ impl HTMLBRElement {
|
|||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLBRElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLBRElement> {
|
||||
let element = HTMLBRElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLBRElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -45,21 +45,28 @@ pub struct HTMLButtonElement {
|
|||
|
||||
impl HTMLButtonElementDerived for EventTarget {
|
||||
fn is_htmlbuttonelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLButtonElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLButtonElement)))
|
||||
}
|
||||
}
|
||||
|
||||
impl HTMLButtonElement {
|
||||
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLButtonElement {
|
||||
fn new_inherited(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> HTMLButtonElement {
|
||||
HTMLButtonElement {
|
||||
htmlelement: HTMLElement::new_inherited(HTMLElementTypeId::HTMLButtonElement, localName, prefix, document),
|
||||
htmlelement:
|
||||
HTMLElement::new_inherited(HTMLElementTypeId::HTMLButtonElement, localName, prefix, document),
|
||||
//TODO: implement button_type in after_set_attr
|
||||
button_type: Cell::new(ButtonType::ButtonSubmit)
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLButtonElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLButtonElement> {
|
||||
let element = HTMLButtonElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLButtonElementBinding::Wrap)
|
||||
}
|
||||
|
@ -96,7 +103,8 @@ impl<'a> HTMLButtonElementMethods for JSRef<'a, HTMLButtonElement> {
|
|||
|
||||
make_setter!(SetFormAction, "formaction");
|
||||
|
||||
make_enumerated_getter!(FormEnctype, "application/x-www-form-urlencoded", ("text/plain") | ("multipart/form-data"));
|
||||
make_enumerated_getter!(
|
||||
FormEnctype, "application/x-www-form-urlencoded", ("text/plain") | ("multipart/form-data"));
|
||||
|
||||
make_setter!(SetFormEnctype, "formenctype");
|
||||
|
||||
|
|
|
@ -47,14 +47,19 @@ pub struct HTMLCanvasElement {
|
|||
|
||||
impl HTMLCanvasElementDerived for EventTarget {
|
||||
fn is_htmlcanvaselement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLCanvasElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLCanvasElement)))
|
||||
}
|
||||
}
|
||||
|
||||
impl HTMLCanvasElement {
|
||||
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLCanvasElement {
|
||||
fn new_inherited(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> HTMLCanvasElement {
|
||||
HTMLCanvasElement {
|
||||
htmlelement: HTMLElement::new_inherited(HTMLElementTypeId::HTMLCanvasElement, localName, prefix, document),
|
||||
htmlelement:
|
||||
HTMLElement::new_inherited(HTMLElementTypeId::HTMLCanvasElement, localName, prefix, document),
|
||||
context_2d: Default::default(),
|
||||
context_webgl: Default::default(),
|
||||
width: Cell::new(DEFAULT_WIDTH),
|
||||
|
@ -63,7 +68,9 @@ impl HTMLCanvasElement {
|
|||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLCanvasElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLCanvasElement> {
|
||||
let element = HTMLCanvasElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLCanvasElementBinding::Wrap)
|
||||
}
|
||||
|
@ -182,7 +189,9 @@ impl<'a> HTMLCanvasElementMethods for JSRef<'a, HTMLCanvasElement> {
|
|||
let size = self.get_size();
|
||||
CanvasRenderingContext2D::new(GlobalRef::Window(window.r()), self, size)
|
||||
});
|
||||
Some(CanvasRenderingContext2DOrWebGLRenderingContext::eCanvasRenderingContext2D(Unrooted::from_temporary(context_2d)))
|
||||
Some(
|
||||
CanvasRenderingContext2DOrWebGLRenderingContext::eCanvasRenderingContext2D(
|
||||
Unrooted::from_temporary(context_2d)))
|
||||
}
|
||||
"webgl" | "experimental-webgl" => {
|
||||
if self.context_2d.get().is_some() {
|
||||
|
|
|
@ -19,19 +19,25 @@ pub struct HTMLDataElement {
|
|||
|
||||
impl HTMLDataElementDerived for EventTarget {
|
||||
fn is_htmldataelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLDataElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLDataElement)))
|
||||
}
|
||||
}
|
||||
|
||||
impl HTMLDataElement {
|
||||
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLDataElement {
|
||||
fn new_inherited(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> HTMLDataElement {
|
||||
HTMLDataElement {
|
||||
htmlelement: HTMLElement::new_inherited(HTMLElementTypeId::HTMLDataElement, localName, prefix, document)
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLDataElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLDataElement> {
|
||||
let element = HTMLDataElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLDataElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -23,19 +23,26 @@ pub struct HTMLDataListElement {
|
|||
|
||||
impl HTMLDataListElementDerived for EventTarget {
|
||||
fn is_htmldatalistelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLDataListElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLDataListElement)))
|
||||
}
|
||||
}
|
||||
|
||||
impl HTMLDataListElement {
|
||||
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLDataListElement {
|
||||
fn new_inherited(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> HTMLDataListElement {
|
||||
HTMLDataListElement {
|
||||
htmlelement: HTMLElement::new_inherited(HTMLElementTypeId::HTMLDataListElement, localName, prefix, document)
|
||||
htmlelement:
|
||||
HTMLElement::new_inherited(HTMLElementTypeId::HTMLDataListElement, localName, prefix, document)
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLDataListElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLDataListElement> {
|
||||
let element = HTMLDataListElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLDataListElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -25,20 +25,27 @@ pub struct HTMLDialogElement {
|
|||
|
||||
impl HTMLDialogElementDerived for EventTarget {
|
||||
fn is_htmldialogelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLDialogElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLDialogElement)))
|
||||
}
|
||||
}
|
||||
|
||||
impl HTMLDialogElement {
|
||||
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLDialogElement {
|
||||
fn new_inherited(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> HTMLDialogElement {
|
||||
HTMLDialogElement {
|
||||
htmlelement: HTMLElement::new_inherited(HTMLElementTypeId::HTMLDialogElement, localName, prefix, document),
|
||||
htmlelement:
|
||||
HTMLElement::new_inherited(HTMLElementTypeId::HTMLDialogElement, localName, prefix, document),
|
||||
return_value: DOMRefCell::new("".to_owned()),
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLDialogElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLDialogElement> {
|
||||
let element = HTMLDialogElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLDialogElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -19,19 +19,26 @@ pub struct HTMLDirectoryElement {
|
|||
|
||||
impl HTMLDirectoryElementDerived for EventTarget {
|
||||
fn is_htmldirectoryelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLDirectoryElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLDirectoryElement)))
|
||||
}
|
||||
}
|
||||
|
||||
impl HTMLDirectoryElement {
|
||||
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLDirectoryElement {
|
||||
fn new_inherited(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> HTMLDirectoryElement {
|
||||
HTMLDirectoryElement {
|
||||
htmlelement: HTMLElement::new_inherited(HTMLElementTypeId::HTMLDirectoryElement, localName, prefix, document)
|
||||
htmlelement:
|
||||
HTMLElement::new_inherited(HTMLElementTypeId::HTMLDirectoryElement, localName, prefix, document)
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLDirectoryElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLDirectoryElement> {
|
||||
let element = HTMLDirectoryElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLDirectoryElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -19,19 +19,25 @@ pub struct HTMLDivElement {
|
|||
|
||||
impl HTMLDivElementDerived for EventTarget {
|
||||
fn is_htmldivelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLDivElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLDivElement)))
|
||||
}
|
||||
}
|
||||
|
||||
impl HTMLDivElement {
|
||||
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLDivElement {
|
||||
fn new_inherited(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> HTMLDivElement {
|
||||
HTMLDivElement {
|
||||
htmlelement: HTMLElement::new_inherited(HTMLElementTypeId::HTMLDivElement, localName, prefix, document)
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLDivElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLDivElement> {
|
||||
let element = HTMLDivElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLDivElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -19,19 +19,24 @@ pub struct HTMLDListElement {
|
|||
|
||||
impl HTMLDListElementDerived for EventTarget {
|
||||
fn is_htmldlistelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLDListElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLDListElement)))
|
||||
}
|
||||
}
|
||||
|
||||
impl HTMLDListElement {
|
||||
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLDListElement {
|
||||
HTMLDListElement {
|
||||
htmlelement: HTMLElement::new_inherited(HTMLElementTypeId::HTMLDListElement, localName, prefix, document)
|
||||
htmlelement:
|
||||
HTMLElement::new_inherited(HTMLElementTypeId::HTMLDListElement, localName, prefix, document)
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLDListElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLDListElement> {
|
||||
let element = HTMLDListElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLDListElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -54,9 +54,13 @@ impl HTMLElementDerived for EventTarget {
|
|||
}
|
||||
|
||||
impl HTMLElement {
|
||||
pub fn new_inherited(type_id: HTMLElementTypeId, tag_name: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLElement {
|
||||
pub fn new_inherited(type_id: HTMLElementTypeId,
|
||||
tag_name: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> HTMLElement {
|
||||
HTMLElement {
|
||||
element: Element::new_inherited(ElementTypeId::HTMLElement(type_id), tag_name, ns!(HTML), prefix, document),
|
||||
element:
|
||||
Element::new_inherited(ElementTypeId::HTMLElement(type_id), tag_name, ns!(HTML), prefix, document),
|
||||
style_decl: Default::default(),
|
||||
dataset: Default::default(),
|
||||
}
|
||||
|
|
|
@ -19,7 +19,9 @@ pub struct HTMLEmbedElement {
|
|||
|
||||
impl HTMLEmbedElementDerived for EventTarget {
|
||||
fn is_htmlembedelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLEmbedElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLEmbedElement)))
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -31,7 +33,9 @@ impl HTMLEmbedElement {
|
|||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLEmbedElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLEmbedElement> {
|
||||
let element = HTMLEmbedElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLEmbedElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -28,19 +28,26 @@ pub struct HTMLFieldSetElement {
|
|||
|
||||
impl HTMLFieldSetElementDerived for EventTarget {
|
||||
fn is_htmlfieldsetelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLFieldSetElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLFieldSetElement)))
|
||||
}
|
||||
}
|
||||
|
||||
impl HTMLFieldSetElement {
|
||||
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLFieldSetElement {
|
||||
fn new_inherited(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> HTMLFieldSetElement {
|
||||
HTMLFieldSetElement {
|
||||
htmlelement: HTMLElement::new_inherited(HTMLElementTypeId::HTMLFieldSetElement, localName, prefix, document)
|
||||
htmlelement:
|
||||
HTMLElement::new_inherited(HTMLElementTypeId::HTMLFieldSetElement, localName, prefix, document)
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLFieldSetElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLFieldSetElement> {
|
||||
let element = HTMLFieldSetElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLFieldSetElementBinding::Wrap)
|
||||
}
|
||||
|
@ -105,10 +112,14 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLFieldSetElement> {
|
|||
for descendant in child.r().traverse_preorder() {
|
||||
let descendant = descendant.root();
|
||||
match descendant.r().type_id() {
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLButtonElement)) |
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLInputElement)) |
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLSelectElement)) |
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTextAreaElement)) => {
|
||||
NodeTypeId::Element(
|
||||
ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLButtonElement)) |
|
||||
NodeTypeId::Element(
|
||||
ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLInputElement)) |
|
||||
NodeTypeId::Element(
|
||||
ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLSelectElement)) |
|
||||
NodeTypeId::Element(
|
||||
ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTextAreaElement)) => {
|
||||
descendant.r().set_disabled_state(true);
|
||||
descendant.r().set_enabled_state(false);
|
||||
},
|
||||
|
@ -144,10 +155,14 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLFieldSetElement> {
|
|||
for descendant in child.r().traverse_preorder() {
|
||||
let descendant = descendant.root();
|
||||
match descendant.r().type_id() {
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLButtonElement)) |
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLInputElement)) |
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLSelectElement)) |
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTextAreaElement)) => {
|
||||
NodeTypeId::Element(
|
||||
ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLButtonElement)) |
|
||||
NodeTypeId::Element(
|
||||
ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLInputElement)) |
|
||||
NodeTypeId::Element(
|
||||
ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLSelectElement)) |
|
||||
NodeTypeId::Element(
|
||||
ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTextAreaElement)) => {
|
||||
descendant.r().check_disabled_attribute();
|
||||
descendant.r().check_ancestors_disabled_state_for_form_control();
|
||||
},
|
||||
|
|
|
@ -26,7 +26,9 @@ pub struct HTMLFontElement {
|
|||
|
||||
impl HTMLFontElementDerived for EventTarget {
|
||||
fn is_htmlfontelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLFontElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLFontElement)))
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -39,7 +41,9 @@ impl HTMLFontElement {
|
|||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLFontElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLFontElement> {
|
||||
let element = HTMLFontElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLFontElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -51,12 +51,16 @@ pub struct HTMLFormElement {
|
|||
|
||||
impl HTMLFormElementDerived for EventTarget {
|
||||
fn is_htmlformelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLFormElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLFormElement)))
|
||||
}
|
||||
}
|
||||
|
||||
impl HTMLFormElement {
|
||||
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLFormElement {
|
||||
fn new_inherited(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> HTMLFormElement {
|
||||
HTMLFormElement {
|
||||
htmlelement: HTMLElement::new_inherited(HTMLElementTypeId::HTMLFormElement, localName, prefix, document),
|
||||
marked_for_reset: Cell::new(false),
|
||||
|
@ -64,7 +68,9 @@ impl HTMLFormElement {
|
|||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLFormElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLFormElement> {
|
||||
let element = HTMLFormElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLFormElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -19,7 +19,9 @@ pub struct HTMLFrameElement {
|
|||
|
||||
impl HTMLFrameElementDerived for EventTarget {
|
||||
fn is_htmlframeelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLFrameElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLFrameElement)))
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -31,7 +33,9 @@ impl HTMLFrameElement {
|
|||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLFrameElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLFrameElement> {
|
||||
let element = HTMLFrameElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLFrameElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -19,19 +19,26 @@ pub struct HTMLFrameSetElement {
|
|||
|
||||
impl HTMLFrameSetElementDerived for EventTarget {
|
||||
fn is_htmlframesetelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLFrameSetElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLFrameSetElement)))
|
||||
}
|
||||
}
|
||||
|
||||
impl HTMLFrameSetElement {
|
||||
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLFrameSetElement {
|
||||
fn new_inherited(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> HTMLFrameSetElement {
|
||||
HTMLFrameSetElement {
|
||||
htmlelement: HTMLElement::new_inherited(HTMLElementTypeId::HTMLFrameSetElement, localName, prefix, document)
|
||||
htmlelement:
|
||||
HTMLElement::new_inherited(HTMLElementTypeId::HTMLFrameSetElement, localName, prefix, document)
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLFrameSetElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLFrameSetElement> {
|
||||
let element = HTMLFrameSetElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLFrameSetElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -21,19 +21,25 @@ pub struct HTMLHeadElement {
|
|||
|
||||
impl HTMLHeadElementDerived for EventTarget {
|
||||
fn is_htmlheadelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLHeadElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLHeadElement)))
|
||||
}
|
||||
}
|
||||
|
||||
impl HTMLHeadElement {
|
||||
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLHeadElement {
|
||||
fn new_inherited(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> HTMLHeadElement {
|
||||
HTMLHeadElement {
|
||||
htmlelement: HTMLElement::new_inherited(HTMLElementTypeId::HTMLHeadElement, localName, prefix, document)
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLHeadElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLHeadElement> {
|
||||
let element = HTMLHeadElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLHeadElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -30,20 +30,29 @@ pub struct HTMLHeadingElement {
|
|||
|
||||
impl HTMLHeadingElementDerived for EventTarget {
|
||||
fn is_htmlheadingelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLHeadingElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLHeadingElement)))
|
||||
}
|
||||
}
|
||||
|
||||
impl HTMLHeadingElement {
|
||||
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>, level: HeadingLevel) -> HTMLHeadingElement {
|
||||
fn new_inherited(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>,
|
||||
level: HeadingLevel) -> HTMLHeadingElement {
|
||||
HTMLHeadingElement {
|
||||
htmlelement: HTMLElement::new_inherited(HTMLElementTypeId::HTMLHeadingElement, localName, prefix, document),
|
||||
htmlelement:
|
||||
HTMLElement::new_inherited(HTMLElementTypeId::HTMLHeadingElement, localName, prefix, document),
|
||||
level: level,
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>, level: HeadingLevel) -> Temporary<HTMLHeadingElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>,
|
||||
level: HeadingLevel) -> Temporary<HTMLHeadingElement> {
|
||||
let element = HTMLHeadingElement::new_inherited(localName, prefix, document, level);
|
||||
Node::reflect_node(box element, document, HTMLHeadingElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -19,7 +19,9 @@ pub struct HTMLHRElement {
|
|||
|
||||
impl HTMLHRElementDerived for EventTarget {
|
||||
fn is_htmlhrelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLHRElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLHRElement)))
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -31,7 +33,9 @@ impl HTMLHRElement {
|
|||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLHRElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLHRElement> {
|
||||
let element = HTMLHRElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLHRElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -19,7 +19,9 @@ pub struct HTMLHtmlElement {
|
|||
|
||||
impl HTMLHtmlElementDerived for EventTarget {
|
||||
fn is_htmlhtmlelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLHtmlElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLHtmlElement)))
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -31,7 +33,9 @@ impl HTMLHtmlElement {
|
|||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLHtmlElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLHtmlElement> {
|
||||
let element = HTMLHtmlElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLHtmlElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -7,7 +7,8 @@ use dom::bindings::codegen::Bindings::HTMLIFrameElementBinding;
|
|||
use dom::bindings::codegen::Bindings::HTMLIFrameElementBinding::HTMLIFrameElementMethods;
|
||||
use dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
|
||||
use dom::bindings::codegen::InheritTypes::{NodeCast, ElementCast, EventCast};
|
||||
use dom::bindings::codegen::InheritTypes::{EventTargetCast, HTMLElementCast, HTMLIFrameElementDerived};
|
||||
use dom::bindings::codegen::InheritTypes::{EventTargetCast, HTMLElementCast,
|
||||
HTMLIFrameElementDerived};
|
||||
use dom::bindings::conversions::ToJSValConvertible;
|
||||
use dom::bindings::error::{ErrorResult, Fallible};
|
||||
use dom::bindings::error::Error::NotSupported;
|
||||
|
@ -59,7 +60,9 @@ pub struct HTMLIFrameElement {
|
|||
|
||||
impl HTMLIFrameElementDerived for EventTarget {
|
||||
fn is_htmliframeelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLIFrameElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLIFrameElement)))
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -191,9 +194,12 @@ impl RawHTMLIFrameElementHelpers for HTMLIFrameElement {
|
|||
}
|
||||
|
||||
impl HTMLIFrameElement {
|
||||
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLIFrameElement {
|
||||
fn new_inherited(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> HTMLIFrameElement {
|
||||
HTMLIFrameElement {
|
||||
htmlelement: HTMLElement::new_inherited(HTMLElementTypeId::HTMLIFrameElement, localName, prefix, document),
|
||||
htmlelement:
|
||||
HTMLElement::new_inherited(HTMLElementTypeId::HTMLIFrameElement, localName, prefix, document),
|
||||
subpage_id: Cell::new(None),
|
||||
containing_page_pipeline_id: Cell::new(None),
|
||||
sandbox: Cell::new(None),
|
||||
|
@ -201,7 +207,9 @@ impl HTMLIFrameElement {
|
|||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLIFrameElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLIFrameElement> {
|
||||
let element = HTMLIFrameElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLIFrameElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -7,7 +7,8 @@ use dom::attr::{AttrHelpers, AttrValue};
|
|||
use dom::bindings::cell::DOMRefCell;
|
||||
use dom::bindings::codegen::Bindings::HTMLImageElementBinding;
|
||||
use dom::bindings::codegen::Bindings::HTMLImageElementBinding::HTMLImageElementMethods;
|
||||
use dom::bindings::codegen::InheritTypes::{NodeCast, ElementCast, EventTargetCast, HTMLElementCast, HTMLImageElementDerived};
|
||||
use dom::bindings::codegen::InheritTypes::{NodeCast, ElementCast, EventTargetCast, HTMLElementCast,
|
||||
HTMLImageElementDerived};
|
||||
use dom::bindings::global::GlobalRef;
|
||||
use dom::bindings::js::{JSRef, LayoutJS, Rootable, Temporary};
|
||||
use dom::bindings::refcounted::Trusted;
|
||||
|
@ -40,7 +41,9 @@ pub struct HTMLImageElement {
|
|||
|
||||
impl HTMLImageElementDerived for EventTarget {
|
||||
fn is_htmlimageelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLImageElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLImageElement)))
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -143,7 +146,9 @@ impl HTMLImageElement {
|
|||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLImageElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLImageElement> {
|
||||
let element = HTMLImageElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLImageElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -105,7 +105,9 @@ impl InputActivationState {
|
|||
|
||||
impl HTMLInputElementDerived for EventTarget {
|
||||
fn is_htmlinputelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLInputElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLInputElement)))
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -129,7 +131,9 @@ impl HTMLInputElement {
|
|||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLInputElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLInputElement> {
|
||||
let element = HTMLInputElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLInputElementBinding::Wrap)
|
||||
}
|
||||
|
@ -297,7 +301,8 @@ impl<'a> HTMLInputElementMethods for JSRef<'a, HTMLInputElement> {
|
|||
make_setter!(SetFormAction, "formaction");
|
||||
|
||||
// https://html.spec.whatwg.org/multipage/#dom-input-formenctype
|
||||
make_enumerated_getter!(FormEnctype, "application/x-www-form-urlencoded", ("text/plain") | ("multipart/form-data"));
|
||||
make_enumerated_getter!(
|
||||
FormEnctype, "application/x-www-form-urlencoded", ("text/plain") | ("multipart/form-data"));
|
||||
|
||||
// https://html.spec.whatwg.org/multipage/#dom-input-formenctype
|
||||
make_setter!(SetFormEnctype, "formenctype");
|
||||
|
@ -678,9 +683,11 @@ impl<'a> Activatable for JSRef<'a, HTMLInputElement> {
|
|||
// https://html.spec.whatwg.org/multipage/#reset-button-state-(type=reset):activation-behavior
|
||||
// InputType::InputSubmit => (), // No behavior defined
|
||||
InputType::InputCheckbox => {
|
||||
// https://html.spec.whatwg.org/multipage/#checkbox-state-(type=checkbox):pre-click-activation-steps
|
||||
// cache current values of `checked` and `indeterminate`
|
||||
// we may need to restore them later
|
||||
/*
|
||||
https://html.spec.whatwg.org/multipage/#checkbox-state-(type=checkbox):pre-click-activation-steps
|
||||
cache current values of `checked` and `indeterminate`
|
||||
we may need to restore them later
|
||||
*/
|
||||
cache.indeterminate = self.Indeterminate();
|
||||
cache.checked = self.Checked();
|
||||
cache.checked_changed = self.checked_changed.get();
|
||||
|
|
|
@ -19,19 +19,26 @@ pub struct HTMLLabelElement {
|
|||
|
||||
impl HTMLLabelElementDerived for EventTarget {
|
||||
fn is_htmllabelelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLLabelElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLLabelElement)))
|
||||
}
|
||||
}
|
||||
|
||||
impl HTMLLabelElement {
|
||||
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLLabelElement {
|
||||
fn new_inherited(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> HTMLLabelElement {
|
||||
HTMLLabelElement {
|
||||
htmlelement: HTMLElement::new_inherited(HTMLElementTypeId::HTMLLabelElement, localName, prefix, document)
|
||||
htmlelement:
|
||||
HTMLElement::new_inherited(HTMLElementTypeId::HTMLLabelElement, localName, prefix, document)
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLLabelElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLLabelElement> {
|
||||
let element = HTMLLabelElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLLabelElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -19,19 +19,26 @@ pub struct HTMLLegendElement {
|
|||
|
||||
impl HTMLLegendElementDerived for EventTarget {
|
||||
fn is_htmllegendelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLLegendElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLLegendElement)))
|
||||
}
|
||||
}
|
||||
|
||||
impl HTMLLegendElement {
|
||||
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLLegendElement {
|
||||
fn new_inherited(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> HTMLLegendElement {
|
||||
HTMLLegendElement {
|
||||
htmlelement: HTMLElement::new_inherited(HTMLElementTypeId::HTMLLegendElement, localName, prefix, document)
|
||||
htmlelement:
|
||||
HTMLElement::new_inherited(HTMLElementTypeId::HTMLLegendElement, localName, prefix, document)
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLLegendElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLLegendElement> {
|
||||
let element = HTMLLegendElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLLegendElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -19,7 +19,9 @@ pub struct HTMLLIElement {
|
|||
|
||||
impl HTMLLIElementDerived for EventTarget {
|
||||
fn is_htmllielement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLLIElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLLIElement)))
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -31,7 +33,9 @@ impl HTMLLIElement {
|
|||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLLIElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLLIElement> {
|
||||
let element = HTMLLIElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLLIElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -44,7 +44,9 @@ pub struct HTMLLinkElement {
|
|||
|
||||
impl HTMLLinkElementDerived for EventTarget {
|
||||
fn is_htmllinkelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLLinkElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLLinkElement)))
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -57,7 +59,9 @@ impl HTMLLinkElement {
|
|||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLLinkElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLLinkElement> {
|
||||
let element = HTMLLinkElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLLinkElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -19,19 +19,25 @@ pub struct HTMLMapElement {
|
|||
|
||||
impl HTMLMapElementDerived for EventTarget {
|
||||
fn is_htmlmapelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLMapElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLMapElement)))
|
||||
}
|
||||
}
|
||||
|
||||
impl HTMLMapElement {
|
||||
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLMapElement {
|
||||
fn new_inherited(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> HTMLMapElement {
|
||||
HTMLMapElement {
|
||||
htmlelement: HTMLElement::new_inherited(HTMLElementTypeId::HTMLMapElement, localName, prefix, document)
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLMapElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLMapElement> {
|
||||
let element = HTMLMapElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLMapElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -19,7 +19,8 @@ pub struct HTMLMediaElement {
|
|||
impl HTMLMediaElementDerived for EventTarget {
|
||||
fn is_htmlmediaelement(&self) -> bool {
|
||||
match *self.type_id() {
|
||||
EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLMediaElement(_)))) => true,
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLMediaElement(_)))) => true,
|
||||
_ => false
|
||||
}
|
||||
}
|
||||
|
@ -30,7 +31,8 @@ impl HTMLMediaElement {
|
|||
prefix: Option<DOMString>, document: JSRef<Document>)
|
||||
-> HTMLMediaElement {
|
||||
HTMLMediaElement {
|
||||
htmlelement: HTMLElement::new_inherited(HTMLElementTypeId::HTMLMediaElement(type_id), tag_name, prefix, document)
|
||||
htmlelement:
|
||||
HTMLElement::new_inherited(HTMLElementTypeId::HTMLMediaElement(type_id), tag_name, prefix, document)
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -20,19 +20,25 @@ pub struct HTMLMetaElement {
|
|||
|
||||
impl HTMLMetaElementDerived for EventTarget {
|
||||
fn is_htmlmetaelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLMetaElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLMetaElement)))
|
||||
}
|
||||
}
|
||||
|
||||
impl HTMLMetaElement {
|
||||
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLMetaElement {
|
||||
fn new_inherited(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> HTMLMetaElement {
|
||||
HTMLMetaElement {
|
||||
htmlelement: HTMLElement::new_inherited(HTMLElementTypeId::HTMLMetaElement, localName, prefix, document)
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLMetaElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLMetaElement> {
|
||||
let element = HTMLMetaElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLMetaElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -19,19 +19,25 @@ pub struct HTMLMeterElement {
|
|||
|
||||
impl HTMLMeterElementDerived for EventTarget {
|
||||
fn is_htmlmeterelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLMeterElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLMeterElement)))
|
||||
}
|
||||
}
|
||||
|
||||
impl HTMLMeterElement {
|
||||
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLMeterElement {
|
||||
fn new_inherited(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> HTMLMeterElement {
|
||||
HTMLMeterElement {
|
||||
htmlelement: HTMLElement::new_inherited(HTMLElementTypeId::HTMLMeterElement, localName, prefix, document)
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLMeterElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLMeterElement> {
|
||||
let element = HTMLMeterElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLMeterElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -19,19 +19,26 @@ pub struct HTMLModElement {
|
|||
|
||||
impl HTMLModElementDerived for EventTarget {
|
||||
fn is_htmlmodelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLModElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLModElement)))
|
||||
}
|
||||
}
|
||||
|
||||
impl HTMLModElement {
|
||||
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLModElement {
|
||||
fn new_inherited(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> HTMLModElement {
|
||||
HTMLModElement {
|
||||
htmlelement: HTMLElement::new_inherited(HTMLElementTypeId::HTMLModElement, localName, prefix, document)
|
||||
htmlelement:
|
||||
HTMLElement::new_inherited(HTMLElementTypeId::HTMLModElement, localName, prefix, document)
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLModElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLModElement> {
|
||||
let element = HTMLModElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLModElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -33,20 +33,27 @@ pub struct HTMLObjectElement {
|
|||
|
||||
impl HTMLObjectElementDerived for EventTarget {
|
||||
fn is_htmlobjectelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLObjectElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLObjectElement)))
|
||||
}
|
||||
}
|
||||
|
||||
impl HTMLObjectElement {
|
||||
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLObjectElement {
|
||||
fn new_inherited(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> HTMLObjectElement {
|
||||
HTMLObjectElement {
|
||||
htmlelement: HTMLElement::new_inherited(HTMLElementTypeId::HTMLObjectElement, localName, prefix, document),
|
||||
htmlelement:
|
||||
HTMLElement::new_inherited(HTMLElementTypeId::HTMLObjectElement, localName, prefix, document),
|
||||
image: DOMRefCell::new(None),
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLObjectElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLObjectElement> {
|
||||
let element = HTMLObjectElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLObjectElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -19,19 +19,25 @@ pub struct HTMLOListElement {
|
|||
|
||||
impl HTMLOListElementDerived for EventTarget {
|
||||
fn is_htmlolistelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLOListElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLOListElement)))
|
||||
}
|
||||
}
|
||||
|
||||
impl HTMLOListElement {
|
||||
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLOListElement {
|
||||
fn new_inherited(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> HTMLOListElement {
|
||||
HTMLOListElement {
|
||||
htmlelement: HTMLElement::new_inherited(HTMLElementTypeId::HTMLOListElement, localName, prefix, document)
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLOListElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLOListElement> {
|
||||
let element = HTMLOListElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLOListElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -26,19 +26,26 @@ pub struct HTMLOptGroupElement {
|
|||
|
||||
impl HTMLOptGroupElementDerived for EventTarget {
|
||||
fn is_htmloptgroupelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLOptGroupElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLOptGroupElement)))
|
||||
}
|
||||
}
|
||||
|
||||
impl HTMLOptGroupElement {
|
||||
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLOptGroupElement {
|
||||
fn new_inherited(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> HTMLOptGroupElement {
|
||||
HTMLOptGroupElement {
|
||||
htmlelement: HTMLElement::new_inherited(HTMLElementTypeId::HTMLOptGroupElement, localName, prefix, document)
|
||||
htmlelement:
|
||||
HTMLElement::new_inherited(HTMLElementTypeId::HTMLOptGroupElement, localName, prefix, document)
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLOptGroupElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLOptGroupElement> {
|
||||
let element = HTMLOptGroupElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLOptGroupElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -30,19 +30,26 @@ pub struct HTMLOptionElement {
|
|||
|
||||
impl HTMLOptionElementDerived for EventTarget {
|
||||
fn is_htmloptionelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLOptionElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLOptionElement)))
|
||||
}
|
||||
}
|
||||
|
||||
impl HTMLOptionElement {
|
||||
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLOptionElement {
|
||||
fn new_inherited(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> HTMLOptionElement {
|
||||
HTMLOptionElement {
|
||||
htmlelement: HTMLElement::new_inherited(HTMLElementTypeId::HTMLOptionElement, localName, prefix, document)
|
||||
htmlelement:
|
||||
HTMLElement::new_inherited(HTMLElementTypeId::HTMLOptionElement, localName, prefix, document)
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLOptionElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLOptionElement> {
|
||||
let element = HTMLOptionElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLOptionElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -21,19 +21,26 @@ pub struct HTMLOutputElement {
|
|||
|
||||
impl HTMLOutputElementDerived for EventTarget {
|
||||
fn is_htmloutputelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLOutputElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLOutputElement)))
|
||||
}
|
||||
}
|
||||
|
||||
impl HTMLOutputElement {
|
||||
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLOutputElement {
|
||||
fn new_inherited(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> HTMLOutputElement {
|
||||
HTMLOutputElement {
|
||||
htmlelement: HTMLElement::new_inherited(HTMLElementTypeId::HTMLOutputElement, localName, prefix, document)
|
||||
htmlelement:
|
||||
HTMLElement::new_inherited(HTMLElementTypeId::HTMLOutputElement, localName, prefix, document)
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLOutputElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLOutputElement> {
|
||||
let element = HTMLOutputElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLOutputElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -19,19 +19,26 @@ pub struct HTMLParagraphElement {
|
|||
|
||||
impl HTMLParagraphElementDerived for EventTarget {
|
||||
fn is_htmlparagraphelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLParagraphElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLParagraphElement)))
|
||||
}
|
||||
}
|
||||
|
||||
impl HTMLParagraphElement {
|
||||
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLParagraphElement {
|
||||
fn new_inherited(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> HTMLParagraphElement {
|
||||
HTMLParagraphElement {
|
||||
htmlelement: HTMLElement::new_inherited(HTMLElementTypeId::HTMLParagraphElement, localName, prefix, document)
|
||||
htmlelement:
|
||||
HTMLElement::new_inherited(HTMLElementTypeId::HTMLParagraphElement, localName, prefix, document)
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLParagraphElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLParagraphElement> {
|
||||
let element = HTMLParagraphElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLParagraphElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -19,19 +19,26 @@ pub struct HTMLParamElement {
|
|||
|
||||
impl HTMLParamElementDerived for EventTarget {
|
||||
fn is_htmlparamelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLParamElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLParamElement)))
|
||||
}
|
||||
}
|
||||
|
||||
impl HTMLParamElement {
|
||||
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLParamElement {
|
||||
fn new_inherited(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> HTMLParamElement {
|
||||
HTMLParamElement {
|
||||
htmlelement: HTMLElement::new_inherited(HTMLElementTypeId::HTMLParamElement, localName, prefix, document)
|
||||
htmlelement:
|
||||
HTMLElement::new_inherited(HTMLElementTypeId::HTMLParamElement, localName, prefix, document)
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLParamElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLParamElement> {
|
||||
let element = HTMLParamElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLParamElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -19,19 +19,26 @@ pub struct HTMLPreElement {
|
|||
|
||||
impl HTMLPreElementDerived for EventTarget {
|
||||
fn is_htmlpreelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLPreElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLPreElement)))
|
||||
}
|
||||
}
|
||||
|
||||
impl HTMLPreElement {
|
||||
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLPreElement {
|
||||
fn new_inherited(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> HTMLPreElement {
|
||||
HTMLPreElement {
|
||||
htmlelement: HTMLElement::new_inherited(HTMLElementTypeId::HTMLPreElement, localName, prefix, document)
|
||||
htmlelement:
|
||||
HTMLElement::new_inherited(HTMLElementTypeId::HTMLPreElement, localName, prefix, document)
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLPreElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLPreElement> {
|
||||
let element = HTMLPreElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLPreElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -19,19 +19,26 @@ pub struct HTMLProgressElement {
|
|||
|
||||
impl HTMLProgressElementDerived for EventTarget {
|
||||
fn is_htmlprogresselement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLProgressElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLProgressElement)))
|
||||
}
|
||||
}
|
||||
|
||||
impl HTMLProgressElement {
|
||||
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLProgressElement {
|
||||
fn new_inherited(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> HTMLProgressElement {
|
||||
HTMLProgressElement {
|
||||
htmlelement: HTMLElement::new_inherited(HTMLElementTypeId::HTMLProgressElement, localName, prefix, document)
|
||||
htmlelement:
|
||||
HTMLElement::new_inherited(HTMLElementTypeId::HTMLProgressElement, localName, prefix, document)
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLProgressElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLProgressElement> {
|
||||
let element = HTMLProgressElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLProgressElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -19,19 +19,26 @@ pub struct HTMLQuoteElement {
|
|||
|
||||
impl HTMLQuoteElementDerived for EventTarget {
|
||||
fn is_htmlquoteelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLQuoteElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLQuoteElement)))
|
||||
}
|
||||
}
|
||||
|
||||
impl HTMLQuoteElement {
|
||||
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLQuoteElement {
|
||||
fn new_inherited(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> HTMLQuoteElement {
|
||||
HTMLQuoteElement {
|
||||
htmlelement: HTMLElement::new_inherited(HTMLElementTypeId::HTMLQuoteElement, localName, prefix, document)
|
||||
htmlelement:
|
||||
HTMLElement::new_inherited(HTMLElementTypeId::HTMLQuoteElement, localName, prefix, document)
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLQuoteElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLQuoteElement> {
|
||||
let element = HTMLQuoteElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLQuoteElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -75,7 +75,9 @@ pub struct HTMLScriptElement {
|
|||
|
||||
impl HTMLScriptElementDerived for EventTarget {
|
||||
fn is_htmlscriptelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLScriptElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLScriptElement)))
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -83,7 +85,8 @@ impl HTMLScriptElement {
|
|||
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>,
|
||||
creator: ElementCreator) -> HTMLScriptElement {
|
||||
HTMLScriptElement {
|
||||
htmlelement: HTMLElement::new_inherited(HTMLElementTypeId::HTMLScriptElement, localName, prefix, document),
|
||||
htmlelement:
|
||||
HTMLElement::new_inherited(HTMLElementTypeId::HTMLScriptElement, localName, prefix, document),
|
||||
already_started: Cell::new(false),
|
||||
parser_inserted: Cell::new(creator == ElementCreator::ParserCreated),
|
||||
non_blocking: Cell::new(creator != ElementCreator::ParserCreated),
|
||||
|
|
|
@ -31,21 +31,28 @@ pub struct HTMLSelectElement {
|
|||
|
||||
impl HTMLSelectElementDerived for EventTarget {
|
||||
fn is_htmlselectelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLSelectElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLSelectElement)))
|
||||
}
|
||||
}
|
||||
|
||||
static DEFAULT_SELECT_SIZE: u32 = 0;
|
||||
|
||||
impl HTMLSelectElement {
|
||||
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLSelectElement {
|
||||
fn new_inherited(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> HTMLSelectElement {
|
||||
HTMLSelectElement {
|
||||
htmlelement: HTMLElement::new_inherited(HTMLElementTypeId::HTMLSelectElement, localName, prefix, document)
|
||||
htmlelement:
|
||||
HTMLElement::new_inherited(HTMLElementTypeId::HTMLSelectElement, localName, prefix, document)
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLSelectElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLSelectElement> {
|
||||
let element = HTMLSelectElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLSelectElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -19,19 +19,26 @@ pub struct HTMLSourceElement {
|
|||
|
||||
impl HTMLSourceElementDerived for EventTarget {
|
||||
fn is_htmlsourceelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLSourceElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLSourceElement)))
|
||||
}
|
||||
}
|
||||
|
||||
impl HTMLSourceElement {
|
||||
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLSourceElement {
|
||||
fn new_inherited(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> HTMLSourceElement {
|
||||
HTMLSourceElement {
|
||||
htmlelement: HTMLElement::new_inherited(HTMLElementTypeId::HTMLSourceElement, localName, prefix, document)
|
||||
htmlelement:
|
||||
HTMLElement::new_inherited(HTMLElementTypeId::HTMLSourceElement, localName, prefix, document)
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLSourceElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLSourceElement> {
|
||||
let element = HTMLSourceElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLSourceElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -19,7 +19,9 @@ pub struct HTMLSpanElement {
|
|||
|
||||
impl HTMLSpanElementDerived for EventTarget {
|
||||
fn is_htmlspanelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLSpanElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLSpanElement)))
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -31,7 +33,9 @@ impl HTMLSpanElement {
|
|||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLSpanElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLSpanElement> {
|
||||
let element = HTMLSpanElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLSpanElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -27,19 +27,25 @@ pub struct HTMLStyleElement {
|
|||
|
||||
impl HTMLStyleElementDerived for EventTarget {
|
||||
fn is_htmlstyleelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLStyleElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLStyleElement)))
|
||||
}
|
||||
}
|
||||
|
||||
impl HTMLStyleElement {
|
||||
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLStyleElement {
|
||||
fn new_inherited(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> HTMLStyleElement {
|
||||
HTMLStyleElement {
|
||||
htmlelement: HTMLElement::new_inherited(HTMLElementTypeId::HTMLStyleElement, localName, prefix, document)
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLStyleElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLStyleElement> {
|
||||
let element = HTMLStyleElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLStyleElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -19,19 +19,26 @@ pub struct HTMLTableCaptionElement {
|
|||
|
||||
impl HTMLTableCaptionElementDerived for EventTarget {
|
||||
fn is_htmltablecaptionelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTableCaptionElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTableCaptionElement)))
|
||||
}
|
||||
}
|
||||
|
||||
impl HTMLTableCaptionElement {
|
||||
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLTableCaptionElement {
|
||||
fn new_inherited(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> HTMLTableCaptionElement {
|
||||
HTMLTableCaptionElement {
|
||||
htmlelement: HTMLElement::new_inherited(HTMLElementTypeId::HTMLTableCaptionElement, localName, prefix, document)
|
||||
htmlelement:
|
||||
HTMLElement::new_inherited(HTMLElementTypeId::HTMLTableCaptionElement, localName, prefix, document)
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLTableCaptionElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLTableCaptionElement> {
|
||||
let element = HTMLTableCaptionElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLTableCaptionElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -41,7 +41,8 @@ pub struct HTMLTableCellElement {
|
|||
impl HTMLTableCellElementDerived for EventTarget {
|
||||
fn is_htmltablecellelement(&self) -> bool {
|
||||
match *self.type_id() {
|
||||
EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTableCellElement(_)))) => true,
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTableCellElement(_)))) => true,
|
||||
_ => false
|
||||
}
|
||||
}
|
||||
|
@ -54,7 +55,8 @@ impl HTMLTableCellElement {
|
|||
document: JSRef<Document>)
|
||||
-> HTMLTableCellElement {
|
||||
HTMLTableCellElement {
|
||||
htmlelement: HTMLElement::new_inherited(HTMLElementTypeId::HTMLTableCellElement(type_id), tag_name, prefix, document),
|
||||
htmlelement: HTMLElement::new_inherited(HTMLElementTypeId::HTMLTableCellElement(type_id),
|
||||
tag_name, prefix, document),
|
||||
background_color: Cell::new(None),
|
||||
colspan: Cell::new(None),
|
||||
width: Cell::new(LengthOrPercentageOrAuto::Auto),
|
||||
|
|
|
@ -19,19 +19,26 @@ pub struct HTMLTableColElement {
|
|||
|
||||
impl HTMLTableColElementDerived for EventTarget {
|
||||
fn is_htmltablecolelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTableColElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTableColElement)))
|
||||
}
|
||||
}
|
||||
|
||||
impl HTMLTableColElement {
|
||||
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLTableColElement {
|
||||
fn new_inherited(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> HTMLTableColElement {
|
||||
HTMLTableColElement {
|
||||
htmlelement: HTMLElement::new_inherited(HTMLElementTypeId::HTMLTableColElement, localName, prefix, document)
|
||||
htmlelement:
|
||||
HTMLElement::new_inherited(HTMLElementTypeId::HTMLTableColElement, localName, prefix, document)
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLTableColElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLTableColElement> {
|
||||
let element = HTMLTableColElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLTableColElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -28,10 +28,13 @@ impl HTMLTableDataCellElementDerived for EventTarget {
|
|||
}
|
||||
|
||||
impl HTMLTableDataCellElement {
|
||||
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLTableDataCellElement {
|
||||
fn new_inherited(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> HTMLTableDataCellElement {
|
||||
HTMLTableDataCellElement {
|
||||
htmltablecellelement: HTMLTableCellElement::new_inherited(HTMLTableCellElementTypeId::HTMLTableDataCellElement,
|
||||
localName, prefix, document)
|
||||
htmltablecellelement:
|
||||
HTMLTableCellElement::new_inherited(
|
||||
HTMLTableCellElementTypeId::HTMLTableDataCellElement, localName, prefix, document)
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -35,7 +35,9 @@ pub struct HTMLTableElement {
|
|||
|
||||
impl HTMLTableElementDerived for EventTarget {
|
||||
fn is_htmltableelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTableElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTableElement)))
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -28,15 +28,19 @@ impl HTMLTableHeaderCellElementDerived for EventTarget {
|
|||
}
|
||||
|
||||
impl HTMLTableHeaderCellElement {
|
||||
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLTableHeaderCellElement {
|
||||
fn new_inherited(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> HTMLTableHeaderCellElement {
|
||||
HTMLTableHeaderCellElement {
|
||||
htmltablecellelement: HTMLTableCellElement::new_inherited(HTMLTableCellElementTypeId::HTMLTableHeaderCellElement,
|
||||
localName, prefix, document)
|
||||
htmltablecellelement: HTMLTableCellElement::new_inherited(
|
||||
HTMLTableCellElementTypeId::HTMLTableHeaderCellElement, localName, prefix, document)
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLTableHeaderCellElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLTableHeaderCellElement> {
|
||||
let element = HTMLTableHeaderCellElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLTableHeaderCellElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -25,7 +25,9 @@ pub struct HTMLTableRowElement {
|
|||
|
||||
impl HTMLTableRowElementDerived for EventTarget {
|
||||
fn is_htmltablerowelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTableRowElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTableRowElement)))
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -25,7 +25,9 @@ pub struct HTMLTableSectionElement {
|
|||
|
||||
impl HTMLTableSectionElementDerived for EventTarget {
|
||||
fn is_htmltablesectionelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTableSectionElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTableSectionElement)))
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -19,19 +19,26 @@ pub struct HTMLTemplateElement {
|
|||
|
||||
impl HTMLTemplateElementDerived for EventTarget {
|
||||
fn is_htmltemplateelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTemplateElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTemplateElement)))
|
||||
}
|
||||
}
|
||||
|
||||
impl HTMLTemplateElement {
|
||||
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLTemplateElement {
|
||||
fn new_inherited(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> HTMLTemplateElement {
|
||||
HTMLTemplateElement {
|
||||
htmlelement: HTMLElement::new_inherited(HTMLElementTypeId::HTMLTemplateElement, localName, prefix, document)
|
||||
htmlelement:
|
||||
HTMLElement::new_inherited(HTMLElementTypeId::HTMLTemplateElement, localName, prefix, document)
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLTemplateElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLTemplateElement> {
|
||||
let element = HTMLTemplateElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLTemplateElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -50,7 +50,9 @@ pub struct HTMLTextAreaElement {
|
|||
|
||||
impl HTMLTextAreaElementDerived for EventTarget {
|
||||
fn is_htmltextareaelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTextAreaElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTextAreaElement)))
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -92,10 +94,13 @@ static DEFAULT_COLS: u32 = 20;
|
|||
static DEFAULT_ROWS: u32 = 2;
|
||||
|
||||
impl HTMLTextAreaElement {
|
||||
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLTextAreaElement {
|
||||
fn new_inherited(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> HTMLTextAreaElement {
|
||||
let chan = document.window().root().r().constellation_chan();
|
||||
HTMLTextAreaElement {
|
||||
htmlelement: HTMLElement::new_inherited(HTMLElementTypeId::HTMLTextAreaElement, localName, prefix, document),
|
||||
htmlelement:
|
||||
HTMLElement::new_inherited(HTMLElementTypeId::HTMLTextAreaElement, localName, prefix, document),
|
||||
textinput: DOMRefCell::new(TextInput::new(Lines::Multiple, "".to_owned(), chan)),
|
||||
cols: Cell::new(DEFAULT_COLS),
|
||||
rows: Cell::new(DEFAULT_ROWS),
|
||||
|
@ -104,7 +109,9 @@ impl HTMLTextAreaElement {
|
|||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLTextAreaElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLTextAreaElement> {
|
||||
let element = HTMLTextAreaElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLTextAreaElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -19,7 +19,9 @@ pub struct HTMLTimeElement {
|
|||
|
||||
impl HTMLTimeElementDerived for EventTarget {
|
||||
fn is_htmltimeelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTimeElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTimeElement)))
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -31,7 +33,9 @@ impl HTMLTimeElement {
|
|||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLTimeElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLTimeElement> {
|
||||
let element = HTMLTimeElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLTimeElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -25,7 +25,9 @@ pub struct HTMLTitleElement {
|
|||
|
||||
impl HTMLTitleElementDerived for EventTarget {
|
||||
fn is_htmltitleelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTitleElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTitleElement)))
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -37,7 +39,9 @@ impl HTMLTitleElement {
|
|||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLTitleElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLTitleElement> {
|
||||
let element = HTMLTitleElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLTitleElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -19,7 +19,9 @@ pub struct HTMLTrackElement {
|
|||
|
||||
impl HTMLTrackElementDerived for EventTarget {
|
||||
fn is_htmltrackelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTrackElement)))
|
||||
*self.type_id() == EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(
|
||||
ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLTrackElement)))
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -31,7 +33,9 @@ impl HTMLTrackElement {
|
|||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLTrackElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLTrackElement> {
|
||||
let element = HTMLTrackElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLTrackElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -19,7 +19,9 @@ pub struct HTMLUListElement {
|
|||
|
||||
impl HTMLUListElementDerived for EventTarget {
|
||||
fn is_htmlulistelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLUListElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLUListElement)))
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -31,7 +33,9 @@ impl HTMLUListElement {
|
|||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLUListElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLUListElement> {
|
||||
let element = HTMLUListElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLUListElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -19,19 +19,26 @@ pub struct HTMLUnknownElement {
|
|||
|
||||
impl HTMLUnknownElementDerived for EventTarget {
|
||||
fn is_htmlunknownelement(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLUnknownElement)))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLUnknownElement)))
|
||||
}
|
||||
}
|
||||
|
||||
impl HTMLUnknownElement {
|
||||
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLUnknownElement {
|
||||
fn new_inherited(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> HTMLUnknownElement {
|
||||
HTMLUnknownElement {
|
||||
htmlelement: HTMLElement::new_inherited(HTMLElementTypeId::HTMLUnknownElement, localName, prefix, document)
|
||||
htmlelement:
|
||||
HTMLElement::new_inherited(HTMLElementTypeId::HTMLUnknownElement, localName, prefix, document)
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLUnknownElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLUnknownElement> {
|
||||
let element = HTMLUnknownElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLUnknownElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -30,12 +30,15 @@ impl HTMLVideoElementDerived for EventTarget {
|
|||
impl HTMLVideoElement {
|
||||
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLVideoElement {
|
||||
HTMLVideoElement {
|
||||
htmlmediaelement: HTMLMediaElement::new_inherited(HTMLMediaElementTypeId::HTMLVideoElement, localName, prefix, document)
|
||||
htmlmediaelement:
|
||||
HTMLMediaElement::new_inherited(HTMLMediaElementTypeId::HTMLVideoElement, localName, prefix, document)
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLVideoElement> {
|
||||
pub fn new(localName: DOMString,
|
||||
prefix: Option<DOMString>,
|
||||
document: JSRef<Document>) -> Temporary<HTMLVideoElement> {
|
||||
let element = HTMLVideoElement::new_inherited(localName, prefix, document);
|
||||
Node::reflect_node(box element, document, HTMLVideoElementBinding::Wrap)
|
||||
}
|
||||
|
|
|
@ -49,7 +49,10 @@ impl MessageEvent {
|
|||
MessageEvent::new_initialized(global, UndefinedValue(), "".to_owned(), "".to_owned())
|
||||
}
|
||||
|
||||
pub fn new_initialized(global: GlobalRef, data: JSVal, origin: DOMString, lastEventId: DOMString) -> Temporary<MessageEvent> {
|
||||
pub fn new_initialized(global: GlobalRef,
|
||||
data: JSVal,
|
||||
origin: DOMString,
|
||||
lastEventId: DOMString) -> Temporary<MessageEvent> {
|
||||
reflect_dom_object(box MessageEvent::new_inherited(data, origin, lastEventId),
|
||||
global,
|
||||
MessageEventBinding::Wrap)
|
||||
|
|
|
@ -80,7 +80,8 @@ impl MouseEvent {
|
|||
button: i16,
|
||||
relatedTarget: Option<JSRef<EventTarget>>) -> Temporary<MouseEvent> {
|
||||
let ev = MouseEvent::new_uninitialized(window).root();
|
||||
ev.r().InitMouseEvent(type_, canBubble == EventBubbles::Bubbles, cancelable == EventCancelable::Cancelable, view, detail,
|
||||
ev.r().InitMouseEvent(type_, canBubble == EventBubbles::Bubbles, cancelable == EventCancelable::Cancelable,
|
||||
view, detail,
|
||||
screenX, screenY, clientX, clientY,
|
||||
ctrlKey, altKey, shiftKey, metaKey,
|
||||
button, relatedTarget);
|
||||
|
@ -90,8 +91,16 @@ impl MouseEvent {
|
|||
pub fn Constructor(global: GlobalRef,
|
||||
type_: DOMString,
|
||||
init: &MouseEventBinding::MouseEventInit) -> Fallible<Temporary<MouseEvent>> {
|
||||
let bubbles = if init.parent.parent.parent.bubbles { EventBubbles::Bubbles } else { EventBubbles::DoesNotBubble };
|
||||
let cancelable = if init.parent.parent.parent.cancelable { EventCancelable::Cancelable } else { EventCancelable::NotCancelable };
|
||||
let bubbles = if init.parent.parent.parent.bubbles {
|
||||
EventBubbles::Bubbles
|
||||
} else {
|
||||
EventBubbles::DoesNotBubble
|
||||
};
|
||||
let cancelable = if init.parent.parent.parent.cancelable {
|
||||
EventCancelable::Cancelable
|
||||
} else {
|
||||
EventCancelable::NotCancelable
|
||||
};
|
||||
let event = MouseEvent::new(global.as_window(), type_,
|
||||
bubbles,
|
||||
cancelable,
|
||||
|
|
|
@ -177,7 +177,8 @@ impl NodeFlags {
|
|||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLOptGroupElement)) |
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLOptionElement)) |
|
||||
//NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLMenuItemElement)) |
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLFieldSetElement)) => IN_ENABLED_STATE | dirty,
|
||||
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLFieldSetElement)) =>
|
||||
IN_ENABLED_STATE | dirty,
|
||||
_ => dirty,
|
||||
}
|
||||
}
|
||||
|
@ -1809,13 +1810,20 @@ impl<'a> NodeMethods for JSRef<'a, Node> {
|
|||
// https://dom.spec.whatwg.org/#dom-node-nodetype
|
||||
fn NodeType(self) -> u16 {
|
||||
match self.type_id {
|
||||
NodeTypeId::CharacterData(CharacterDataTypeId::Text) => NodeConstants::TEXT_NODE,
|
||||
NodeTypeId::CharacterData(CharacterDataTypeId::ProcessingInstruction) => NodeConstants::PROCESSING_INSTRUCTION_NODE,
|
||||
NodeTypeId::CharacterData(CharacterDataTypeId::Comment) => NodeConstants::COMMENT_NODE,
|
||||
NodeTypeId::Document => NodeConstants::DOCUMENT_NODE,
|
||||
NodeTypeId::DocumentType => NodeConstants::DOCUMENT_TYPE_NODE,
|
||||
NodeTypeId::DocumentFragment => NodeConstants::DOCUMENT_FRAGMENT_NODE,
|
||||
NodeTypeId::Element(_) => NodeConstants::ELEMENT_NODE,
|
||||
NodeTypeId::CharacterData(CharacterDataTypeId::Text) =>
|
||||
NodeConstants::TEXT_NODE,
|
||||
NodeTypeId::CharacterData(CharacterDataTypeId::ProcessingInstruction) =>
|
||||
NodeConstants::PROCESSING_INSTRUCTION_NODE,
|
||||
NodeTypeId::CharacterData(CharacterDataTypeId::Comment) =>
|
||||
NodeConstants::COMMENT_NODE,
|
||||
NodeTypeId::Document =>
|
||||
NodeConstants::DOCUMENT_NODE,
|
||||
NodeTypeId::DocumentType =>
|
||||
NodeConstants::DOCUMENT_TYPE_NODE,
|
||||
NodeTypeId::DocumentFragment =>
|
||||
NodeConstants::DOCUMENT_FRAGMENT_NODE,
|
||||
NodeTypeId::Element(_) =>
|
||||
NodeConstants::ELEMENT_NODE,
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -2008,7 +2016,8 @@ impl<'a> NodeMethods for JSRef<'a, Node> {
|
|||
|
||||
// Step 4-5.
|
||||
match node.type_id() {
|
||||
NodeTypeId::CharacterData(CharacterDataTypeId::Text) if self.is_document() => return Err(HierarchyRequest),
|
||||
NodeTypeId::CharacterData(CharacterDataTypeId::Text) if self.is_document() =>
|
||||
return Err(HierarchyRequest),
|
||||
NodeTypeId::DocumentType if !self.is_document() => return Err(HierarchyRequest),
|
||||
NodeTypeId::DocumentFragment |
|
||||
NodeTypeId::DocumentType |
|
||||
|
@ -2159,7 +2168,8 @@ impl<'a> NodeMethods for JSRef<'a, Node> {
|
|||
match prev_text {
|
||||
Some(ref text_node) => {
|
||||
let text_node = text_node.clone().root();
|
||||
let prev_characterdata: JSRef<CharacterData> = CharacterDataCast::from_ref(text_node.r());
|
||||
let prev_characterdata: JSRef<CharacterData> =
|
||||
CharacterDataCast::from_ref(text_node.r());
|
||||
let _ = prev_characterdata.AppendData(characterdata.Data());
|
||||
self.remove_child(child.r());
|
||||
},
|
||||
|
|
|
@ -21,7 +21,8 @@ pub struct ProcessingInstruction {
|
|||
|
||||
impl ProcessingInstructionDerived for EventTarget {
|
||||
fn is_processinginstruction(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::CharacterData(CharacterDataTypeId::ProcessingInstruction))
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::Node(NodeTypeId::CharacterData(CharacterDataTypeId::ProcessingInstruction))
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -76,7 +76,8 @@ impl<'a> StorageMethods for JSRef<'a, Storage> {
|
|||
fn GetItem(self, name: DOMString) -> Option<DOMString> {
|
||||
let (sender, receiver) = channel();
|
||||
|
||||
self.get_storage_task().send(StorageTaskMsg::GetItem(sender, self.get_url(), self.storage_type, name)).unwrap();
|
||||
let msg = StorageTaskMsg::GetItem(sender, self.get_url(), self.storage_type, name);
|
||||
self.get_storage_task().send(msg).unwrap();
|
||||
receiver.recv().unwrap()
|
||||
}
|
||||
|
||||
|
@ -89,7 +90,8 @@ impl<'a> StorageMethods for JSRef<'a, Storage> {
|
|||
fn SetItem(self, name: DOMString, value: DOMString) {
|
||||
let (sender, receiver) = channel();
|
||||
|
||||
self.get_storage_task().send(StorageTaskMsg::SetItem(sender, self.get_url(), self.storage_type, name.clone(), value.clone())).unwrap();
|
||||
let msg = StorageTaskMsg::SetItem(sender, self.get_url(), self.storage_type, name.clone(), value.clone());
|
||||
self.get_storage_task().send(msg).unwrap();
|
||||
let (changed, old_value) = receiver.recv().unwrap();
|
||||
if changed {
|
||||
self.broadcast_change_notification(Some(name), old_value, Some(value));
|
||||
|
@ -107,7 +109,8 @@ impl<'a> StorageMethods for JSRef<'a, Storage> {
|
|||
fn RemoveItem(self, name: DOMString) {
|
||||
let (sender, receiver) = channel();
|
||||
|
||||
self.get_storage_task().send(StorageTaskMsg::RemoveItem(sender, self.get_url(), self.storage_type, name.clone())).unwrap();
|
||||
let msg = StorageTaskMsg::RemoveItem(sender, self.get_url(), self.storage_type, name.clone());
|
||||
self.get_storage_task().send(msg).unwrap();
|
||||
if let Some(old_value) = receiver.recv().unwrap() {
|
||||
self.broadcast_change_notification(Some(name), Some(old_value), None);
|
||||
}
|
||||
|
|
|
@ -73,7 +73,11 @@ impl StorageEvent {
|
|||
let url = init.url.clone();
|
||||
let storageArea = init.storageArea.r();
|
||||
let bubbles = if init.parent.bubbles { EventBubbles::Bubbles } else { EventBubbles::DoesNotBubble };
|
||||
let cancelable = if init.parent.cancelable { EventCancelable::Cancelable } else { EventCancelable::NotCancelable };
|
||||
let cancelable = if init.parent.cancelable {
|
||||
EventCancelable::Cancelable
|
||||
} else {
|
||||
EventCancelable::NotCancelable
|
||||
};
|
||||
let event = StorageEvent::new(global, type_,
|
||||
bubbles, cancelable,
|
||||
key, oldValue, newValue,
|
||||
|
|
|
@ -55,7 +55,8 @@ impl UIEvent {
|
|||
view: Option<JSRef<Window>>,
|
||||
detail: i32) -> Temporary<UIEvent> {
|
||||
let ev = UIEvent::new_uninitialized(window).root();
|
||||
ev.r().InitUIEvent(type_, can_bubble == EventBubbles::Bubbles, cancelable == EventCancelable::Cancelable, view, detail);
|
||||
ev.r().InitUIEvent(type_, can_bubble == EventBubbles::Bubbles,
|
||||
cancelable == EventCancelable::Cancelable, view, detail);
|
||||
Temporary::from_rooted(ev.r())
|
||||
}
|
||||
|
||||
|
@ -63,7 +64,11 @@ impl UIEvent {
|
|||
type_: DOMString,
|
||||
init: &UIEventBinding::UIEventInit) -> Fallible<Temporary<UIEvent>> {
|
||||
let bubbles = if init.parent.bubbles { EventBubbles::Bubbles } else { EventBubbles::DoesNotBubble };
|
||||
let cancelable = if init.parent.cancelable { EventCancelable::Cancelable } else { EventCancelable::NotCancelable };
|
||||
let cancelable = if init.parent.cancelable {
|
||||
EventCancelable::Cancelable
|
||||
} else {
|
||||
EventCancelable::NotCancelable
|
||||
};
|
||||
let event = UIEvent::new(global.as_window(), type_,
|
||||
bubbles, cancelable,
|
||||
init.view.r(), init.detail);
|
||||
|
|
|
@ -5,7 +5,8 @@
|
|||
use canvas::webgl_paint_task::WebGLPaintTask;
|
||||
use canvas_traits::{CanvasMsg, CanvasWebGLMsg, CanvasCommonMsg};
|
||||
use dom::bindings::codegen::Bindings::WebGLRenderingContextBinding;
|
||||
use dom::bindings::codegen::Bindings::WebGLRenderingContextBinding::{ WebGLRenderingContextMethods, WebGLRenderingContextConstants};
|
||||
use dom::bindings::codegen::Bindings::WebGLRenderingContextBinding::{
|
||||
WebGLRenderingContextMethods, WebGLRenderingContextConstants};
|
||||
use dom::bindings::global::{GlobalRef, GlobalField};
|
||||
use dom::bindings::js::{JS, JSRef, LayoutJS, Temporary};
|
||||
use dom::bindings::utils::{Reflector, reflect_dom_object};
|
||||
|
@ -192,12 +193,15 @@ impl<'a> WebGLRenderingContextMethods for JSRef<'a, WebGLRenderingContext> {
|
|||
None => return NullValue(),
|
||||
};
|
||||
let (sender, receiver) = channel::<i32>();
|
||||
self.renderer.send(CanvasMsg::WebGL(CanvasWebGLMsg::GetShaderParameter(shader_id, param_id, sender))).unwrap();
|
||||
let msg = CanvasMsg::WebGL(CanvasWebGLMsg::GetShaderParameter(shader_id, param_id, sender));
|
||||
self.renderer.send(msg).unwrap();
|
||||
Int32Value(receiver.recv().unwrap())
|
||||
}
|
||||
|
||||
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.10
|
||||
fn GetUniformLocation(self, program: Option<JSRef<WebGLProgram>>, name: DOMString) -> Option<Temporary<WebGLUniformLocation>> {
|
||||
fn GetUniformLocation(self,
|
||||
program: Option<JSRef<WebGLProgram>>,
|
||||
name: DOMString) -> Option<Temporary<WebGLUniformLocation>> {
|
||||
let program_id = match program {
|
||||
Some(program) => program.get_id(),
|
||||
None => return None,
|
||||
|
@ -226,12 +230,16 @@ impl<'a> WebGLRenderingContextMethods for JSRef<'a, WebGLRenderingContext> {
|
|||
.split(|c: char| c == '\n')
|
||||
.map(|line: &str| String::from_str(line) + "\n")
|
||||
.collect();
|
||||
self.renderer.send(CanvasMsg::WebGL(CanvasWebGLMsg::ShaderSource(shader_id, source_lines))).unwrap()
|
||||
let msg = CanvasMsg::WebGL(CanvasWebGLMsg::ShaderSource(shader_id, source_lines));
|
||||
self.renderer.send(msg).unwrap()
|
||||
}
|
||||
|
||||
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.10
|
||||
#[allow(unsafe_code)]
|
||||
fn Uniform4fv(self, cx: *mut JSContext, uniform: Option<JSRef<WebGLUniformLocation>>, data: Option<*mut JSObject>) {
|
||||
fn Uniform4fv(self,
|
||||
cx: *mut JSContext,
|
||||
uniform: Option<JSRef<WebGLUniformLocation>>,
|
||||
data: Option<*mut JSObject>) {
|
||||
let uniform_id = match uniform {
|
||||
Some(uniform) => uniform.get_id(),
|
||||
None => return,
|
||||
|
@ -262,8 +270,9 @@ impl<'a> WebGLRenderingContextMethods for JSRef<'a, WebGLRenderingContext> {
|
|||
normalized: bool, stride: i32, offset: i64) {
|
||||
match data_type {
|
||||
WebGLRenderingContextConstants::FLOAT => {
|
||||
self.renderer.send(
|
||||
CanvasMsg::WebGL(CanvasWebGLMsg::VertexAttribPointer2f(attrib_id, size, normalized, stride, offset))).unwrap()
|
||||
let msg = CanvasMsg::WebGL(
|
||||
CanvasWebGLMsg::VertexAttribPointer2f(attrib_id, size, normalized, stride, offset));
|
||||
self.renderer.send(msg).unwrap()
|
||||
}
|
||||
_ => panic!("VertexAttribPointer: Data Type not supported")
|
||||
}
|
||||
|
|
|
@ -162,7 +162,8 @@ impl WebSocket {
|
|||
|
||||
//Create everything necessary for starting the open asynchronous task, then begin the task.
|
||||
let global_root = ws_root.global.root();
|
||||
let addr: Trusted<WebSocket> = Trusted::new(global_root.r().get_cx(), ws_root, global_root.r().script_chan().clone());
|
||||
let addr: Trusted<WebSocket> =
|
||||
Trusted::new(global_root.r().get_cx(), ws_root, global_root.r().script_chan().clone());
|
||||
let open_task = box WebSocketTaskHandler::new(addr.clone(), WebSocketTask::Open);
|
||||
global_root.r().script_chan().send(ScriptMsg::RunnableMsg(open_task)).unwrap();
|
||||
//TODO: Spawn thread here for receive loop
|
||||
|
@ -200,7 +201,8 @@ impl<'a> WebSocketMethods for JSRef<'a, WebSocket> {
|
|||
}
|
||||
|
||||
fn Send(self, data: Option<USVString>)-> Fallible<()>{
|
||||
/*TODO: This is not up to spec see http://html.spec.whatwg.org/multipage/comms.html search for "If argument is a string"
|
||||
/*TODO: This is not up to spec see http://html.spec.whatwg.org/multipage/comms.html search for
|
||||
"If argument is a string"
|
||||
TODO: Need to buffer data
|
||||
TODO: bufferedAmount attribute returns the size of the buffer in bytes -
|
||||
this is a required attribute defined in the websocket.webidl file
|
||||
|
@ -240,9 +242,11 @@ impl<'a> WebSocketMethods for JSRef<'a, WebSocket> {
|
|||
self.failed.set(true);
|
||||
self.sendCloseFrame.set(true);
|
||||
//Dispatch send task to send close frame
|
||||
//TODO: Sending here is just empty string, though no string is really needed. Another send, empty send, could be used.
|
||||
//TODO: Sending here is just empty string, though no string is really needed. Another send, empty
|
||||
// send, could be used.
|
||||
let _ = self.Send(None);
|
||||
//Note: After sending the close message, the receive loop confirms a close message from the server and must fire a close event
|
||||
//Note: After sending the close message, the receive loop confirms a close message from the server and
|
||||
// must fire a close event
|
||||
}
|
||||
WebSocketRequestState::Open => {
|
||||
//Closing handshake not started - still in open
|
||||
|
@ -257,7 +261,8 @@ impl<'a> WebSocketMethods for JSRef<'a, WebSocket> {
|
|||
self.sendCloseFrame.set(true);
|
||||
//Dispatch send task to send close frame
|
||||
let _ = self.Send(None);
|
||||
//Note: After sending the close message, the receive loop confirms a close message from the server and must fire a close event
|
||||
//Note: After sending the close message, the receive loop confirms a close message from the server and
|
||||
// must fire a close event
|
||||
}
|
||||
}
|
||||
Ok(()) //Return Ok
|
||||
|
|
|
@ -735,14 +735,18 @@ impl<'a> WindowHelpers for JSRef<'a, Window> {
|
|||
}
|
||||
|
||||
fn content_box_query(self, content_box_request: TrustedNodeAddress) -> Rect<Au> {
|
||||
self.reflow(ReflowGoal::ForScriptQuery, ReflowQueryType::ContentBoxQuery(content_box_request), ReflowReason::Query);
|
||||
self.reflow(ReflowGoal::ForScriptQuery,
|
||||
ReflowQueryType::ContentBoxQuery(content_box_request),
|
||||
ReflowReason::Query);
|
||||
self.join_layout(); //FIXME: is this necessary, or is layout_rpc's mutex good enough?
|
||||
let ContentBoxResponse(rect) = self.layout_rpc.content_box();
|
||||
rect
|
||||
}
|
||||
|
||||
fn content_boxes_query(self, content_boxes_request: TrustedNodeAddress) -> Vec<Rect<Au>> {
|
||||
self.reflow(ReflowGoal::ForScriptQuery, ReflowQueryType::ContentBoxesQuery(content_boxes_request), ReflowReason::Query);
|
||||
self.reflow(ReflowGoal::ForScriptQuery,
|
||||
ReflowQueryType::ContentBoxesQuery(content_boxes_request),
|
||||
ReflowReason::Query);
|
||||
self.join_layout(); //FIXME: is this necessary, or is layout_rpc's mutex good enough?
|
||||
let ContentBoxesResponse(rects) = self.layout_rpc.content_boxes();
|
||||
rects
|
||||
|
|
|
@ -192,7 +192,8 @@ pub struct WorkerErrorHandler {
|
|||
}
|
||||
|
||||
impl WorkerErrorHandler {
|
||||
pub fn new(addr: TrustedWorkerAddress, msg: DOMString, file_name: DOMString, line_num: u32, col_num: u32) -> WorkerErrorHandler {
|
||||
pub fn new(addr: TrustedWorkerAddress, msg: DOMString, file_name: DOMString, line_num: u32, col_num: u32)
|
||||
-> WorkerErrorHandler {
|
||||
WorkerErrorHandler {
|
||||
addr: addr,
|
||||
msg: msg,
|
||||
|
|
|
@ -19,7 +19,8 @@ pub struct XMLHttpRequestUpload {
|
|||
impl XMLHttpRequestUpload {
|
||||
fn new_inherited() -> XMLHttpRequestUpload {
|
||||
XMLHttpRequestUpload {
|
||||
eventtarget: XMLHttpRequestEventTarget::new_inherited(XMLHttpRequestEventTargetTypeId::XMLHttpRequestUpload)
|
||||
eventtarget: XMLHttpRequestEventTarget::new_inherited(
|
||||
XMLHttpRequestEventTargetTypeId::XMLHttpRequestUpload)
|
||||
}
|
||||
}
|
||||
pub fn new(global: GlobalRef) -> Temporary<XMLHttpRequestUpload> {
|
||||
|
@ -31,6 +32,7 @@ impl XMLHttpRequestUpload {
|
|||
|
||||
impl XMLHttpRequestUploadDerived for EventTarget {
|
||||
fn is_xmlhttprequestupload(&self) -> bool {
|
||||
*self.type_id() == EventTargetTypeId::XMLHttpRequestEventTarget(XMLHttpRequestEventTargetTypeId::XMLHttpRequestUpload)
|
||||
*self.type_id() ==
|
||||
EventTargetTypeId::XMLHttpRequestEventTarget(XMLHttpRequestEventTargetTypeId::XMLHttpRequestUpload)
|
||||
}
|
||||
}
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue