Implement JSManaged for DOM objects.

src/components/script/dom/eventtarget.rs

@@ -2,122 +2,42 @@
  * 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::js::JS;
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::bindings::utils::{Fallible, InvalidState};
 use dom::bindings::codegen::EventListenerBinding::EventListener;
-use dom::document::AbstractDocument;
-use dom::event::AbstractEvent;
+use dom::event::Event;
 use dom::eventdispatcher::dispatch_event;
-use dom::node::AbstractNode;
-use dom::window::Window;
+use dom::node::NodeTypeId;
 use servo_util::str::DOMString;
 
-use std::cast;
 use std::hashmap::HashMap;
-use std::unstable::raw::Box;
 
-#[deriving(Eq)]
+#[deriving(Eq,Encodable)]
 pub enum ListenerPhase {
     Capturing,
     Bubbling,
 }
 
-#[deriving(Eq)]
+#[deriving(Eq,Encodable)]
 pub enum EventTargetTypeId {
     WindowTypeId,
-    NodeTypeId
+    NodeTargetTypeId(NodeTypeId)
 }
 
-#[deriving(Eq)]
+#[deriving(Eq,Encodable)]
 struct EventListenerEntry {
     phase: ListenerPhase,
     listener: EventListener
 }
 
+#[deriving(Encodable)]
 pub struct EventTarget {
     type_id: EventTargetTypeId,
     reflector_: Reflector,
     handlers: HashMap<DOMString, ~[EventListenerEntry]>,
 }
 
-pub struct AbstractEventTarget {
-    eventtarget: *mut Box<EventTarget>
-}
-
-impl AbstractEventTarget {
-    pub fn from_box<T>(box_: *mut Box<T>) -> AbstractEventTarget {
-        AbstractEventTarget {
-            eventtarget: box_ as *mut Box<EventTarget>
-        }
-    }
-
-    pub fn from_node(node: AbstractNode) -> AbstractEventTarget {
-        unsafe {
-            cast::transmute(node)
-        }
-    }
-
-    pub fn from_window(window: @mut Window) -> AbstractEventTarget {
-        AbstractEventTarget {
-            eventtarget: unsafe { cast::transmute(window) }
-        }
-    }
-
-    pub fn from_document(document: AbstractDocument) -> AbstractEventTarget {
-        unsafe {
-            cast::transmute(document)
-        }
-    }
-
-    pub fn type_id(&self) -> EventTargetTypeId {
-        self.eventtarget().type_id
-    }
-
-    pub fn is_window(&self) -> bool {
-        self.type_id() == WindowTypeId
-    }
-
-    pub fn is_node(&self) -> bool {
-        self.type_id() == NodeTypeId
-    }
-
-    //
-    // Downcasting borrows
-    //
-
-    fn transmute<'a, T>(&'a self) -> &'a T {
-        unsafe {
-            let box_: *Box<T> = self.eventtarget as *Box<T>;
-            &(*box_).data
-        }
-    }
-
-    fn transmute_mut<'a, T>(&'a mut self) -> &'a mut T {
-        unsafe {
-            let box_: *mut Box<T> = self.eventtarget as *mut Box<T>;
-            &mut (*box_).data
-        }
-    }
-
-    pub fn eventtarget<'a>(&'a self) -> &'a EventTarget {
-        self.transmute()
-    }
-
-    pub fn mut_eventtarget<'a>(&'a mut self) -> &'a mut EventTarget {
-        self.transmute_mut()
-    }
-}
-
-impl Reflectable for AbstractEventTarget {
-    fn reflector<'a>(&'a self) -> &'a Reflector {
-        self.eventtarget().reflector()
-    }
-
-    fn mut_reflector<'a>(&'a mut self) -> &'a mut Reflector {
-        self.mut_eventtarget().mut_reflector()
-    }
-}
-
 impl EventTarget {
     pub fn new_inherited(type_id: EventTargetTypeId) -> EventTarget {
         EventTarget {
@@ -178,15 +98,16 @@ impl EventTarget {
         }
     }
 
-    pub fn DispatchEvent(&self, abstract_self: AbstractEventTarget, event: AbstractEvent) -> Fallible<bool> {
+    pub fn DispatchEvent(&self, abstract_self: &JS<EventTarget>,
+                         event: &mut JS<Event>) -> Fallible<bool> {
         self.dispatch_event_with_target(abstract_self, None, event)
     }
 
     pub fn dispatch_event_with_target(&self,
-                                      abstract_self: AbstractEventTarget,
-                                      abstract_target: Option<AbstractEventTarget>,
-                                      event: AbstractEvent) -> Fallible<bool> {
-        if event.event().dispatching || !event.event().initialized {
+                                      abstract_self: &JS<EventTarget>,
+                                      abstract_target: Option<JS<EventTarget>>,
+                                      event: &mut JS<Event>) -> Fallible<bool> {
+        if event.get().dispatching || !event.get().initialized {
             return Err(InvalidState);
         }
         Ok(dispatch_event(abstract_self, abstract_target, event))