mirror of
https://github.com/servo/servo.git
synced 2025-08-03 12:40:06 +01:00
commit
cc23f3c436
22 changed files with 417 additions and 406 deletions
|
@ -112,7 +112,7 @@ pub trait TLayoutNode {
|
|||
fail!("not an iframe element!")
|
||||
}
|
||||
let iframe_element: JS<HTMLIFrameElement> = self.get_jsmanaged().transmute_copy();
|
||||
let size = (*iframe_element.unsafe_get()).size.unwrap();
|
||||
let size = (*iframe_element.unsafe_get()).size.deref().get().unwrap();
|
||||
(size.pipeline_id, size.subpage_id)
|
||||
}
|
||||
}
|
||||
|
@ -188,7 +188,7 @@ impl<'ln> TLayoutNode for LayoutNode<'ln> {
|
|||
fail!("not text!")
|
||||
}
|
||||
let text: JS<Text> = self.get_jsmanaged().transmute_copy();
|
||||
(*text.unsafe_get()).characterdata.data.to_str()
|
||||
(*text.unsafe_get()).characterdata.data.deref().borrow().clone()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -494,7 +494,7 @@ impl<'ln> TLayoutNode for ThreadSafeLayoutNode<'ln> {
|
|||
fail!("not text!")
|
||||
}
|
||||
let text: JS<Text> = self.get_jsmanaged().transmute_copy();
|
||||
(*text.unsafe_get()).characterdata.data.to_str()
|
||||
(*text.unsafe_get()).characterdata.data.deref().borrow().clone()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -636,7 +636,7 @@ impl<'ln> ThreadSafeLayoutNode<'ln> {
|
|||
Some(TextNodeTypeId) => {
|
||||
unsafe {
|
||||
let text: JS<Text> = self.get_jsmanaged().transmute_copy();
|
||||
if !is_whitespace((*text.unsafe_get()).characterdata.data.as_slice()) {
|
||||
if !is_whitespace((*text.unsafe_get()).characterdata.data.deref().borrow().as_slice()) {
|
||||
return false
|
||||
}
|
||||
|
||||
|
|
|
@ -606,7 +606,7 @@ pub extern fn outerize_global(_cx: *mut JSContext, obj: JSHandleObject) -> *mut
|
|||
IDLInterface::get_prototype_depth(None::<window::Window>))
|
||||
.unwrap()
|
||||
.root();
|
||||
win.deref().browser_context.get_ref().window_proxy()
|
||||
win.deref().browser_context.deref().borrow().get_ref().window_proxy()
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -5,18 +5,21 @@
|
|||
//! DOM bindings for `CharacterData`.
|
||||
|
||||
use dom::bindings::codegen::InheritTypes::{CharacterDataDerived, NodeCast};
|
||||
use dom::bindings::js::JSRef;
|
||||
use dom::bindings::error::{Fallible, ErrorResult, IndexSize};
|
||||
use dom::bindings::js::JSRef;
|
||||
use dom::bindings::trace::Untraceable;
|
||||
use dom::bindings::utils::{Reflectable, Reflector};
|
||||
use dom::document::Document;
|
||||
use dom::eventtarget::{EventTarget, NodeTargetTypeId};
|
||||
use dom::node::{CommentNodeTypeId, Node, NodeTypeId, TextNodeTypeId, ProcessingInstructionNodeTypeId, NodeHelpers};
|
||||
use servo_util::str::DOMString;
|
||||
|
||||
use std::cell::RefCell;
|
||||
|
||||
#[deriving(Encodable)]
|
||||
pub struct CharacterData {
|
||||
pub node: Node,
|
||||
pub data: DOMString,
|
||||
pub data: Untraceable<RefCell<DOMString>>,
|
||||
}
|
||||
|
||||
impl CharacterDataDerived for EventTarget {
|
||||
|
@ -34,56 +37,56 @@ impl CharacterData {
|
|||
pub fn new_inherited(id: NodeTypeId, data: DOMString, document: &JSRef<Document>) -> CharacterData {
|
||||
CharacterData {
|
||||
node: Node::new_inherited(id, document),
|
||||
data: data
|
||||
data: Untraceable::new(RefCell::new(data)),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub trait CharacterDataMethods {
|
||||
fn Data(&self) -> DOMString;
|
||||
fn SetData(&mut self, arg: DOMString) -> ErrorResult;
|
||||
fn SetData(&self, arg: DOMString) -> ErrorResult;
|
||||
fn Length(&self) -> u32;
|
||||
fn SubstringData(&self, offset: u32, count: u32) -> Fallible<DOMString>;
|
||||
fn AppendData(&mut self, arg: DOMString) -> ErrorResult;
|
||||
fn InsertData(&mut self, _offset: u32, _arg: DOMString) -> ErrorResult;
|
||||
fn DeleteData(&mut self, _offset: u32, _count: u32) -> ErrorResult;
|
||||
fn ReplaceData(&mut self, _offset: u32, _count: u32, _arg: DOMString) -> ErrorResult;
|
||||
fn AppendData(&self, arg: DOMString) -> ErrorResult;
|
||||
fn InsertData(&self, _offset: u32, _arg: DOMString) -> ErrorResult;
|
||||
fn DeleteData(&self, _offset: u32, _count: u32) -> ErrorResult;
|
||||
fn ReplaceData(&self, _offset: u32, _count: u32, _arg: DOMString) -> ErrorResult;
|
||||
fn Remove(&self);
|
||||
}
|
||||
|
||||
impl<'a> CharacterDataMethods for JSRef<'a, CharacterData> {
|
||||
fn Data(&self) -> DOMString {
|
||||
self.data.clone()
|
||||
self.data.deref().borrow().clone()
|
||||
}
|
||||
|
||||
fn SetData(&mut self, arg: DOMString) -> ErrorResult {
|
||||
self.data = arg;
|
||||
fn SetData(&self, arg: DOMString) -> ErrorResult {
|
||||
*self.data.deref().borrow_mut() = arg;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn Length(&self) -> u32 {
|
||||
self.data.len() as u32
|
||||
self.data.deref().borrow().len() as u32
|
||||
}
|
||||
|
||||
fn SubstringData(&self, offset: u32, count: u32) -> Fallible<DOMString> {
|
||||
Ok(self.data.as_slice().slice(offset as uint, count as uint).to_str())
|
||||
Ok(self.data.deref().borrow().as_slice().slice(offset as uint, count as uint).to_string())
|
||||
}
|
||||
|
||||
fn AppendData(&mut self, arg: DOMString) -> ErrorResult {
|
||||
self.data.push_str(arg.as_slice());
|
||||
fn AppendData(&self, arg: DOMString) -> ErrorResult {
|
||||
self.data.deref().borrow_mut().push_str(arg.as_slice());
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn InsertData(&mut self, offset: u32, arg: DOMString) -> ErrorResult {
|
||||
fn InsertData(&self, offset: u32, arg: DOMString) -> ErrorResult {
|
||||
self.ReplaceData(offset, 0, arg)
|
||||
}
|
||||
|
||||
fn DeleteData(&mut self, offset: u32, count: u32) -> ErrorResult {
|
||||
fn DeleteData(&self, offset: u32, count: u32) -> ErrorResult {
|
||||
self.ReplaceData(offset, count, "".to_string())
|
||||
}
|
||||
|
||||
fn ReplaceData(&mut self, offset: u32, count: u32, arg: DOMString) -> ErrorResult {
|
||||
let length = self.data.len() as u32;
|
||||
fn ReplaceData(&self, offset: u32, count: u32, arg: DOMString) -> ErrorResult {
|
||||
let length = self.data.deref().borrow().len() as u32;
|
||||
if offset > length {
|
||||
return Err(IndexSize);
|
||||
}
|
||||
|
@ -92,10 +95,10 @@ impl<'a> CharacterDataMethods for JSRef<'a, CharacterData> {
|
|||
} else {
|
||||
count
|
||||
};
|
||||
let mut data = self.data.as_slice().slice(0, offset as uint).to_string();
|
||||
let mut data = self.data.deref().borrow().as_slice().slice(0, offset as uint).to_string();
|
||||
data.push_str(arg.as_slice());
|
||||
data.push_str(self.data.as_slice().slice((offset + count) as uint, length as uint));
|
||||
self.data = data.into_owned();
|
||||
data.push_str(self.data.deref().borrow().as_slice().slice((offset + count) as uint, length as uint));
|
||||
*self.data.deref().borrow_mut() = data.into_owned();
|
||||
// FIXME: Once we have `Range`, we should implement step7 to step11
|
||||
Ok(())
|
||||
}
|
||||
|
|
|
@ -14,10 +14,12 @@ use js::jsapi::JSContext;
|
|||
use js::jsval::{JSVal, NullValue};
|
||||
use servo_util::str::DOMString;
|
||||
|
||||
use std::cell::Cell;
|
||||
|
||||
#[deriving(Encodable)]
|
||||
pub struct CustomEvent {
|
||||
event: Event,
|
||||
detail: Traceable<JSVal>
|
||||
detail: Traceable<Cell<Traceable<JSVal>>>,
|
||||
}
|
||||
|
||||
impl CustomEventDerived for Event {
|
||||
|
@ -28,7 +30,7 @@ impl CustomEventDerived for Event {
|
|||
|
||||
pub trait CustomEventMethods {
|
||||
fn Detail(&self, _cx: *mut JSContext) -> JSVal;
|
||||
fn InitCustomEvent(&mut self, _cx: *mut JSContext,
|
||||
fn InitCustomEvent(&self, _cx: *mut JSContext,
|
||||
type_: DOMString, can_bubble: bool,
|
||||
cancelable: bool, detail: JSVal);
|
||||
}
|
||||
|
@ -37,7 +39,7 @@ impl CustomEvent {
|
|||
pub fn new_inherited(type_id: EventTypeId) -> CustomEvent {
|
||||
CustomEvent {
|
||||
event: Event::new_inherited(type_id),
|
||||
detail: Traceable::new(NullValue())
|
||||
detail: Traceable::new(Cell::new(Traceable::new(NullValue()))),
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -47,8 +49,8 @@ impl CustomEvent {
|
|||
CustomEventBinding::Wrap)
|
||||
}
|
||||
pub fn new(window: &JSRef<Window>, type_: DOMString, bubbles: bool, cancelable: bool, detail: JSVal) -> Temporary<CustomEvent> {
|
||||
let mut ev = CustomEvent::new_uninitialized(window).root();
|
||||
ev.InitCustomEvent(window.deref().get_cx(), type_, bubbles, cancelable, detail);
|
||||
let ev = CustomEvent::new_uninitialized(window).root();
|
||||
ev.deref().InitCustomEvent(window.deref().get_cx(), type_, bubbles, cancelable, detail);
|
||||
Temporary::from_rooted(&*ev)
|
||||
}
|
||||
pub fn Constructor(owner: &JSRef<Window>,
|
||||
|
@ -60,17 +62,17 @@ impl CustomEvent {
|
|||
|
||||
impl<'a> CustomEventMethods for JSRef<'a, CustomEvent> {
|
||||
fn Detail(&self, _cx: *mut JSContext) -> JSVal {
|
||||
self.detail.deref().clone()
|
||||
*self.detail.deref().get()
|
||||
}
|
||||
|
||||
fn InitCustomEvent(&mut self,
|
||||
_cx: *mut JSContext,
|
||||
fn InitCustomEvent(&self,
|
||||
_cx: *mut JSContext,
|
||||
type_: DOMString,
|
||||
can_bubble: bool,
|
||||
cancelable: bool,
|
||||
detail: JSVal) {
|
||||
self.detail = Traceable::new(detail);
|
||||
let event: &mut JSRef<Event> = EventCast::from_mut_ref(self);
|
||||
self.detail.deref().set(Traceable::new(detail));
|
||||
let event: &JSRef<Event> = EventCast::from_ref(self);
|
||||
event.InitEvent(type_, can_bubble, cancelable);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -49,7 +49,7 @@ use servo_util::str::{DOMString, null_str_as_empty_ref};
|
|||
use collections::hashmap::HashMap;
|
||||
use js::jsapi::JSContext;
|
||||
use std::ascii::StrAsciiExt;
|
||||
use std::cell::Cell;
|
||||
use std::cell::{Cell, RefCell};
|
||||
use url::{Url, from_str};
|
||||
|
||||
#[deriving(Eq,Encodable)]
|
||||
|
@ -66,10 +66,10 @@ pub struct Document {
|
|||
pub idmap: HashMap<DOMString, Vec<JS<Element>>>,
|
||||
pub implementation: Cell<Option<JS<DOMImplementation>>>,
|
||||
pub content_type: DOMString,
|
||||
pub encoding_name: DOMString,
|
||||
pub encoding_name: Untraceable<RefCell<DOMString>>,
|
||||
pub is_html_document: bool,
|
||||
pub url: Untraceable<Url>,
|
||||
pub quirks_mode: Untraceable<QuirksMode>,
|
||||
pub quirks_mode: Untraceable<Cell<QuirksMode>>,
|
||||
}
|
||||
|
||||
impl DocumentDerived for EventTarget {
|
||||
|
@ -81,8 +81,8 @@ impl DocumentDerived for EventTarget {
|
|||
pub trait DocumentHelpers {
|
||||
fn url<'a>(&'a self) -> &'a Url;
|
||||
fn quirks_mode(&self) -> QuirksMode;
|
||||
fn set_quirks_mode(&mut self, mode: QuirksMode);
|
||||
fn set_encoding_name(&mut self, name: DOMString);
|
||||
fn set_quirks_mode(&self, mode: QuirksMode);
|
||||
fn set_encoding_name(&self, name: DOMString);
|
||||
fn content_changed(&self);
|
||||
fn damage_and_reflow(&self, damage: DocumentDamageLevel);
|
||||
fn wait_until_safe_to_modify_dom(&self);
|
||||
|
@ -97,15 +97,15 @@ impl<'a> DocumentHelpers for JSRef<'a, Document> {
|
|||
}
|
||||
|
||||
fn quirks_mode(&self) -> QuirksMode {
|
||||
*self.quirks_mode
|
||||
self.quirks_mode.deref().get()
|
||||
}
|
||||
|
||||
fn set_quirks_mode(&mut self, mode: QuirksMode) {
|
||||
*self.quirks_mode = mode;
|
||||
fn set_quirks_mode(&self, mode: QuirksMode) {
|
||||
self.quirks_mode.deref().set(mode);
|
||||
}
|
||||
|
||||
fn set_encoding_name(&mut self, name: DOMString) {
|
||||
self.encoding_name = name;
|
||||
fn set_encoding_name(&self, name: DOMString) {
|
||||
*self.encoding_name.deref().borrow_mut() = name;
|
||||
}
|
||||
|
||||
fn content_changed(&self) {
|
||||
|
@ -227,9 +227,9 @@ impl Document {
|
|||
},
|
||||
url: Untraceable::new(url),
|
||||
// http://dom.spec.whatwg.org/#concept-document-quirks
|
||||
quirks_mode: Untraceable::new(NoQuirks),
|
||||
quirks_mode: Untraceable::new(Cell::new(NoQuirks)),
|
||||
// http://dom.spec.whatwg.org/#concept-document-encoding
|
||||
encoding_name: "utf-8".to_string(),
|
||||
encoding_name: Untraceable::new(RefCell::new("utf-8".to_string())),
|
||||
is_html_document: is_html_document == HTMLDocument,
|
||||
}
|
||||
}
|
||||
|
@ -331,9 +331,9 @@ pub trait DocumentMethods {
|
|||
fn Children(&self) -> Temporary<HTMLCollection>;
|
||||
fn QuerySelector(&self, selectors: DOMString) -> Fallible<Option<Temporary<Element>>>;
|
||||
fn GetOnclick(&self) -> Option<EventHandlerNonNull>;
|
||||
fn SetOnclick(&mut self, listener: Option<EventHandlerNonNull>);
|
||||
fn SetOnclick(&self, listener: Option<EventHandlerNonNull>);
|
||||
fn GetOnload(&self) -> Option<EventHandlerNonNull>;
|
||||
fn SetOnload(&mut self, listener: Option<EventHandlerNonNull>);
|
||||
fn SetOnload(&self, listener: Option<EventHandlerNonNull>);
|
||||
}
|
||||
|
||||
impl<'a> DocumentMethods for JSRef<'a, Document> {
|
||||
|
@ -358,7 +358,7 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
|
|||
|
||||
// http://dom.spec.whatwg.org/#dom-document-compatmode
|
||||
fn CompatMode(&self) -> DOMString {
|
||||
match *self.quirks_mode {
|
||||
match self.quirks_mode.deref().get() {
|
||||
NoQuirks => "CSS1Compat".to_string(),
|
||||
LimitedQuirks | FullQuirks => "BackCompat".to_string()
|
||||
}
|
||||
|
@ -366,7 +366,7 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
|
|||
|
||||
// http://dom.spec.whatwg.org/#dom-document-characterset
|
||||
fn CharacterSet(&self) -> DOMString {
|
||||
self.encoding_name.as_slice().to_ascii_lower()
|
||||
self.encoding_name.deref().borrow().as_slice().to_ascii_lower()
|
||||
}
|
||||
|
||||
// http://dom.spec.whatwg.org/#dom-document-content_type
|
||||
|
@ -430,7 +430,7 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
|
|||
return Err(InvalidCharacter);
|
||||
}
|
||||
let local_name = local_name.as_slice().to_ascii_lower();
|
||||
Ok(build_element_from_tag(local_name, self))
|
||||
Ok(build_element_from_tag(local_name, namespace::HTML, self))
|
||||
}
|
||||
|
||||
// http://dom.spec.whatwg.org/#dom-document-createelementns
|
||||
|
@ -473,7 +473,7 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
|
|||
}
|
||||
|
||||
if ns == namespace::HTML {
|
||||
Ok(build_element_from_tag(local_name_from_qname, self))
|
||||
Ok(build_element_from_tag(local_name_from_qname, ns, self))
|
||||
} else {
|
||||
Ok(Element::new(local_name_from_qname, ns, prefix_from_qname, self))
|
||||
}
|
||||
|
@ -567,7 +567,7 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
|
|||
for child in title_elem.children() {
|
||||
if child.is_text() {
|
||||
let text: &JSRef<Text> = TextCast::to_ref(&child).unwrap();
|
||||
title.push_str(text.deref().characterdata.data.as_slice());
|
||||
title.push_str(text.deref().characterdata.data.deref().borrow().as_slice());
|
||||
}
|
||||
}
|
||||
});
|
||||
|
@ -826,8 +826,8 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
|
|||
eventtarget.get_event_handler_common("click")
|
||||
}
|
||||
|
||||
fn SetOnclick(&mut self, listener: Option<EventHandlerNonNull>) {
|
||||
let eventtarget: &mut JSRef<EventTarget> = EventTargetCast::from_mut_ref(self);
|
||||
fn SetOnclick(&self, listener: Option<EventHandlerNonNull>) {
|
||||
let eventtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
|
||||
eventtarget.set_event_handler_common("click", listener)
|
||||
}
|
||||
|
||||
|
@ -836,8 +836,8 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
|
|||
eventtarget.get_event_handler_common("load")
|
||||
}
|
||||
|
||||
fn SetOnload(&mut self, listener: Option<EventHandlerNonNull>) {
|
||||
let eventtarget: &mut JSRef<EventTarget> = EventTargetCast::from_mut_ref(self);
|
||||
fn SetOnload(&self, listener: Option<EventHandlerNonNull>) {
|
||||
let eventtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
|
||||
eventtarget.set_event_handler_common("load", listener)
|
||||
}
|
||||
}
|
||||
|
|
|
@ -4,14 +4,15 @@
|
|||
|
||||
use dom::bindings::codegen::Bindings::EventBinding;
|
||||
use dom::bindings::codegen::Bindings::EventBinding::EventConstants;
|
||||
use dom::bindings::js::{JS, JSRef, Temporary};
|
||||
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
|
||||
use dom::bindings::error::Fallible;
|
||||
use dom::bindings::js::{JS, JSRef, Temporary};
|
||||
use dom::bindings::trace::Untraceable;
|
||||
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
|
||||
use dom::eventtarget::EventTarget;
|
||||
use dom::window::Window;
|
||||
use servo_util::str::DOMString;
|
||||
use servo_util::geometry::PagePx;
|
||||
use std::cell::Cell;
|
||||
use std::cell::{Cell, RefCell};
|
||||
|
||||
use geom::point::Point2D;
|
||||
use geom::size::TypedSize2D;
|
||||
|
@ -51,16 +52,16 @@ pub struct Event {
|
|||
pub reflector_: Reflector,
|
||||
pub current_target: Cell<Option<JS<EventTarget>>>,
|
||||
pub target: Cell<Option<JS<EventTarget>>>,
|
||||
pub type_: DOMString,
|
||||
pub phase: EventPhase,
|
||||
pub canceled: bool,
|
||||
pub stop_propagation: bool,
|
||||
pub stop_immediate: bool,
|
||||
pub cancelable: bool,
|
||||
pub bubbles: bool,
|
||||
pub trusted: bool,
|
||||
pub dispatching: bool,
|
||||
pub initialized: bool,
|
||||
type_: Untraceable<RefCell<DOMString>>,
|
||||
pub phase: Untraceable<Cell<EventPhase>>,
|
||||
pub canceled: Untraceable<Cell<bool>>,
|
||||
pub stop_propagation: Untraceable<Cell<bool>>,
|
||||
pub stop_immediate: Untraceable<Cell<bool>>,
|
||||
pub cancelable: Untraceable<Cell<bool>>,
|
||||
pub bubbles: Untraceable<Cell<bool>>,
|
||||
pub trusted: Untraceable<Cell<bool>>,
|
||||
pub dispatching: Untraceable<Cell<bool>>,
|
||||
pub initialized: Untraceable<Cell<bool>>,
|
||||
pub timestamp: u64,
|
||||
}
|
||||
|
||||
|
@ -71,16 +72,16 @@ impl Event {
|
|||
reflector_: Reflector::new(),
|
||||
current_target: Cell::new(None),
|
||||
target: Cell::new(None),
|
||||
phase: PhaseNone,
|
||||
type_: "".to_string(),
|
||||
canceled: false,
|
||||
cancelable: true,
|
||||
bubbles: false,
|
||||
trusted: false,
|
||||
dispatching: false,
|
||||
stop_propagation: false,
|
||||
stop_immediate: false,
|
||||
initialized: false,
|
||||
phase: Untraceable::new(Cell::new(PhaseNone)),
|
||||
type_: Untraceable::new(RefCell::new("".to_string())),
|
||||
canceled: Untraceable::new(Cell::new(false)),
|
||||
cancelable: Untraceable::new(Cell::new(true)),
|
||||
bubbles: Untraceable::new(Cell::new(false)),
|
||||
trusted: Untraceable::new(Cell::new(false)),
|
||||
dispatching: Untraceable::new(Cell::new(false)),
|
||||
stop_propagation: Untraceable::new(Cell::new(false)),
|
||||
stop_immediate: Untraceable::new(Cell::new(false)),
|
||||
initialized: Untraceable::new(Cell::new(false)),
|
||||
timestamp: time::get_time().sec as u64,
|
||||
}
|
||||
}
|
||||
|
@ -95,8 +96,8 @@ impl Event {
|
|||
type_: DOMString,
|
||||
can_bubble: bool,
|
||||
cancelable: bool) -> Temporary<Event> {
|
||||
let mut event = Event::new_uninitialized(window).root();
|
||||
event.InitEvent(type_, can_bubble, cancelable);
|
||||
let event = Event::new_uninitialized(window).root();
|
||||
event.deref().InitEvent(type_, can_bubble, cancelable);
|
||||
Temporary::from_rooted(&*event)
|
||||
}
|
||||
|
||||
|
@ -113,23 +114,23 @@ pub trait EventMethods {
|
|||
fn GetTarget(&self) -> Option<Temporary<EventTarget>>;
|
||||
fn GetCurrentTarget(&self) -> Option<Temporary<EventTarget>>;
|
||||
fn DefaultPrevented(&self) -> bool;
|
||||
fn PreventDefault(&mut self);
|
||||
fn StopPropagation(&mut self);
|
||||
fn StopImmediatePropagation(&mut self);
|
||||
fn PreventDefault(&self);
|
||||
fn StopPropagation(&self);
|
||||
fn StopImmediatePropagation(&self);
|
||||
fn Bubbles(&self) -> bool;
|
||||
fn Cancelable(&self) -> bool;
|
||||
fn TimeStamp(&self) -> u64;
|
||||
fn InitEvent(&mut self, type_: DOMString, bubbles: bool, cancelable: bool);
|
||||
fn InitEvent(&self, type_: DOMString, bubbles: bool, cancelable: bool);
|
||||
fn IsTrusted(&self) -> bool;
|
||||
}
|
||||
|
||||
impl<'a> EventMethods for JSRef<'a, Event> {
|
||||
fn EventPhase(&self) -> u16 {
|
||||
self.phase as u16
|
||||
self.phase.deref().get() as u16
|
||||
}
|
||||
|
||||
fn Type(&self) -> DOMString {
|
||||
self.type_.clone()
|
||||
self.type_.deref().borrow().clone()
|
||||
}
|
||||
|
||||
fn GetTarget(&self) -> Option<Temporary<EventTarget>> {
|
||||
|
@ -141,56 +142,56 @@ impl<'a> EventMethods for JSRef<'a, Event> {
|
|||
}
|
||||
|
||||
fn DefaultPrevented(&self) -> bool {
|
||||
self.canceled
|
||||
self.canceled.deref().get()
|
||||
}
|
||||
|
||||
fn PreventDefault(&mut self) {
|
||||
if self.cancelable {
|
||||
self.canceled = true
|
||||
fn PreventDefault(&self) {
|
||||
if self.cancelable.deref().get() {
|
||||
self.canceled.deref().set(true)
|
||||
}
|
||||
}
|
||||
|
||||
fn StopPropagation(&mut self) {
|
||||
self.stop_propagation = true;
|
||||
fn StopPropagation(&self) {
|
||||
self.stop_propagation.deref().set(true);
|
||||
}
|
||||
|
||||
fn StopImmediatePropagation(&mut self) {
|
||||
self.stop_immediate = true;
|
||||
self.stop_propagation = true;
|
||||
fn StopImmediatePropagation(&self) {
|
||||
self.stop_immediate.deref().set(true);
|
||||
self.stop_propagation.deref().set(true);
|
||||
}
|
||||
|
||||
fn Bubbles(&self) -> bool {
|
||||
self.bubbles
|
||||
self.bubbles.deref().get()
|
||||
}
|
||||
|
||||
fn Cancelable(&self) -> bool {
|
||||
self.cancelable
|
||||
self.cancelable.deref().get()
|
||||
}
|
||||
|
||||
fn TimeStamp(&self) -> u64 {
|
||||
self.timestamp
|
||||
}
|
||||
|
||||
fn InitEvent(&mut self,
|
||||
fn InitEvent(&self,
|
||||
type_: DOMString,
|
||||
bubbles: bool,
|
||||
cancelable: bool) {
|
||||
self.initialized = true;
|
||||
if self.dispatching {
|
||||
self.initialized.deref().set(true);
|
||||
if self.dispatching.deref().get() {
|
||||
return;
|
||||
}
|
||||
self.stop_propagation = false;
|
||||
self.stop_immediate = false;
|
||||
self.canceled = false;
|
||||
self.trusted = false;
|
||||
self.stop_propagation.deref().set(false);
|
||||
self.stop_immediate.deref().set(false);
|
||||
self.canceled.deref().set(false);
|
||||
self.trusted.deref().set(false);
|
||||
self.target.set(None);
|
||||
self.type_ = type_;
|
||||
self.bubbles = bubbles;
|
||||
self.cancelable = cancelable;
|
||||
*self.type_.deref().borrow_mut() = type_;
|
||||
self.bubbles.deref().set(bubbles);
|
||||
self.cancelable.deref().set(cancelable);
|
||||
}
|
||||
|
||||
fn IsTrusted(&self) -> bool {
|
||||
self.trusted
|
||||
self.trusted.deref().get()
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -13,19 +13,16 @@ use dom::virtualmethods::vtable_for;
|
|||
// See http://dom.spec.whatwg.org/#concept-event-dispatch for the full dispatch algorithm
|
||||
pub fn dispatch_event<'a, 'b>(target: &JSRef<'a, EventTarget>,
|
||||
pseudo_target: Option<JSRef<'b, EventTarget>>,
|
||||
event: &mut JSRef<Event>) -> bool {
|
||||
assert!(!event.deref().dispatching);
|
||||
event: &JSRef<Event>) -> bool {
|
||||
assert!(!event.deref().dispatching.deref().get());
|
||||
|
||||
{
|
||||
let event = event.deref_mut();
|
||||
event.target.assign(Some(match pseudo_target {
|
||||
Some(pseudo_target) => pseudo_target,
|
||||
None => target.clone(),
|
||||
}));
|
||||
event.dispatching = true;
|
||||
}
|
||||
event.target.assign(Some(match pseudo_target {
|
||||
Some(pseudo_target) => pseudo_target,
|
||||
None => target.clone(),
|
||||
}));
|
||||
event.dispatching.deref().set(true);
|
||||
|
||||
let type_ = event.deref().type_.clone();
|
||||
let type_ = event.Type();
|
||||
|
||||
//TODO: no chain if not participating in a tree
|
||||
let mut chain: Vec<Root<EventTarget>> = if target.deref().is_node() {
|
||||
|
@ -38,7 +35,7 @@ pub fn dispatch_event<'a, 'b>(target: &JSRef<'a, EventTarget>,
|
|||
vec!()
|
||||
};
|
||||
|
||||
event.deref_mut().phase = PhaseCapturing;
|
||||
event.deref().phase.deref().set(PhaseCapturing);
|
||||
|
||||
//FIXME: The "callback this value" should be currentTarget
|
||||
|
||||
|
@ -51,12 +48,12 @@ pub fn dispatch_event<'a, 'b>(target: &JSRef<'a, EventTarget>,
|
|||
// Explicitly drop any exception on the floor.
|
||||
let _ = listener.HandleEvent_(&**cur_target, event, ReportExceptions);
|
||||
|
||||
if event.deref().stop_immediate {
|
||||
if event.deref().stop_immediate.deref().get() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
event.deref().stop_propagation
|
||||
event.deref().stop_propagation.deref().get()
|
||||
}
|
||||
None => false
|
||||
};
|
||||
|
@ -67,12 +64,9 @@ pub fn dispatch_event<'a, 'b>(target: &JSRef<'a, EventTarget>,
|
|||
}
|
||||
|
||||
/* at target */
|
||||
if !event.deref().stop_propagation {
|
||||
{
|
||||
let event = event.deref_mut();
|
||||
event.phase = PhaseAtTarget;
|
||||
event.current_target.assign(Some(target.clone()));
|
||||
}
|
||||
if !event.deref().stop_propagation.deref().get() {
|
||||
event.phase.deref().set(PhaseAtTarget);
|
||||
event.current_target.assign(Some(target.clone()));
|
||||
|
||||
let opt_listeners = target.deref().get_listeners(type_.as_slice());
|
||||
for listeners in opt_listeners.iter() {
|
||||
|
@ -80,7 +74,7 @@ pub fn dispatch_event<'a, 'b>(target: &JSRef<'a, EventTarget>,
|
|||
// Explicitly drop any exception on the floor.
|
||||
let _ = listener.HandleEvent_(target, event, ReportExceptions);
|
||||
|
||||
if event.deref().stop_immediate {
|
||||
if event.deref().stop_immediate.deref().get() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
@ -88,23 +82,23 @@ pub fn dispatch_event<'a, 'b>(target: &JSRef<'a, EventTarget>,
|
|||
}
|
||||
|
||||
/* bubbling */
|
||||
if event.deref().bubbles && !event.deref().stop_propagation {
|
||||
event.deref_mut().phase = PhaseBubbling;
|
||||
if event.deref().bubbles.deref().get() && !event.deref().stop_propagation.deref().get() {
|
||||
event.deref().phase.deref().set(PhaseBubbling);
|
||||
|
||||
for cur_target in chain.iter() {
|
||||
let stopped = match cur_target.deref().get_listeners_for(type_.as_slice(), Bubbling) {
|
||||
Some(listeners) => {
|
||||
event.deref_mut().current_target.assign(Some(cur_target.deref().clone()));
|
||||
event.deref().current_target.assign(Some(cur_target.deref().clone()));
|
||||
for listener in listeners.iter() {
|
||||
// Explicitly drop any exception on the floor.
|
||||
let _ = listener.HandleEvent_(&**cur_target, event, ReportExceptions);
|
||||
|
||||
if event.deref().stop_immediate {
|
||||
if event.deref().stop_immediate.deref().get() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
event.deref().stop_propagation
|
||||
event.deref().stop_propagation.deref().get()
|
||||
}
|
||||
None => false
|
||||
};
|
||||
|
@ -136,8 +130,8 @@ pub fn dispatch_event<'a, 'b>(target: &JSRef<'a, EventTarget>,
|
|||
let _ = chain.pop();
|
||||
}
|
||||
|
||||
event.dispatching = false;
|
||||
event.phase = PhaseNone;
|
||||
event.dispatching.deref().set(false);
|
||||
event.phase.deref().set(PhaseNone);
|
||||
event.current_target.set(None);
|
||||
|
||||
!event.DefaultPrevented()
|
||||
|
|
|
@ -7,6 +7,7 @@ use dom::bindings::codegen::Bindings::EventHandlerBinding::EventHandlerNonNull;
|
|||
use dom::bindings::codegen::Bindings::EventListenerBinding::EventListener;
|
||||
use dom::bindings::error::{Fallible, InvalidState};
|
||||
use dom::bindings::js::JSRef;
|
||||
use dom::bindings::trace::Traceable;
|
||||
use dom::bindings::utils::{Reflectable, Reflector};
|
||||
use dom::event::Event;
|
||||
use dom::eventdispatcher::dispatch_event;
|
||||
|
@ -17,6 +18,7 @@ use js::jsapi::{JS_CompileUCFunction, JS_GetFunctionObject, JS_CloneFunctionObje
|
|||
use js::jsapi::{JSContext, JSObject};
|
||||
use servo_util::str::DOMString;
|
||||
use libc::{c_char, size_t};
|
||||
use std::cell::RefCell;
|
||||
use std::ptr;
|
||||
use url::Url;
|
||||
|
||||
|
@ -59,7 +61,7 @@ pub struct EventListenerEntry {
|
|||
pub struct EventTarget {
|
||||
pub type_id: EventTargetTypeId,
|
||||
pub reflector_: Reflector,
|
||||
pub handlers: HashMap<DOMString, Vec<EventListenerEntry>>,
|
||||
handlers: Traceable<RefCell<HashMap<DOMString, Vec<EventListenerEntry>>>>,
|
||||
}
|
||||
|
||||
impl EventTarget {
|
||||
|
@ -67,19 +69,19 @@ impl EventTarget {
|
|||
EventTarget {
|
||||
type_id: type_id,
|
||||
reflector_: Reflector::new(),
|
||||
handlers: HashMap::new(),
|
||||
handlers: Traceable::new(RefCell::new(HashMap::new())),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn get_listeners(&self, type_: &str) -> Option<Vec<EventListener>> {
|
||||
self.handlers.find_equiv(&type_).map(|listeners| {
|
||||
self.handlers.deref().borrow().find_equiv(&type_).map(|listeners| {
|
||||
listeners.iter().map(|entry| entry.listener.get_listener()).collect()
|
||||
})
|
||||
}
|
||||
|
||||
pub fn get_listeners_for(&self, type_: &str, desired_phase: ListenerPhase)
|
||||
-> Option<Vec<EventListener>> {
|
||||
self.handlers.find_equiv(&type_).map(|listeners| {
|
||||
self.handlers.deref().borrow().find_equiv(&type_).map(|listeners| {
|
||||
let filtered = listeners.iter().filter(|entry| entry.phase == desired_phase);
|
||||
filtered.map(|entry| entry.listener.get_listener()).collect()
|
||||
})
|
||||
|
@ -89,36 +91,39 @@ impl EventTarget {
|
|||
pub trait EventTargetHelpers {
|
||||
fn dispatch_event_with_target<'a>(&self,
|
||||
target: Option<JSRef<'a, EventTarget>>,
|
||||
event: &mut JSRef<Event>) -> Fallible<bool>;
|
||||
fn set_inline_event_listener(&mut self,
|
||||
event: &JSRef<Event>) -> Fallible<bool>;
|
||||
fn set_inline_event_listener(&self,
|
||||
ty: DOMString,
|
||||
listener: Option<EventListener>);
|
||||
fn get_inline_event_listener(&self, ty: DOMString) -> Option<EventListener>;
|
||||
fn set_event_handler_uncompiled(&mut self,
|
||||
fn set_event_handler_uncompiled(&self,
|
||||
cx: *mut JSContext,
|
||||
url: Url,
|
||||
scope: *mut JSObject,
|
||||
ty: &str,
|
||||
source: DOMString);
|
||||
fn set_event_handler_common<T: CallbackContainer>(&mut self, ty: &str,
|
||||
fn set_event_handler_common<T: CallbackContainer>(&self, ty: &str,
|
||||
listener: Option<T>);
|
||||
fn get_event_handler_common<T: CallbackContainer>(&self, ty: &str) -> Option<T>;
|
||||
|
||||
fn has_handlers(&self) -> bool;
|
||||
}
|
||||
|
||||
impl<'a> EventTargetHelpers for JSRef<'a, EventTarget> {
|
||||
fn dispatch_event_with_target<'b>(&self,
|
||||
target: Option<JSRef<'b, EventTarget>>,
|
||||
event: &mut JSRef<Event>) -> Fallible<bool> {
|
||||
if event.deref().dispatching || !event.deref().initialized {
|
||||
event: &JSRef<Event>) -> Fallible<bool> {
|
||||
if event.deref().dispatching.deref().get() || !event.deref().initialized.deref().get() {
|
||||
return Err(InvalidState);
|
||||
}
|
||||
Ok(dispatch_event(self, target, event))
|
||||
}
|
||||
|
||||
fn set_inline_event_listener(&mut self,
|
||||
fn set_inline_event_listener(&self,
|
||||
ty: DOMString,
|
||||
listener: Option<EventListener>) {
|
||||
let entries = self.handlers.find_or_insert_with(ty, |_| vec!());
|
||||
let mut handlers = self.handlers.deref().borrow_mut();
|
||||
let entries = handlers.find_or_insert_with(ty, |_| vec!());
|
||||
let idx = entries.iter().position(|&entry| {
|
||||
match entry.listener {
|
||||
Inline(_) => true,
|
||||
|
@ -147,7 +152,8 @@ impl<'a> EventTargetHelpers for JSRef<'a, EventTarget> {
|
|||
}
|
||||
|
||||
fn get_inline_event_listener(&self, ty: DOMString) -> Option<EventListener> {
|
||||
let entries = self.handlers.find(&ty);
|
||||
let handlers = self.handlers.deref().borrow();
|
||||
let entries = handlers.find(&ty);
|
||||
entries.and_then(|entries| entries.iter().find(|entry| {
|
||||
match entry.listener {
|
||||
Inline(_) => true,
|
||||
|
@ -156,7 +162,7 @@ impl<'a> EventTargetHelpers for JSRef<'a, EventTarget> {
|
|||
}).map(|entry| entry.listener.get_listener()))
|
||||
}
|
||||
|
||||
fn set_event_handler_uncompiled(&mut self,
|
||||
fn set_event_handler_uncompiled(&self,
|
||||
cx: *mut JSContext,
|
||||
url: Url,
|
||||
scope: *mut JSObject,
|
||||
|
@ -188,7 +194,7 @@ impl<'a> EventTargetHelpers for JSRef<'a, EventTarget> {
|
|||
}
|
||||
|
||||
fn set_event_handler_common<T: CallbackContainer>(
|
||||
&mut self, ty: &str, listener: Option<T>)
|
||||
&self, ty: &str, listener: Option<T>)
|
||||
{
|
||||
let event_listener = listener.map(|listener|
|
||||
EventListener::new(listener.callback()));
|
||||
|
@ -199,59 +205,71 @@ impl<'a> EventTargetHelpers for JSRef<'a, EventTarget> {
|
|||
let listener = self.get_inline_event_listener(ty.to_string());
|
||||
listener.map(|listener| CallbackContainer::new(listener.parent.callback()))
|
||||
}
|
||||
|
||||
fn has_handlers(&self) -> bool {
|
||||
!self.handlers.deref().borrow().is_empty()
|
||||
}
|
||||
}
|
||||
|
||||
pub trait EventTargetMethods {
|
||||
fn AddEventListener(&mut self,
|
||||
fn AddEventListener(&self,
|
||||
ty: DOMString,
|
||||
listener: Option<EventListener>,
|
||||
capture: bool);
|
||||
fn RemoveEventListener(&mut self,
|
||||
fn RemoveEventListener(&self,
|
||||
ty: DOMString,
|
||||
listener: Option<EventListener>,
|
||||
capture: bool);
|
||||
fn DispatchEvent(&self, event: &mut JSRef<Event>) -> Fallible<bool>;
|
||||
fn DispatchEvent(&self, event: &JSRef<Event>) -> Fallible<bool>;
|
||||
}
|
||||
|
||||
impl<'a> EventTargetMethods for JSRef<'a, EventTarget> {
|
||||
fn AddEventListener(&mut self,
|
||||
fn AddEventListener(&self,
|
||||
ty: DOMString,
|
||||
listener: Option<EventListener>,
|
||||
capture: bool) {
|
||||
for &listener in listener.iter() {
|
||||
let entry = self.handlers.find_or_insert_with(ty.clone(), |_| vec!());
|
||||
let phase = if capture { Capturing } else { Bubbling };
|
||||
let new_entry = EventListenerEntry {
|
||||
phase: phase,
|
||||
listener: Additive(listener)
|
||||
};
|
||||
if entry.as_slice().position_elem(&new_entry).is_none() {
|
||||
entry.push(new_entry);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn RemoveEventListener(&mut self,
|
||||
ty: DOMString,
|
||||
listener: Option<EventListener>,
|
||||
capture: bool) {
|
||||
for &listener in listener.iter() {
|
||||
let mut entry = self.handlers.find_mut(&ty);
|
||||
for entry in entry.mut_iter() {
|
||||
match listener {
|
||||
Some(listener) => {
|
||||
let mut handlers = self.handlers.deref().borrow_mut();
|
||||
let entry = handlers.find_or_insert_with(ty, |_| vec!());
|
||||
let phase = if capture { Capturing } else { Bubbling };
|
||||
let old_entry = EventListenerEntry {
|
||||
let new_entry = EventListenerEntry {
|
||||
phase: phase,
|
||||
listener: Additive(listener)
|
||||
};
|
||||
let position = entry.as_slice().position_elem(&old_entry);
|
||||
for &position in position.iter() {
|
||||
entry.remove(position);
|
||||
if entry.as_slice().position_elem(&new_entry).is_none() {
|
||||
entry.push(new_entry);
|
||||
}
|
||||
}
|
||||
},
|
||||
_ => (),
|
||||
}
|
||||
}
|
||||
|
||||
fn DispatchEvent(&self, event: &mut JSRef<Event>) -> Fallible<bool> {
|
||||
fn RemoveEventListener(&self,
|
||||
ty: DOMString,
|
||||
listener: Option<EventListener>,
|
||||
capture: bool) {
|
||||
match listener {
|
||||
Some(listener) => {
|
||||
let mut handlers = self.handlers.deref().borrow_mut();
|
||||
let mut entry = handlers.find_mut(&ty);
|
||||
for entry in entry.mut_iter() {
|
||||
let phase = if capture { Capturing } else { Bubbling };
|
||||
let old_entry = EventListenerEntry {
|
||||
phase: phase,
|
||||
listener: Additive(listener)
|
||||
};
|
||||
let position = entry.as_slice().position_elem(&old_entry);
|
||||
for &position in position.iter() {
|
||||
entry.remove(position);
|
||||
}
|
||||
}
|
||||
},
|
||||
_ => (),
|
||||
}
|
||||
}
|
||||
|
||||
fn DispatchEvent(&self, event: &JSRef<Event>) -> Fallible<bool> {
|
||||
self.dispatch_event_with_target(None, event)
|
||||
}
|
||||
}
|
||||
|
|
|
@ -2,15 +2,17 @@
|
|||
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
||||
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
||||
|
||||
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
|
||||
use dom::bindings::error::{Fallible};
|
||||
use dom::bindings::codegen::Bindings::FormDataBinding;
|
||||
use dom::bindings::error::{Fallible};
|
||||
use dom::bindings::js::{JS, JSRef, Temporary, OptionalUnrootable};
|
||||
use dom::bindings::trace::Traceable;
|
||||
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
|
||||
use dom::blob::Blob;
|
||||
use dom::htmlformelement::HTMLFormElement;
|
||||
use dom::window::Window;
|
||||
use servo_util::str::DOMString;
|
||||
use collections::hashmap::HashMap;
|
||||
use std::cell::RefCell;
|
||||
|
||||
#[deriving(Encodable)]
|
||||
pub enum FormDatum {
|
||||
|
@ -20,7 +22,7 @@ pub enum FormDatum {
|
|||
|
||||
#[deriving(Encodable)]
|
||||
pub struct FormData {
|
||||
pub data: HashMap<DOMString, FormDatum>,
|
||||
pub data: Traceable<RefCell<HashMap<DOMString, FormDatum>>>,
|
||||
pub reflector_: Reflector,
|
||||
pub window: JS<Window>,
|
||||
pub form: Option<JS<HTMLFormElement>>
|
||||
|
@ -29,7 +31,7 @@ pub struct FormData {
|
|||
impl FormData {
|
||||
pub fn new_inherited(form: Option<JSRef<HTMLFormElement>>, window: &JSRef<Window>) -> FormData {
|
||||
FormData {
|
||||
data: HashMap::new(),
|
||||
data: Traceable::new(RefCell::new(HashMap::new())),
|
||||
reflector_: Reflector::new(),
|
||||
window: window.unrooted(),
|
||||
form: form.unrooted(),
|
||||
|
@ -46,21 +48,21 @@ impl FormData {
|
|||
}
|
||||
|
||||
pub trait FormDataMethods {
|
||||
fn Append(&mut self, name: DOMString, value: &JSRef<Blob>, filename: Option<DOMString>);
|
||||
fn Append_(&mut self, name: DOMString, value: DOMString);
|
||||
fn Append(&self, name: DOMString, value: &JSRef<Blob>, filename: Option<DOMString>);
|
||||
fn Append_(&self, name: DOMString, value: DOMString);
|
||||
}
|
||||
|
||||
impl<'a> FormDataMethods for JSRef<'a, FormData> {
|
||||
fn Append(&mut self, name: DOMString, value: &JSRef<Blob>, filename: Option<DOMString>) {
|
||||
fn Append(&self, name: DOMString, value: &JSRef<Blob>, filename: Option<DOMString>) {
|
||||
let blob = BlobData {
|
||||
blob: value.unrooted(),
|
||||
name: filename.unwrap_or("default".to_string())
|
||||
};
|
||||
self.data.insert(name.clone(), blob);
|
||||
self.data.deref().borrow_mut().insert(name.clone(), blob);
|
||||
}
|
||||
|
||||
fn Append_(&mut self, name: DOMString, value: DOMString) {
|
||||
self.data.insert(name, StringData(value));
|
||||
fn Append_(&self, name: DOMString, value: DOMString) {
|
||||
self.data.deref().borrow_mut().insert(name, StringData(value));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -80,12 +80,11 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLBodyElement> {
|
|||
let (cx, url, reflector) = (window.get_cx(),
|
||||
window.get_url(),
|
||||
window.reflector().get_jsobject());
|
||||
let mut self_alias = self.clone();
|
||||
let evtarget: &mut JSRef<EventTarget> =
|
||||
let evtarget: &JSRef<EventTarget> =
|
||||
if forwarded_events.iter().any(|&event| name.as_slice() == event) {
|
||||
EventTargetCast::from_mut_ref(&mut *window)
|
||||
EventTargetCast::from_ref(&*window)
|
||||
} else {
|
||||
EventTargetCast::from_mut_ref(&mut self_alias)
|
||||
EventTargetCast::from_ref(self)
|
||||
};
|
||||
evtarget.set_event_handler_uncompiled(cx, url, reflector,
|
||||
name.as_slice().slice_from(2),
|
||||
|
|
|
@ -59,9 +59,9 @@ impl<'a> PrivateHTMLElementHelpers for JSRef<'a, HTMLElement> {
|
|||
|
||||
pub trait HTMLElementMethods {
|
||||
fn GetOnclick(&self) -> Option<EventHandlerNonNull>;
|
||||
fn SetOnclick(&mut self, listener: Option<EventHandlerNonNull>);
|
||||
fn SetOnclick(&self, listener: Option<EventHandlerNonNull>);
|
||||
fn GetOnload(&self) -> Option<EventHandlerNonNull>;
|
||||
fn SetOnload(&mut self, listener: Option<EventHandlerNonNull>);
|
||||
fn SetOnload(&self, listener: Option<EventHandlerNonNull>);
|
||||
}
|
||||
|
||||
impl<'a> HTMLElementMethods for JSRef<'a, HTMLElement> {
|
||||
|
@ -70,8 +70,8 @@ impl<'a> HTMLElementMethods for JSRef<'a, HTMLElement> {
|
|||
eventtarget.get_event_handler_common("click")
|
||||
}
|
||||
|
||||
fn SetOnclick(&mut self, listener: Option<EventHandlerNonNull>) {
|
||||
let eventtarget: &mut JSRef<EventTarget> = EventTargetCast::from_mut_ref(self);
|
||||
fn SetOnclick(&self, listener: Option<EventHandlerNonNull>) {
|
||||
let eventtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
|
||||
eventtarget.set_event_handler_common("click", listener)
|
||||
}
|
||||
|
||||
|
@ -84,10 +84,10 @@ impl<'a> HTMLElementMethods for JSRef<'a, HTMLElement> {
|
|||
}
|
||||
}
|
||||
|
||||
fn SetOnload(&mut self, listener: Option<EventHandlerNonNull>) {
|
||||
fn SetOnload(&self, listener: Option<EventHandlerNonNull>) {
|
||||
if self.is_body_or_frameset() {
|
||||
let mut win = window_from_node(self).root();
|
||||
win.SetOnload(listener)
|
||||
let win = window_from_node(self).root();
|
||||
win.deref().SetOnload(listener)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -109,9 +109,7 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLElement> {
|
|||
let (cx, url, reflector) = (window.get_cx(),
|
||||
window.get_url(),
|
||||
window.reflector().get_jsobject());
|
||||
let mut self_alias = self.clone();
|
||||
let evtarget: &mut JSRef<EventTarget> =
|
||||
EventTargetCast::from_mut_ref(&mut self_alias);
|
||||
let evtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
|
||||
evtarget.set_event_handler_uncompiled(cx, url, reflector,
|
||||
name.as_slice().slice_from(2),
|
||||
value);
|
||||
|
|
|
@ -39,7 +39,7 @@ enum SandboxAllowance {
|
|||
#[deriving(Encodable)]
|
||||
pub struct HTMLIFrameElement {
|
||||
pub htmlelement: HTMLElement,
|
||||
pub size: Option<IFrameSize>,
|
||||
pub size: Traceable<Cell<Option<IFrameSize>>>,
|
||||
pub sandbox: Traceable<Cell<Option<u8>>>,
|
||||
}
|
||||
|
||||
|
@ -79,7 +79,7 @@ impl HTMLIFrameElement {
|
|||
pub fn new_inherited(localName: DOMString, document: &JSRef<Document>) -> HTMLIFrameElement {
|
||||
HTMLIFrameElement {
|
||||
htmlelement: HTMLElement::new_inherited(HTMLIFrameElementTypeId, localName, document),
|
||||
size: None,
|
||||
size: Traceable::new(Cell::new(None)),
|
||||
sandbox: Traceable::new(Cell::new(None)),
|
||||
}
|
||||
}
|
||||
|
@ -120,7 +120,7 @@ impl<'a> HTMLIFrameElementMethods for JSRef<'a, HTMLIFrameElement> {
|
|||
}
|
||||
|
||||
fn GetContentWindow(&self) -> Option<Temporary<Window>> {
|
||||
self.size.and_then(|size| {
|
||||
self.size.deref().get().and_then(|size| {
|
||||
let window = window_from_node(self).root();
|
||||
let children = &*window.deref().page.children.deref().borrow();
|
||||
let child = children.iter().find(|child| {
|
||||
|
@ -194,11 +194,10 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLIFrameElement> {
|
|||
let page = window.deref().page();
|
||||
let subpage_id = page.get_next_subpage_id();
|
||||
|
||||
let mut self_alias = self.clone();
|
||||
self_alias.deref_mut().size = Some(IFrameSize {
|
||||
self.deref().size.deref().set(Some(IFrameSize {
|
||||
pipeline_id: page.id,
|
||||
subpage_id: subpage_id,
|
||||
});
|
||||
}));
|
||||
|
||||
let ConstellationChan(ref chan) = *page.constellation_chan.deref();
|
||||
chan.send(LoadIframeUrlMsg(url, page.id, subpage_id, sandboxed));
|
||||
|
|
|
@ -17,12 +17,13 @@ use servo_util::geometry::to_px;
|
|||
use servo_net::image_cache_task;
|
||||
use servo_util::url::parse_url;
|
||||
use servo_util::str::DOMString;
|
||||
use std::cell::RefCell;
|
||||
use url::Url;
|
||||
|
||||
#[deriving(Encodable)]
|
||||
pub struct HTMLImageElement {
|
||||
pub htmlelement: HTMLElement,
|
||||
image: Untraceable<Option<Url>>,
|
||||
image: Untraceable<RefCell<Option<Url>>>,
|
||||
}
|
||||
|
||||
impl HTMLImageElementDerived for EventTarget {
|
||||
|
@ -32,25 +33,24 @@ impl HTMLImageElementDerived for EventTarget {
|
|||
}
|
||||
|
||||
trait PrivateHTMLImageElementHelpers {
|
||||
fn update_image(&mut self, value: Option<DOMString>, url: Option<Url>);
|
||||
fn update_image(&self, value: Option<DOMString>, url: Option<Url>);
|
||||
}
|
||||
|
||||
impl<'a> PrivateHTMLImageElementHelpers for JSRef<'a, HTMLImageElement> {
|
||||
/// Makes the local `image` member match the status of the `src` attribute and starts
|
||||
/// prefetching the image. This method must be called after `src` is changed.
|
||||
fn update_image(&mut self, value: Option<DOMString>, url: Option<Url>) {
|
||||
let self_alias = self.clone();
|
||||
let node_alias: &JSRef<Node> = NodeCast::from_ref(&self_alias);
|
||||
let document = node_alias.owner_doc().root();
|
||||
fn update_image(&self, value: Option<DOMString>, url: Option<Url>) {
|
||||
let node: &JSRef<Node> = NodeCast::from_ref(self);
|
||||
let document = node.owner_doc().root();
|
||||
let window = document.deref().window.root();
|
||||
let image_cache = &window.image_cache_task;
|
||||
match value {
|
||||
None => {
|
||||
*self.image = None;
|
||||
*self.image.deref().borrow_mut() = None;
|
||||
}
|
||||
Some(src) => {
|
||||
let img_url = parse_url(src.as_slice(), url);
|
||||
*self.image = Some(img_url.clone());
|
||||
*self.image.deref().borrow_mut() = Some(img_url.clone());
|
||||
|
||||
// inform the image cache to load this, but don't store a
|
||||
// handle.
|
||||
|
@ -67,7 +67,7 @@ impl HTMLImageElement {
|
|||
pub fn new_inherited(localName: DOMString, document: &JSRef<Document>) -> HTMLImageElement {
|
||||
HTMLImageElement {
|
||||
htmlelement: HTMLElement::new_inherited(HTMLImageElementTypeId, localName, document),
|
||||
image: Untraceable::new(None),
|
||||
image: Untraceable::new(RefCell::new(None)),
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -78,12 +78,12 @@ impl HTMLImageElement {
|
|||
}
|
||||
|
||||
pub trait LayoutHTMLImageElementHelpers {
|
||||
unsafe fn image<'a>(&'a self) -> &'a Option<Url>;
|
||||
unsafe fn image(&self) -> Option<Url>;
|
||||
}
|
||||
|
||||
impl LayoutHTMLImageElementHelpers for JS<HTMLImageElement> {
|
||||
unsafe fn image<'a>(&'a self) -> &'a Option<Url> {
|
||||
&*(*self.unsafe_get()).image
|
||||
unsafe fn image(&self) -> Option<Url> {
|
||||
(*self.unsafe_get()).image.borrow().clone()
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -253,8 +253,7 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLImageElement> {
|
|||
if "src" == name.as_slice() {
|
||||
let window = window_from_node(self).root();
|
||||
let url = Some(window.deref().get_url());
|
||||
let mut self_alias = self.clone();
|
||||
self_alias.update_image(Some(value), url);
|
||||
self.update_image(Some(value), url);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -265,8 +264,7 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLImageElement> {
|
|||
}
|
||||
|
||||
if "src" == name.as_slice() {
|
||||
let mut self_alias = self.clone();
|
||||
self_alias.update_image(None, None);
|
||||
self.update_image(None, None);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -67,7 +67,7 @@ pub fn serialize(iterator: &mut NodeIterator) -> String {
|
|||
|
||||
fn serialize_comment(comment: &JSRef<Comment>, html: &mut String) {
|
||||
html.push_str("<!--");
|
||||
html.push_str(comment.deref().characterdata.data.as_slice());
|
||||
html.push_str(comment.deref().characterdata.data.deref().borrow().as_slice());
|
||||
html.push_str("-->");
|
||||
}
|
||||
|
||||
|
@ -80,11 +80,11 @@ fn serialize_text(text: &JSRef<Text>, html: &mut String) {
|
|||
"style" | "script" | "xmp" | "iframe" |
|
||||
"noembed" | "noframes" | "plaintext" |
|
||||
"noscript" if elem.deref().namespace == namespace::HTML
|
||||
=> html.push_str(text.deref().characterdata.data.as_slice()),
|
||||
_ => escape(text.deref().characterdata.data.as_slice(), false, html)
|
||||
=> html.push_str(text.deref().characterdata.data.deref().borrow().as_slice()),
|
||||
_ => escape(text.deref().characterdata.data.deref().borrow().as_slice(), false, html)
|
||||
}
|
||||
}
|
||||
_ => escape(text.deref().characterdata.data.as_slice(), false, html)
|
||||
_ => escape(text.deref().characterdata.data.deref().borrow().as_slice(), false, html)
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -93,7 +93,7 @@ fn serialize_processing_instruction(processing_instruction: &JSRef<ProcessingIns
|
|||
html.push_str("<?");
|
||||
html.push_str(processing_instruction.deref().target.as_slice());
|
||||
html.push_char(' ');
|
||||
html.push_str(processing_instruction.deref().characterdata.data.as_slice());
|
||||
html.push_str(processing_instruction.deref().characterdata.data.deref().borrow().as_slice());
|
||||
html.push_str("?>");
|
||||
}
|
||||
|
||||
|
@ -118,7 +118,7 @@ fn serialize_elem(elem: &JSRef<Element>, open_elements: &mut Vec<String>, html:
|
|||
match node.first_child().map(|child| child.root()) {
|
||||
Some(ref child) if child.is_text() => {
|
||||
let text: &JSRef<CharacterData> = CharacterDataCast::to_ref(&**child).unwrap();
|
||||
if text.deref().data.len() > 0 && text.deref().data.as_slice().char_at(0) == '\n' {
|
||||
if text.deref().data.deref().borrow().len() > 0 && text.deref().data.deref().borrow().as_slice().char_at(0) == '\n' {
|
||||
html.push_char('\x0A');
|
||||
}
|
||||
},
|
||||
|
|
|
@ -11,12 +11,13 @@ use dom::bindings::codegen::InheritTypes::{ElementCast, TextCast, NodeCast, Elem
|
|||
use dom::bindings::codegen::InheritTypes::{CharacterDataCast, NodeBase, NodeDerived};
|
||||
use dom::bindings::codegen::InheritTypes::{ProcessingInstructionCast, EventTargetCast};
|
||||
use dom::bindings::codegen::Bindings::NodeBinding::NodeConstants;
|
||||
use dom::bindings::error::{ErrorResult, Fallible, NotFound, HierarchyRequest, Syntax};
|
||||
use dom::bindings::js::{JS, JSRef, RootedReference, Temporary, Root, OptionalUnrootable};
|
||||
use dom::bindings::js::{OptionalSettable, TemporaryPushable, OptionalRootedRootable};
|
||||
use dom::bindings::js::{ResultRootable, OptionalRootable};
|
||||
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
|
||||
use dom::bindings::error::{ErrorResult, Fallible, NotFound, HierarchyRequest, Syntax};
|
||||
use dom::bindings::trace::Untraceable;
|
||||
use dom::bindings::utils;
|
||||
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
|
||||
use dom::characterdata::{CharacterData, CharacterDataMethods};
|
||||
use dom::comment::Comment;
|
||||
use dom::document::{Document, DocumentMethods, DocumentHelpers, HTMLDocument, NonHTMLDocument};
|
||||
|
@ -86,7 +87,7 @@ pub struct Node {
|
|||
pub child_list: Cell<Option<JS<NodeList>>>,
|
||||
|
||||
/// A bitfield of flags for node items.
|
||||
flags: NodeFlags,
|
||||
flags: Untraceable<RefCell<NodeFlags>>,
|
||||
|
||||
/// Layout information. Only the layout task may touch this data.
|
||||
///
|
||||
|
@ -382,7 +383,7 @@ pub trait NodeHelpers {
|
|||
fn is_anchor_element(&self) -> bool;
|
||||
|
||||
fn get_hover_state(&self) -> bool;
|
||||
fn set_hover_state(&mut self, state: bool);
|
||||
fn set_hover_state(&self, state: bool);
|
||||
|
||||
fn dump(&self);
|
||||
fn dump_indent(&self, indent: uint);
|
||||
|
@ -430,7 +431,7 @@ impl<'a> NodeHelpers for JSRef<'a, Node> {
|
|||
}
|
||||
|
||||
fn is_in_doc(&self) -> bool {
|
||||
self.deref().flags.contains(IsInDoc)
|
||||
self.deref().flags.deref().borrow().contains(IsInDoc)
|
||||
}
|
||||
|
||||
/// Returns the type ID of this node. Fails if this node is borrowed mutably.
|
||||
|
@ -489,14 +490,14 @@ impl<'a> NodeHelpers for JSRef<'a, Node> {
|
|||
}
|
||||
|
||||
fn get_hover_state(&self) -> bool {
|
||||
self.flags.contains(InHoverState)
|
||||
self.flags.deref().borrow().contains(InHoverState)
|
||||
}
|
||||
|
||||
fn set_hover_state(&mut self, state: bool) {
|
||||
fn set_hover_state(&self, state: bool) {
|
||||
if state {
|
||||
self.flags.insert(InHoverState);
|
||||
self.flags.deref().borrow_mut().insert(InHoverState);
|
||||
} else {
|
||||
self.flags.remove(InHoverState);
|
||||
self.flags.deref().borrow_mut().remove(InHoverState);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -706,7 +707,7 @@ pub trait RawLayoutNodeHelpers {
|
|||
|
||||
impl RawLayoutNodeHelpers for Node {
|
||||
unsafe fn get_hover_state_for_layout(&self) -> bool {
|
||||
self.flags.contains(InHoverState)
|
||||
self.flags.deref().borrow().contains(InHoverState)
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -916,7 +917,7 @@ impl Node {
|
|||
owner_doc: Cell::new(doc.unrooted()),
|
||||
child_list: Cell::new(None),
|
||||
|
||||
flags: NodeFlags::new(type_id),
|
||||
flags: Untraceable::new(RefCell::new(NodeFlags::new(type_id))),
|
||||
|
||||
layout_data: LayoutDataRef::new(),
|
||||
}
|
||||
|
@ -1110,9 +1111,9 @@ impl Node {
|
|||
for node in nodes.mut_iter() {
|
||||
parent.add_child(node, child);
|
||||
if parent.is_in_doc() {
|
||||
node.flags.insert(IsInDoc);
|
||||
node.flags.deref().borrow_mut().insert(IsInDoc);
|
||||
} else {
|
||||
node.flags.remove(IsInDoc);
|
||||
node.flags.deref().borrow_mut().remove(IsInDoc);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1197,9 +1198,7 @@ impl Node {
|
|||
// Step 8.
|
||||
parent.remove_child(node);
|
||||
|
||||
// FIXME(2513): remove this `node_alias` when in fix mozilla#2513
|
||||
let mut node_alias = node.clone();
|
||||
node_alias.deref_mut().flags.remove(IsInDoc);
|
||||
node.deref().flags.deref().borrow_mut().remove(IsInDoc);
|
||||
|
||||
// Step 9.
|
||||
match suppress_observers {
|
||||
|
@ -1236,7 +1235,7 @@ impl Node {
|
|||
CommentNodeTypeId => {
|
||||
let comment: &JSRef<Comment> = CommentCast::to_ref(node).unwrap();
|
||||
let comment = comment.deref();
|
||||
let comment = Comment::new(comment.characterdata.data.clone(), &*document);
|
||||
let comment = Comment::new(comment.characterdata.data.deref().borrow().clone(), &*document);
|
||||
NodeCast::from_temporary(comment)
|
||||
},
|
||||
DocumentNodeTypeId => {
|
||||
|
@ -1253,20 +1252,21 @@ impl Node {
|
|||
ElementNodeTypeId(..) => {
|
||||
let element: &JSRef<Element> = ElementCast::to_ref(node).unwrap();
|
||||
let element = element.deref();
|
||||
let element = build_element_from_tag(element.local_name.clone(), &*document);
|
||||
let element = build_element_from_tag(element.local_name.clone(),
|
||||
element.namespace.clone(), &*document);
|
||||
NodeCast::from_temporary(element)
|
||||
},
|
||||
TextNodeTypeId => {
|
||||
let text: &JSRef<Text> = TextCast::to_ref(node).unwrap();
|
||||
let text = text.deref();
|
||||
let text = Text::new(text.characterdata.data.clone(), &*document);
|
||||
let text = Text::new(text.characterdata.data.deref().borrow().clone(), &*document);
|
||||
NodeCast::from_temporary(text)
|
||||
},
|
||||
ProcessingInstructionNodeTypeId => {
|
||||
let pi: &JSRef<ProcessingInstruction> = ProcessingInstructionCast::to_ref(node).unwrap();
|
||||
let pi = pi.deref();
|
||||
let pi = ProcessingInstruction::new(pi.target.clone(),
|
||||
pi.characterdata.data.clone(), &*document);
|
||||
pi.characterdata.data.deref().borrow().clone(), &*document);
|
||||
NodeCast::from_temporary(pi)
|
||||
},
|
||||
}.root();
|
||||
|
@ -1284,28 +1284,22 @@ impl Node {
|
|||
match node.type_id() {
|
||||
DocumentNodeTypeId => {
|
||||
let node_doc: &JSRef<Document> = DocumentCast::to_ref(node).unwrap();
|
||||
let copy_doc: &mut JSRef<Document> = DocumentCast::to_mut_ref(&mut *copy).unwrap();
|
||||
copy_doc.set_encoding_name(node_doc.encoding_name.clone());
|
||||
let copy_doc: &JSRef<Document> = DocumentCast::to_ref(&*copy).unwrap();
|
||||
copy_doc.set_encoding_name(node_doc.encoding_name.deref().borrow().clone());
|
||||
copy_doc.set_quirks_mode(node_doc.quirks_mode());
|
||||
},
|
||||
ElementNodeTypeId(..) => {
|
||||
let node_elem: &JSRef<Element> = ElementCast::to_ref(node).unwrap();
|
||||
let node_elem = node_elem.deref();
|
||||
let copy_elem: &mut JSRef<Element> = ElementCast::to_mut_ref(&mut *copy).unwrap();
|
||||
let copy_elem: &JSRef<Element> = ElementCast::to_ref(&*copy).unwrap();
|
||||
|
||||
// XXX: to avoid double borrowing compile error. we might be able to fix this after #1854
|
||||
let copy_elem_alias = copy_elem.clone();
|
||||
|
||||
let copy_elem = copy_elem.deref_mut();
|
||||
// FIXME: https://github.com/mozilla/servo/issues/1737
|
||||
copy_elem.namespace = node_elem.namespace.clone();
|
||||
let window = document.deref().window.root();
|
||||
for attr in node_elem.attrs.borrow().iter().map(|attr| attr.root()) {
|
||||
copy_elem.attrs.borrow_mut().push_unrooted(
|
||||
for attr in node_elem.deref().attrs.borrow().iter().map(|attr| attr.root()) {
|
||||
copy_elem.deref().attrs.borrow_mut().push_unrooted(
|
||||
&Attr::new(&*window,
|
||||
attr.deref().local_name.clone(), attr.deref().value.clone(),
|
||||
attr.deref().name.clone(), attr.deref().namespace.clone(),
|
||||
attr.deref().prefix.clone(), ©_elem_alias));
|
||||
attr.deref().prefix.clone(), copy_elem));
|
||||
}
|
||||
},
|
||||
_ => ()
|
||||
|
@ -1520,7 +1514,7 @@ impl<'a> NodeMethods for JSRef<'a, Node> {
|
|||
for node in self.traverse_preorder() {
|
||||
if node.is_text() {
|
||||
let text: &JSRef<Text> = TextCast::to_ref(&node).unwrap();
|
||||
content.push_str(text.deref().characterdata.data.as_slice());
|
||||
content.push_str(text.deref().characterdata.data.deref().borrow().as_slice());
|
||||
}
|
||||
}
|
||||
Some(content.into_owned())
|
||||
|
@ -1561,10 +1555,8 @@ impl<'a> NodeMethods for JSRef<'a, Node> {
|
|||
ProcessingInstructionNodeTypeId => {
|
||||
self.wait_until_safe_to_modify_dom();
|
||||
|
||||
{
|
||||
let characterdata: &mut JSRef<CharacterData> = CharacterDataCast::to_mut_ref(self).unwrap();
|
||||
characterdata.deref_mut().data = value;
|
||||
}
|
||||
let characterdata: &JSRef<CharacterData> = CharacterDataCast::to_ref(self).unwrap();
|
||||
*characterdata.data.deref().borrow_mut() = value;
|
||||
|
||||
// Notify the document that the content of this node is different
|
||||
let document = self.owner_doc().root();
|
||||
|
@ -1778,12 +1770,12 @@ impl<'a> NodeMethods for JSRef<'a, Node> {
|
|||
let pi: &JSRef<ProcessingInstruction> = ProcessingInstructionCast::to_ref(node).unwrap();
|
||||
let other_pi: &JSRef<ProcessingInstruction> = ProcessingInstructionCast::to_ref(other).unwrap();
|
||||
(pi.deref().target == other_pi.deref().target) &&
|
||||
(pi.deref().characterdata.data == other_pi.deref().characterdata.data)
|
||||
(*pi.deref().characterdata.data.deref().borrow() == *other_pi.deref().characterdata.data.deref().borrow())
|
||||
}
|
||||
fn is_equal_characterdata(node: &JSRef<Node>, other: &JSRef<Node>) -> bool {
|
||||
let characterdata: &JSRef<CharacterData> = CharacterDataCast::to_ref(node).unwrap();
|
||||
let other_characterdata: &JSRef<CharacterData> = CharacterDataCast::to_ref(other).unwrap();
|
||||
characterdata.deref().data == other_characterdata.deref().data
|
||||
*characterdata.deref().data.deref().borrow() == *other_characterdata.deref().data.deref().borrow()
|
||||
}
|
||||
fn is_equal_element_attrs(node: &JSRef<Node>, other: &JSRef<Node>) -> bool {
|
||||
let element: &JSRef<Element> = ElementCast::to_ref(node).unwrap();
|
||||
|
|
|
@ -37,13 +37,11 @@ impl ProgressEvent {
|
|||
pub fn new(window: &JSRef<Window>, type_: DOMString,
|
||||
can_bubble: bool, cancelable: bool,
|
||||
length_computable: bool, loaded: u64, total: u64) -> Temporary<ProgressEvent> {
|
||||
let mut ev = reflect_dom_object(box ProgressEvent::new_inherited(length_computable, loaded, total),
|
||||
window,
|
||||
ProgressEventBinding::Wrap).root();
|
||||
{
|
||||
let event: &mut JSRef<Event> = EventCast::from_mut_ref(&mut *ev);
|
||||
event.InitEvent(type_, can_bubble, cancelable);
|
||||
}
|
||||
let ev = reflect_dom_object(box ProgressEvent::new_inherited(length_computable, loaded, total),
|
||||
window,
|
||||
ProgressEventBinding::Wrap).root();
|
||||
let event: &JSRef<Event> = EventCast::from_ref(&*ev);
|
||||
event.InitEvent(type_, can_bubble, cancelable);
|
||||
Temporary::from_rooted(&*ev)
|
||||
}
|
||||
pub fn Constructor(owner: &JSRef<Window>,
|
||||
|
|
|
@ -4,8 +4,9 @@
|
|||
|
||||
use dom::bindings::codegen::Bindings::UIEventBinding;
|
||||
use dom::bindings::codegen::InheritTypes::{EventCast, UIEventDerived};
|
||||
use dom::bindings::js::{JS, JSRef, RootedReference, Temporary, OptionalSettable};
|
||||
use dom::bindings::error::Fallible;
|
||||
use dom::bindings::js::{JS, JSRef, RootedReference, Temporary, OptionalSettable};
|
||||
use dom::bindings::trace::Untraceable;
|
||||
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
|
||||
use dom::event::{Event, EventMethods, EventTypeId, UIEventTypeId};
|
||||
use dom::window::Window;
|
||||
|
@ -18,7 +19,7 @@ use std::cell::Cell;
|
|||
pub struct UIEvent {
|
||||
pub event: Event,
|
||||
pub view: Cell<Option<JS<Window>>>,
|
||||
pub detail: i32
|
||||
pub detail: Untraceable<Cell<i32>>
|
||||
}
|
||||
|
||||
impl UIEventDerived for Event {
|
||||
|
@ -32,7 +33,7 @@ impl UIEvent {
|
|||
UIEvent {
|
||||
event: Event::new_inherited(type_id),
|
||||
view: Cell::new(None),
|
||||
detail: 0
|
||||
detail: Untraceable::new(Cell::new(0)),
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -48,8 +49,8 @@ impl UIEvent {
|
|||
cancelable: bool,
|
||||
view: Option<JSRef<Window>>,
|
||||
detail: i32) -> Temporary<UIEvent> {
|
||||
let mut ev = UIEvent::new_uninitialized(window).root();
|
||||
ev.InitUIEvent(type_, can_bubble, cancelable, view, detail);
|
||||
let ev = UIEvent::new_uninitialized(window).root();
|
||||
ev.deref().InitUIEvent(type_, can_bubble, cancelable, view, detail);
|
||||
Temporary::from_rooted(&*ev)
|
||||
}
|
||||
|
||||
|
@ -66,7 +67,7 @@ impl UIEvent {
|
|||
pub trait UIEventMethods {
|
||||
fn GetView(&self) -> Option<Temporary<Window>>;
|
||||
fn Detail(&self) -> i32;
|
||||
fn InitUIEvent(&mut self,
|
||||
fn InitUIEvent(&self,
|
||||
type_: DOMString,
|
||||
can_bubble: bool,
|
||||
cancelable: bool,
|
||||
|
@ -80,21 +81,19 @@ impl<'a> UIEventMethods for JSRef<'a, UIEvent> {
|
|||
}
|
||||
|
||||
fn Detail(&self) -> i32 {
|
||||
self.detail
|
||||
self.detail.deref().get()
|
||||
}
|
||||
|
||||
fn InitUIEvent(&mut self,
|
||||
fn InitUIEvent(&self,
|
||||
type_: DOMString,
|
||||
can_bubble: bool,
|
||||
cancelable: bool,
|
||||
view: Option<JSRef<Window>>,
|
||||
detail: i32) {
|
||||
{
|
||||
let event: &mut JSRef<Event> = EventCast::from_mut_ref(self);
|
||||
event.InitEvent(type_, can_bubble, cancelable);
|
||||
}
|
||||
let event: &JSRef<Event> = EventCast::from_ref(self);
|
||||
event.InitEvent(type_, can_bubble, cancelable);
|
||||
self.view.assign(view);
|
||||
self.detail = detail;
|
||||
self.detail.deref().set(detail);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -29,7 +29,7 @@ use js::jsapi::{JS_GC, JS_GetRuntime};
|
|||
use js::jsval::JSVal;
|
||||
|
||||
use collections::hashmap::HashMap;
|
||||
use std::cell::Cell;
|
||||
use std::cell::{Cell, RefCell};
|
||||
use std::cmp;
|
||||
use std::comm::{channel, Sender};
|
||||
use std::comm::Select;
|
||||
|
@ -73,10 +73,10 @@ pub struct Window {
|
|||
pub location: Cell<Option<JS<Location>>>,
|
||||
pub navigator: Cell<Option<JS<Navigator>>>,
|
||||
pub image_cache_task: ImageCacheTask,
|
||||
pub active_timers: Box<HashMap<TimerId, TimerHandle>>,
|
||||
pub next_timer_handle: i32,
|
||||
pub active_timers: Traceable<RefCell<HashMap<TimerId, TimerHandle>>>,
|
||||
pub next_timer_handle: Untraceable<Cell<i32>>,
|
||||
pub compositor: Untraceable<Box<ScriptListener>>,
|
||||
pub browser_context: Option<BrowserContext>,
|
||||
pub browser_context: Traceable<RefCell<Option<BrowserContext>>>,
|
||||
pub page: Rc<Page>,
|
||||
pub performance: Cell<Option<JS<Performance>>>,
|
||||
pub navigationStart: u64,
|
||||
|
@ -100,7 +100,7 @@ impl Window {
|
|||
#[unsafe_destructor]
|
||||
impl Drop for Window {
|
||||
fn drop(&mut self) {
|
||||
for (_, timer_handle) in self.active_timers.mut_iter() {
|
||||
for (_, timer_handle) in self.active_timers.borrow_mut().mut_iter() {
|
||||
timer_handle.cancel();
|
||||
}
|
||||
}
|
||||
|
@ -122,21 +122,21 @@ pub trait WindowMethods {
|
|||
fn Location(&self) -> Temporary<Location>;
|
||||
fn Console(&self) -> Temporary<Console>;
|
||||
fn Navigator(&self) -> Temporary<Navigator>;
|
||||
fn SetTimeout(&mut self, _cx: *mut JSContext, callback: JSVal, timeout: i32) -> i32;
|
||||
fn ClearTimeout(&mut self, handle: i32);
|
||||
fn SetInterval(&mut self, _cx: *mut JSContext, callback: JSVal, timeout: i32) -> i32;
|
||||
fn ClearInterval(&mut self, handle: i32);
|
||||
fn SetTimeout(&self, _cx: *mut JSContext, callback: JSVal, timeout: i32) -> i32;
|
||||
fn ClearTimeout(&self, handle: i32);
|
||||
fn SetInterval(&self, _cx: *mut JSContext, callback: JSVal, timeout: i32) -> i32;
|
||||
fn ClearInterval(&self, handle: i32);
|
||||
fn Window(&self) -> Temporary<Window>;
|
||||
fn Self(&self) -> Temporary<Window>;
|
||||
fn Performance(&self) -> Temporary<Performance>;
|
||||
fn GetOnclick(&self) -> Option<EventHandlerNonNull>;
|
||||
fn SetOnclick(&mut self, listener: Option<EventHandlerNonNull>);
|
||||
fn SetOnclick(&self, listener: Option<EventHandlerNonNull>);
|
||||
fn GetOnload(&self) -> Option<EventHandlerNonNull>;
|
||||
fn SetOnload(&mut self, listener: Option<EventHandlerNonNull>);
|
||||
fn SetOnload(&self, listener: Option<EventHandlerNonNull>);
|
||||
fn GetOnunload(&self) -> Option<EventHandlerNonNull>;
|
||||
fn SetOnunload(&mut self, listener: Option<EventHandlerNonNull>);
|
||||
fn SetOnunload(&self, listener: Option<EventHandlerNonNull>);
|
||||
fn GetOnerror(&self) -> Option<OnErrorEventHandlerNonNull>;
|
||||
fn SetOnerror(&mut self, listener: Option<OnErrorEventHandlerNonNull>);
|
||||
fn SetOnerror(&self, listener: Option<OnErrorEventHandlerNonNull>);
|
||||
fn Debug(&self, message: DOMString);
|
||||
fn Gc(&self);
|
||||
}
|
||||
|
@ -182,24 +182,25 @@ impl<'a> WindowMethods for JSRef<'a, Window> {
|
|||
Temporary::new(self.navigator.get().get_ref().clone())
|
||||
}
|
||||
|
||||
fn SetTimeout(&mut self, _cx: *mut JSContext, callback: JSVal, timeout: i32) -> i32 {
|
||||
fn SetTimeout(&self, _cx: *mut JSContext, callback: JSVal, timeout: i32) -> i32 {
|
||||
self.set_timeout_or_interval(callback, timeout, false)
|
||||
}
|
||||
|
||||
fn ClearTimeout(&mut self, handle: i32) {
|
||||
let mut timer_handle = self.active_timers.pop(&TimerId(handle));
|
||||
fn ClearTimeout(&self, handle: i32) {
|
||||
let mut timers = self.active_timers.deref().borrow_mut();
|
||||
let mut timer_handle = timers.pop(&TimerId(handle));
|
||||
match timer_handle {
|
||||
Some(ref mut handle) => handle.cancel(),
|
||||
None => { }
|
||||
}
|
||||
self.active_timers.remove(&TimerId(handle));
|
||||
timers.remove(&TimerId(handle));
|
||||
}
|
||||
|
||||
fn SetInterval(&mut self, _cx: *mut JSContext, callback: JSVal, timeout: i32) -> i32 {
|
||||
fn SetInterval(&self, _cx: *mut JSContext, callback: JSVal, timeout: i32) -> i32 {
|
||||
self.set_timeout_or_interval(callback, timeout, true)
|
||||
}
|
||||
|
||||
fn ClearInterval(&mut self, handle: i32) {
|
||||
fn ClearInterval(&self, handle: i32) {
|
||||
self.ClearTimeout(handle);
|
||||
}
|
||||
|
||||
|
@ -224,8 +225,8 @@ impl<'a> WindowMethods for JSRef<'a, Window> {
|
|||
eventtarget.get_event_handler_common("click")
|
||||
}
|
||||
|
||||
fn SetOnclick(&mut self, listener: Option<EventHandlerNonNull>) {
|
||||
let eventtarget: &mut JSRef<EventTarget> = EventTargetCast::from_mut_ref(self);
|
||||
fn SetOnclick(&self, listener: Option<EventHandlerNonNull>) {
|
||||
let eventtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
|
||||
eventtarget.set_event_handler_common("click", listener)
|
||||
}
|
||||
|
||||
|
@ -234,8 +235,8 @@ impl<'a> WindowMethods for JSRef<'a, Window> {
|
|||
eventtarget.get_event_handler_common("load")
|
||||
}
|
||||
|
||||
fn SetOnload(&mut self, listener: Option<EventHandlerNonNull>) {
|
||||
let eventtarget: &mut JSRef<EventTarget> = EventTargetCast::from_mut_ref(self);
|
||||
fn SetOnload(&self, listener: Option<EventHandlerNonNull>) {
|
||||
let eventtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
|
||||
eventtarget.set_event_handler_common("load", listener)
|
||||
}
|
||||
|
||||
|
@ -244,8 +245,8 @@ impl<'a> WindowMethods for JSRef<'a, Window> {
|
|||
eventtarget.get_event_handler_common("unload")
|
||||
}
|
||||
|
||||
fn SetOnunload(&mut self, listener: Option<EventHandlerNonNull>) {
|
||||
let eventtarget: &mut JSRef<EventTarget> = EventTargetCast::from_mut_ref(self);
|
||||
fn SetOnunload(&self, listener: Option<EventHandlerNonNull>) {
|
||||
let eventtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
|
||||
eventtarget.set_event_handler_common("unload", listener)
|
||||
}
|
||||
|
||||
|
@ -254,8 +255,8 @@ impl<'a> WindowMethods for JSRef<'a, Window> {
|
|||
eventtarget.get_event_handler_common("error")
|
||||
}
|
||||
|
||||
fn SetOnerror(&mut self, listener: Option<OnErrorEventHandlerNonNull>) {
|
||||
let eventtarget: &mut JSRef<EventTarget> = EventTargetCast::from_mut_ref(self);
|
||||
fn SetOnerror(&self, listener: Option<OnErrorEventHandlerNonNull>) {
|
||||
let eventtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
|
||||
eventtarget.set_event_handler_common("error", listener)
|
||||
}
|
||||
|
||||
|
@ -283,12 +284,12 @@ impl Reflectable for Window {
|
|||
pub trait WindowHelpers {
|
||||
fn damage_and_reflow(&self, damage: DocumentDamageLevel);
|
||||
fn wait_until_safe_to_modify_dom(&self);
|
||||
fn init_browser_context(&mut self, doc: &JSRef<Document>);
|
||||
fn init_browser_context(&self, doc: &JSRef<Document>);
|
||||
fn load_url(&self, href: DOMString);
|
||||
}
|
||||
|
||||
trait PrivateWindowHelpers {
|
||||
fn set_timeout_or_interval(&mut self, callback: JSVal, timeout: i32, is_interval: bool) -> i32;
|
||||
fn set_timeout_or_interval(&self, callback: JSVal, timeout: i32, is_interval: bool) -> i32;
|
||||
}
|
||||
|
||||
impl<'a> WindowHelpers for JSRef<'a, Window> {
|
||||
|
@ -306,8 +307,8 @@ impl<'a> WindowHelpers for JSRef<'a, Window> {
|
|||
self.page().join_layout();
|
||||
}
|
||||
|
||||
fn init_browser_context(&mut self, doc: &JSRef<Document>) {
|
||||
self.browser_context = Some(BrowserContext::new(doc));
|
||||
fn init_browser_context(&self, doc: &JSRef<Document>) {
|
||||
*self.browser_context.deref().borrow_mut() = Some(BrowserContext::new(doc));
|
||||
}
|
||||
|
||||
/// Commence a new URL load which will either replace this window or scroll to a fragment.
|
||||
|
@ -325,10 +326,10 @@ impl<'a> WindowHelpers for JSRef<'a, Window> {
|
|||
}
|
||||
|
||||
impl<'a> PrivateWindowHelpers for JSRef<'a, Window> {
|
||||
fn set_timeout_or_interval(&mut self, callback: JSVal, timeout: i32, is_interval: bool) -> i32 {
|
||||
fn set_timeout_or_interval(&self, callback: JSVal, timeout: i32, is_interval: bool) -> i32 {
|
||||
let timeout = cmp::max(0, timeout) as u64;
|
||||
let handle = self.next_timer_handle;
|
||||
self.next_timer_handle += 1;
|
||||
let handle = self.next_timer_handle.deref().get();
|
||||
self.next_timer_handle.deref().set(handle + 1);
|
||||
|
||||
// Post a delayed message to the per-window timer task; it will dispatch it
|
||||
// to the relevant script handler that will deal with it.
|
||||
|
@ -379,7 +380,7 @@ impl<'a> PrivateWindowHelpers for JSRef<'a, Window> {
|
|||
funval: Traceable::new(callback),
|
||||
}
|
||||
};
|
||||
self.active_timers.insert(timer_id, timer);
|
||||
self.active_timers.deref().borrow_mut().insert(timer_id, timer);
|
||||
handle
|
||||
}
|
||||
}
|
||||
|
@ -400,9 +401,9 @@ impl Window {
|
|||
location: Cell::new(None),
|
||||
navigator: Cell::new(None),
|
||||
image_cache_task: image_cache_task,
|
||||
active_timers: box HashMap::new(),
|
||||
next_timer_handle: 0,
|
||||
browser_context: None,
|
||||
active_timers: Traceable::new(RefCell::new(HashMap::new())),
|
||||
next_timer_handle: Untraceable::new(Cell::new(0)),
|
||||
browser_context: Traceable::new(RefCell::new(None)),
|
||||
performance: Cell::new(None),
|
||||
navigationStart: time::get_time().sec as u64,
|
||||
navigationStartPrecise: time::precise_time_s(),
|
||||
|
|
|
@ -225,7 +225,7 @@ impl XMLHttpRequest {
|
|||
|
||||
pub trait XMLHttpRequestMethods<'a> {
|
||||
fn GetOnreadystatechange(&self) -> Option<EventHandlerNonNull>;
|
||||
fn SetOnreadystatechange(&mut self, listener: Option<EventHandlerNonNull>);
|
||||
fn SetOnreadystatechange(&self, listener: Option<EventHandlerNonNull>);
|
||||
fn ReadyState(&self) -> u16;
|
||||
fn Open(&mut self, _method: ByteString, _url: DOMString) -> ErrorResult;
|
||||
fn Open_(&mut self, _method: ByteString, _url: DOMString, _async: bool,
|
||||
|
@ -257,8 +257,8 @@ impl<'a> XMLHttpRequestMethods<'a> for JSRef<'a, XMLHttpRequest> {
|
|||
eventtarget.get_event_handler_common("readystatechange")
|
||||
}
|
||||
|
||||
fn SetOnreadystatechange(&mut self, listener: Option<EventHandlerNonNull>) {
|
||||
let eventtarget: &mut JSRef<EventTarget> = EventTargetCast::from_mut_ref(self);
|
||||
fn SetOnreadystatechange(&self, listener: Option<EventHandlerNonNull>) {
|
||||
let eventtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
|
||||
eventtarget.set_event_handler_common("readystatechange", listener)
|
||||
}
|
||||
|
||||
|
@ -431,7 +431,7 @@ impl<'a> XMLHttpRequestMethods<'a> for JSRef<'a, XMLHttpRequest> {
|
|||
// Step 8
|
||||
let upload_target = &*self.upload.get().root().unwrap();
|
||||
let event_target: &JSRef<EventTarget> = EventTargetCast::from_ref(upload_target);
|
||||
if event_target.handlers.iter().len() > 0 {
|
||||
if event_target.has_handlers() {
|
||||
self.upload_events = true;
|
||||
}
|
||||
|
||||
|
@ -638,10 +638,10 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
|
|||
assert!(self.ready_state != rs)
|
||||
self.ready_state = rs;
|
||||
let win = &*self.global.root();
|
||||
let mut event =
|
||||
let event =
|
||||
Event::new(win, "readystatechange".to_string(), false, true).root();
|
||||
let target: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
|
||||
target.dispatch_event_with_target(None, &mut *event).ok();
|
||||
target.dispatch_event_with_target(None, &*event).ok();
|
||||
}
|
||||
|
||||
fn process_partial_response(&mut self, progress: XHRProgress) {
|
||||
|
@ -739,16 +739,16 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
|
|||
fn dispatch_progress_event(&self, upload: bool, type_: DOMString, loaded: u64, total: Option<u64>) {
|
||||
let win = &*self.global.root();
|
||||
let upload_target = &*self.upload.get().root().unwrap();
|
||||
let mut progressevent = ProgressEvent::new(win, type_, false, false,
|
||||
total.is_some(), loaded,
|
||||
total.unwrap_or(0)).root();
|
||||
let progressevent = ProgressEvent::new(win, type_, false, false,
|
||||
total.is_some(), loaded,
|
||||
total.unwrap_or(0)).root();
|
||||
let target: &JSRef<EventTarget> = if upload {
|
||||
EventTargetCast::from_ref(upload_target)
|
||||
} else {
|
||||
EventTargetCast::from_ref(self)
|
||||
};
|
||||
let event: &mut JSRef<Event> = EventCast::from_mut_ref(&mut *progressevent);
|
||||
target.dispatch_event_with_target(None, &mut *event).ok();
|
||||
let event: &JSRef<Event> = EventCast::from_ref(&*progressevent);
|
||||
target.dispatch_event_with_target(None, event).ok();
|
||||
}
|
||||
|
||||
fn dispatch_upload_progress_event(&self, type_: DOMString, partial_load: Option<u64>) {
|
||||
|
|
|
@ -44,19 +44,19 @@ impl Reflectable for XMLHttpRequestEventTarget {
|
|||
|
||||
pub trait XMLHttpRequestEventTargetMethods {
|
||||
fn GetOnloadstart(&self) -> Option<EventHandlerNonNull>;
|
||||
fn SetOnloadstart(&mut self, listener: Option<EventHandlerNonNull>);
|
||||
fn SetOnloadstart(&self, listener: Option<EventHandlerNonNull>);
|
||||
fn GetOnprogress(&self) -> Option<EventHandlerNonNull>;
|
||||
fn SetOnprogress(&mut self, listener: Option<EventHandlerNonNull>);
|
||||
fn SetOnprogress(&self, listener: Option<EventHandlerNonNull>);
|
||||
fn GetOnabort(&self) -> Option<EventHandlerNonNull>;
|
||||
fn SetOnabort(&mut self, listener: Option<EventHandlerNonNull>);
|
||||
fn SetOnabort(&self, listener: Option<EventHandlerNonNull>);
|
||||
fn GetOnerror(&self) -> Option<EventHandlerNonNull>;
|
||||
fn SetOnerror(&mut self, listener: Option<EventHandlerNonNull>);
|
||||
fn SetOnerror(&self, listener: Option<EventHandlerNonNull>);
|
||||
fn GetOnload(&self) -> Option<EventHandlerNonNull>;
|
||||
fn SetOnload(&mut self, listener: Option<EventHandlerNonNull>);
|
||||
fn SetOnload(&self, listener: Option<EventHandlerNonNull>);
|
||||
fn GetOntimeout(&self) -> Option<EventHandlerNonNull>;
|
||||
fn SetOntimeout(&mut self, listener: Option<EventHandlerNonNull>);
|
||||
fn SetOntimeout(&self, listener: Option<EventHandlerNonNull>);
|
||||
fn GetOnloadend(&self) -> Option<EventHandlerNonNull>;
|
||||
fn SetOnloadend(&mut self, listener: Option<EventHandlerNonNull>);
|
||||
fn SetOnloadend(&self, listener: Option<EventHandlerNonNull>);
|
||||
}
|
||||
|
||||
impl<'a> XMLHttpRequestEventTargetMethods for JSRef<'a, XMLHttpRequestEventTarget> {
|
||||
|
@ -65,8 +65,8 @@ impl<'a> XMLHttpRequestEventTargetMethods for JSRef<'a, XMLHttpRequestEventTarge
|
|||
eventtarget.get_event_handler_common("loadstart")
|
||||
}
|
||||
|
||||
fn SetOnloadstart(&mut self, listener: Option<EventHandlerNonNull>) {
|
||||
let eventtarget: &mut JSRef<EventTarget> = EventTargetCast::from_mut_ref(self);
|
||||
fn SetOnloadstart(&self, listener: Option<EventHandlerNonNull>) {
|
||||
let eventtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
|
||||
eventtarget.set_event_handler_common("loadstart", listener)
|
||||
}
|
||||
|
||||
|
@ -75,8 +75,8 @@ impl<'a> XMLHttpRequestEventTargetMethods for JSRef<'a, XMLHttpRequestEventTarge
|
|||
eventtarget.get_event_handler_common("progress")
|
||||
}
|
||||
|
||||
fn SetOnprogress(&mut self, listener: Option<EventHandlerNonNull>) {
|
||||
let eventtarget: &mut JSRef<EventTarget> = EventTargetCast::from_mut_ref(self);
|
||||
fn SetOnprogress(&self, listener: Option<EventHandlerNonNull>) {
|
||||
let eventtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
|
||||
eventtarget.set_event_handler_common("progress", listener)
|
||||
}
|
||||
|
||||
|
@ -85,8 +85,8 @@ impl<'a> XMLHttpRequestEventTargetMethods for JSRef<'a, XMLHttpRequestEventTarge
|
|||
eventtarget.get_event_handler_common("abort")
|
||||
}
|
||||
|
||||
fn SetOnabort(&mut self, listener: Option<EventHandlerNonNull>) {
|
||||
let eventtarget: &mut JSRef<EventTarget> = EventTargetCast::from_mut_ref(self);
|
||||
fn SetOnabort(&self, listener: Option<EventHandlerNonNull>) {
|
||||
let eventtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
|
||||
eventtarget.set_event_handler_common("abort", listener)
|
||||
}
|
||||
|
||||
|
@ -95,8 +95,8 @@ impl<'a> XMLHttpRequestEventTargetMethods for JSRef<'a, XMLHttpRequestEventTarge
|
|||
eventtarget.get_event_handler_common("error")
|
||||
}
|
||||
|
||||
fn SetOnerror(&mut self, listener: Option<EventHandlerNonNull>) {
|
||||
let eventtarget: &mut JSRef<EventTarget> = EventTargetCast::from_mut_ref(self);
|
||||
fn SetOnerror(&self, listener: Option<EventHandlerNonNull>) {
|
||||
let eventtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
|
||||
eventtarget.set_event_handler_common("error", listener)
|
||||
}
|
||||
|
||||
|
@ -105,8 +105,8 @@ impl<'a> XMLHttpRequestEventTargetMethods for JSRef<'a, XMLHttpRequestEventTarge
|
|||
eventtarget.get_event_handler_common("load")
|
||||
}
|
||||
|
||||
fn SetOnload(&mut self, listener: Option<EventHandlerNonNull>) {
|
||||
let eventtarget: &mut JSRef<EventTarget> = EventTargetCast::from_mut_ref(self);
|
||||
fn SetOnload(&self, listener: Option<EventHandlerNonNull>) {
|
||||
let eventtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
|
||||
eventtarget.set_event_handler_common("load", listener)
|
||||
}
|
||||
|
||||
|
@ -115,8 +115,8 @@ impl<'a> XMLHttpRequestEventTargetMethods for JSRef<'a, XMLHttpRequestEventTarge
|
|||
eventtarget.get_event_handler_common("timeout")
|
||||
}
|
||||
|
||||
fn SetOntimeout(&mut self, listener: Option<EventHandlerNonNull>) {
|
||||
let eventtarget: &mut JSRef<EventTarget> = EventTargetCast::from_mut_ref(self);
|
||||
fn SetOntimeout(&self, listener: Option<EventHandlerNonNull>) {
|
||||
let eventtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
|
||||
eventtarget.set_event_handler_common("timeout", listener)
|
||||
}
|
||||
|
||||
|
@ -125,8 +125,8 @@ impl<'a> XMLHttpRequestEventTargetMethods for JSRef<'a, XMLHttpRequestEventTarge
|
|||
eventtarget.get_event_handler_common("loadend")
|
||||
}
|
||||
|
||||
fn SetOnloadend(&mut self, listener: Option<EventHandlerNonNull>) {
|
||||
let eventtarget: &mut JSRef<EventTarget> = EventTargetCast::from_mut_ref(self);
|
||||
fn SetOnloadend(&self, listener: Option<EventHandlerNonNull>) {
|
||||
let eventtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
|
||||
eventtarget.set_event_handler_common("loadend", listener)
|
||||
}
|
||||
}
|
||||
|
|
|
@ -17,10 +17,10 @@ use html::cssparse::{StylesheetProvenance, UrlProvenance, spawn_css_parser};
|
|||
use script_task::Page;
|
||||
|
||||
use hubbub::hubbub;
|
||||
use hubbub::hubbub::{NullNs, XLinkNs, XmlNs, XmlNsNs};
|
||||
use hubbub::hubbub::{NullNs, HtmlNs, MathMlNs, SvgNs, XLinkNs, XmlNs, XmlNsNs};
|
||||
use servo_net::resource_task::{Load, LoadData, Payload, Done, ResourceTask, load_whole_resource};
|
||||
use servo_util::namespace;
|
||||
use servo_util::namespace::Null;
|
||||
use servo_util::namespace::{Namespace, Null};
|
||||
use servo_util::str::{DOMString, HTML_SPACE_CHARACTERS};
|
||||
use servo_util::task::spawn_named;
|
||||
use servo_util::url::parse_url;
|
||||
|
@ -158,7 +158,11 @@ fn js_script_listener(to_parent: Sender<HtmlDiscoveryMessage>,
|
|||
// Silly macros to handle constructing DOM nodes. This produces bad code and should be optimized
|
||||
// via atomization (issue #85).
|
||||
|
||||
pub fn build_element_from_tag(tag: DOMString, document: &JSRef<Document>) -> Temporary<Element> {
|
||||
pub fn build_element_from_tag(tag: DOMString, ns: Namespace, document: &JSRef<Document>) -> Temporary<Element> {
|
||||
if ns != namespace::HTML {
|
||||
return Element::new(tag, ns, None, document);
|
||||
}
|
||||
|
||||
// TODO (Issue #85): use atoms
|
||||
handle_element!(document, tag, "a", HTMLAnchorElement);
|
||||
handle_element!(document, tag, "abbr", HTMLElement);
|
||||
|
@ -369,7 +373,13 @@ pub fn parse_html(page: &Page,
|
|||
// NOTE: tmp vars are workaround for lifetime issues. Both required.
|
||||
let tmp_borrow = doc_cell.borrow();
|
||||
let tmp = &*tmp_borrow;
|
||||
let mut element: Root<Element> = build_element_from_tag(tag.name.clone(), *tmp).root();
|
||||
let namespace = match tag.ns {
|
||||
HtmlNs => namespace::HTML,
|
||||
MathMlNs => namespace::MathML,
|
||||
SvgNs => namespace::SVG,
|
||||
ns => fail!("Not expecting namespace {:?}", ns),
|
||||
};
|
||||
let mut element: Root<Element> = build_element_from_tag(tag.name.clone(), namespace, *tmp).root();
|
||||
|
||||
debug!("-- attach attrs");
|
||||
for attr in tag.attributes.iter() {
|
||||
|
@ -496,17 +506,17 @@ pub fn parse_html(page: &Page,
|
|||
js_chan2.send(JSTaskNewFile(new_url));
|
||||
}
|
||||
None => {
|
||||
let mut data = vec!();
|
||||
let mut data = String::new();
|
||||
let scriptnode: &JSRef<Node> = NodeCast::from_ref(script);
|
||||
debug!("iterating over children {:?}", scriptnode.first_child());
|
||||
for child in scriptnode.children() {
|
||||
debug!("child = {:?}", child);
|
||||
let text: &JSRef<Text> = TextCast::to_ref(&child).unwrap();
|
||||
data.push(text.deref().characterdata.data.to_str()); // FIXME: Bad copy.
|
||||
data.push_str(text.deref().characterdata.data.deref().borrow().as_slice());
|
||||
}
|
||||
|
||||
debug!("script data = {:?}", data);
|
||||
js_chan2.send(JSTaskNewInlineScript(data.concat(), url3.clone()));
|
||||
js_chan2.send(JSTaskNewInlineScript(data, url3.clone()));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -817,31 +817,27 @@ impl ScriptTask {
|
|||
let page = page.find(id).expect("ScriptTask: received fire timer msg for a
|
||||
pipeline ID not associated with this script task. This is a bug.");
|
||||
let frame = page.frame();
|
||||
let mut window = frame.get_ref().window.root();
|
||||
let window = frame.get_ref().window.root();
|
||||
|
||||
let this_value = window.deref().reflector().get_jsobject();
|
||||
|
||||
let is_interval;
|
||||
match window.deref().active_timers.find(&timer_id) {
|
||||
let data = match window.deref().active_timers.deref().borrow().find(&timer_id) {
|
||||
None => return,
|
||||
Some(timer_handle) => {
|
||||
// TODO: Support extra arguments. This requires passing a `*JSVal` array as `argv`.
|
||||
let cx = self.get_cx();
|
||||
with_compartment(cx, this_value, || {
|
||||
let mut rval = NullValue();
|
||||
unsafe {
|
||||
JS_CallFunctionValue(cx, this_value,
|
||||
*timer_handle.data.funval,
|
||||
0, ptr::mut_null(), &mut rval);
|
||||
}
|
||||
});
|
||||
Some(timer_handle) => timer_handle.data,
|
||||
};
|
||||
|
||||
is_interval = timer_handle.data.is_interval;
|
||||
// TODO: Support extra arguments. This requires passing a `*JSVal` array as `argv`.
|
||||
let cx = self.get_cx();
|
||||
with_compartment(cx, this_value, || {
|
||||
let mut rval = NullValue();
|
||||
unsafe {
|
||||
JS_CallFunctionValue(cx, this_value, *data.funval,
|
||||
0, ptr::mut_null(), &mut rval);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
if !is_interval {
|
||||
window.deref_mut().active_timers.remove(&timer_id);
|
||||
if !data.is_interval {
|
||||
window.deref().active_timers.deref().borrow_mut().remove(&timer_id);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -952,7 +948,7 @@ impl ScriptTask {
|
|||
self.compositor.dup(),
|
||||
self.image_cache_task.clone()).root();
|
||||
let mut document = Document::new(&*window, Some(url.clone()), HTMLDocument, None).root();
|
||||
window.deref_mut().init_browser_context(&*document);
|
||||
window.deref().init_browser_context(&*document);
|
||||
|
||||
with_compartment((**cx).ptr, window.reflector().get_jsobject(), || {
|
||||
let mut js_info = page.mut_js_info();
|
||||
|
@ -1033,12 +1029,11 @@ impl ScriptTask {
|
|||
// We have no concept of a document loader right now, so just dispatch the
|
||||
// "load" event as soon as we've finished executing all scripts parsed during
|
||||
// the initial load.
|
||||
let mut event =
|
||||
Event::new(&*window, "load".to_string(), false, false).root();
|
||||
let event = Event::new(&*window, "load".to_string(), false, false).root();
|
||||
let doctarget: &JSRef<EventTarget> = EventTargetCast::from_ref(&*document);
|
||||
let wintarget: &JSRef<EventTarget> = EventTargetCast::from_ref(&*window);
|
||||
let _ = wintarget.dispatch_event_with_target(Some((*doctarget).clone()),
|
||||
&mut *event);
|
||||
&*event);
|
||||
|
||||
page.fragment_node.assign(fragment.map_or(None, |fragid| page.find_fragment_node(fragid)));
|
||||
|
||||
|
@ -1089,12 +1084,14 @@ impl ScriptTask {
|
|||
Some(mut window) => {
|
||||
// http://dev.w3.org/csswg/cssom-view/#resizing-viewports
|
||||
// https://dvcs.w3.org/hg/dom3events/raw-file/tip/html/DOM3-Events.html#event-type-resize
|
||||
let mut uievent = UIEvent::new(&window.clone(), "resize".to_string(), false, false,
|
||||
Some((*window).clone()), 0i32).root();
|
||||
let event: &mut JSRef<Event> = EventCast::from_mut_ref(&mut *uievent);
|
||||
let uievent = UIEvent::new(&window.clone(),
|
||||
"resize".to_string(), false,
|
||||
false, Some(window.clone()),
|
||||
0i32).root();
|
||||
let event: &JSRef<Event> = EventCast::from_ref(&*uievent);
|
||||
|
||||
let wintarget: &mut JSRef<EventTarget> = EventTargetCast::from_mut_ref(&mut *window);
|
||||
let _ = wintarget.dispatch_event_with_target(None, &mut *event);
|
||||
let wintarget: &JSRef<EventTarget> = EventTargetCast::from_ref(&*window);
|
||||
let _ = wintarget.dispatch_event_with_target(None, event);
|
||||
}
|
||||
None => ()
|
||||
}
|
||||
|
@ -1129,12 +1126,12 @@ impl ScriptTask {
|
|||
match *page.frame() {
|
||||
Some(ref frame) => {
|
||||
let window = frame.window.root();
|
||||
let mut event =
|
||||
let event =
|
||||
Event::new(&*window,
|
||||
"click".to_string(),
|
||||
true, true).root();
|
||||
let eventtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(&node);
|
||||
let _ = eventtarget.dispatch_event_with_target(None, &mut *event);
|
||||
let _ = eventtarget.dispatch_event_with_target(None, &*event);
|
||||
}
|
||||
None => {}
|
||||
}
|
||||
|
@ -1160,8 +1157,8 @@ impl ScriptTask {
|
|||
match *mouse_over_targets {
|
||||
Some(ref mut mouse_over_targets) => {
|
||||
for node in mouse_over_targets.mut_iter() {
|
||||
let mut node = node.root();
|
||||
node.set_hover_state(false);
|
||||
let node = node.root();
|
||||
node.deref().set_hover_state(false);
|
||||
}
|
||||
}
|
||||
None => {}
|
||||
|
@ -1175,7 +1172,7 @@ impl ScriptTask {
|
|||
|
||||
let maybe_node = temp_node.root().ancestors().find(|node| node.is_element());
|
||||
match maybe_node {
|
||||
Some(mut node) => {
|
||||
Some(node) => {
|
||||
node.set_hover_state(true);
|
||||
|
||||
match *mouse_over_targets {
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue