11158 - add event handlers

components/script/dom/beforeunloadevent.rs

@@ -0,0 +1,67 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * 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::cell::DOMRefCell;
+use dom::bindings::codegen::Bindings::BeforeUnloadEventBinding;
+use dom::bindings::codegen::Bindings::BeforeUnloadEventBinding::BeforeUnloadEventMethods;
+use dom::bindings::codegen::Bindings::EventBinding::EventMethods;
+use dom::bindings::global::GlobalRef;
+use dom::bindings::inheritance::Castable;
+use dom::bindings::js::Root;
+use dom::bindings::reflector::reflect_dom_object;
+use dom::event::{Event, EventBubbles, EventCancelable};
+use string_cache::Atom;
+use util::str::DOMString;
+
+// https://html.spec.whatwg.org/multipage/#beforeunloadevent
+#[dom_struct]
+pub struct BeforeUnloadEvent {
+    event: Event,
+    return_value: DOMRefCell<DOMString>,
+}
+
+impl BeforeUnloadEvent {
+    fn new_inherited() -> BeforeUnloadEvent {
+        BeforeUnloadEvent {
+            event: Event::new_inherited(),
+            return_value: DOMRefCell::new(DOMString::new()),
+        }
+    }
+
+    pub fn new_uninitialized(global: GlobalRef) -> Root<BeforeUnloadEvent> {
+        reflect_dom_object(box BeforeUnloadEvent::new_inherited(),
+                           global,
+                           BeforeUnloadEventBinding::Wrap)
+    }
+
+    pub fn new(global: GlobalRef,
+               type_: Atom,
+               bubbles: EventBubbles,
+               cancelable: EventCancelable) -> Root<BeforeUnloadEvent> {
+        let ev = BeforeUnloadEvent::new_uninitialized(global);
+        {
+            let event = ev.upcast::<Event>();
+            event.init_event(type_, bool::from(bubbles),
+                             bool::from(cancelable));
+        }
+        ev
+    }
+}
+
+impl BeforeUnloadEventMethods for BeforeUnloadEvent {
+    // https://html.spec.whatwg.org/multipage/#dom-beforeunloadevent-returnvalue
+    fn ReturnValue(&self) -> DOMString {
+        self.return_value.borrow().clone()
+    }
+
+    // https://html.spec.whatwg.org/multipage/#dom-beforeunloadevent-returnvalue
+    fn SetReturnValue(&self, value: DOMString) {
+        *self.return_value.borrow_mut() = value;
+    }
+
+    // https://dom.spec.whatwg.org/#dom-event-istrusted
+    fn IsTrusted(&self) -> bool {
+        self.event.IsTrusted()
+    }
+}

components/script/dom/document.rs

@@ -2801,6 +2801,9 @@ impl DocumentMethods for Document {
         // Step 5
         elements
     }
+
+    // https://html.spec.whatwg.org/multipage/#documentandelementeventhandlers
+    document_and_element_event_handlers!();
 }
 
 fn update_with_current_time_ms(marker: &Cell<u64>) {

components/script/dom/eventtarget.rs

@@ -2,11 +2,14 @@
  * 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::beforeunloadevent::BeforeUnloadEvent;
 use dom::bindings::callback::{CallbackContainer, ExceptionHandling, CallbackFunction};
 use dom::bindings::cell::DOMRefCell;
+use dom::bindings::codegen::Bindings::BeforeUnloadEventBinding::BeforeUnloadEventMethods;
 use dom::bindings::codegen::Bindings::ErrorEventBinding::ErrorEventMethods;
 use dom::bindings::codegen::Bindings::EventBinding::EventMethods;
 use dom::bindings::codegen::Bindings::EventHandlerBinding::EventHandlerNonNull;
+use dom::bindings::codegen::Bindings::EventHandlerBinding::OnBeforeUnloadEventHandlerNonNull;
 use dom::bindings::codegen::Bindings::EventHandlerBinding::OnErrorEventHandlerNonNull;
 use dom::bindings::codegen::Bindings::EventListenerBinding::EventListener;
 use dom::bindings::codegen::Bindings::EventTargetBinding::EventTargetMethods;
@@ -45,13 +48,15 @@ use util::str::DOMString;
 pub enum CommonEventHandler {
     EventHandler(Rc<EventHandlerNonNull>),
     ErrorEventHandler(Rc<OnErrorEventHandlerNonNull>),
+    BeforeUnloadEventHandler(Rc<OnBeforeUnloadEventHandlerNonNull>),
 }
 
 impl CommonEventHandler {
     fn parent(&self) -> &CallbackFunction {
         match *self {
             CommonEventHandler::EventHandler(ref handler) => &handler.parent,
             CommonEventHandler::ErrorEventHandler(ref handler) => &handler.parent,
+            CommonEventHandler::BeforeUnloadEventHandler(ref handler) => &handler.parent,
         }
     }
 }
@@ -173,6 +178,27 @@ impl CompiledEventListener {
                                               None, None, None, None, exception_handle);
                     }
 
+                    CommonEventHandler::BeforeUnloadEventHandler(ref handler) => {
+                        if let Some(event) = event.downcast::<BeforeUnloadEvent>() {
+                            let rv = event.ReturnValue();
+
+                            if let Ok(value) = handler.Call_(object,
+                                                             event.upcast::<Event>(),
+                                                             exception_handle) {
+                                match value {
+                                    Some(value) => {
+                                        if rv.is_empty() {
+                                            event.SetReturnValue(value);
+                                        }
+                                    }
+                                    None => {
+                                        event.upcast::<Event>().PreventDefault();
+                                    }
+                                }
+                            }
+                        }
+                    }
+
                     CommonEventHandler::EventHandler(ref handler) => {
                         if let Ok(value) = handler.Call_(object, event, exception_handle) {
                             let global = object.global();
@@ -183,7 +209,6 @@ impl CompiledEventListener {
                             //Step 4
                             let should_cancel = match event.type_() {
                                 atom!("mouseover") => value.is_boolean() && value.to_boolean() == true,
-                                atom!("beforeunload") => value.is_null(),
                                 _ => value.is_boolean() && value.to_boolean() == false
                             };
                             if should_cancel {
@@ -412,7 +437,12 @@ impl EventTarget {
         if is_error {
             Some(CommonEventHandler::ErrorEventHandler(OnErrorEventHandlerNonNull::new(funobj)))
         } else {
-            Some(CommonEventHandler::EventHandler(EventHandlerNonNull::new(funobj)))
+            if ty == &atom!("beforeunload") {
+                Some(CommonEventHandler::BeforeUnloadEventHandler(
+                        OnBeforeUnloadEventHandlerNonNull::new(funobj)))
+            } else {
+                Some(CommonEventHandler::EventHandler(EventHandlerNonNull::new(funobj)))
+            }
         }
     }
 
@@ -436,6 +466,16 @@ impl EventTarget {
         self.set_inline_event_listener(Atom::from(ty), event_listener);
     }
 
+    pub fn set_beforeunload_event_handler<T: CallbackContainer>(&self, ty: &str,
+            listener: Option<Rc<T>>) {
+        let event_listener = listener.map(|listener|
+            InlineEventListener::Compiled(
+                CommonEventHandler::BeforeUnloadEventHandler(
+                    OnBeforeUnloadEventHandlerNonNull::new(listener.callback())))
+        );
+        self.set_inline_event_listener(Atom::from(ty), event_listener);
+    }
+
     pub fn get_event_handler_common<T: CallbackContainer>(&self, ty: &str) -> Option<Rc<T>> {
         let listener = self.get_inline_event_listener(&Atom::from(ty));
         listener.map(|listener| CallbackContainer::new(listener.parent().callback()))

components/script/dom/htmlbodyelement.rs

@@ -4,7 +4,7 @@
 
 use cssparser::RGBA;
 use dom::attr::{Attr, AttrValue};
-use dom::bindings::codegen::Bindings::EventHandlerBinding::EventHandlerNonNull;
+use dom::bindings::codegen::Bindings::EventHandlerBinding::{EventHandlerNonNull, OnBeforeUnloadEventHandlerNonNull};
 use dom::bindings::codegen::Bindings::HTMLBodyElementBinding::{self, HTMLBodyElementMethods};
 use dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
 use dom::bindings::inheritance::Castable;
@@ -17,7 +17,6 @@ use dom::node::{Node, document_from_node, window_from_node};
 use dom::virtualmethods::VirtualMethods;
 use msg::constellation_msg::ConstellationChan;
 use script_traits::ScriptMsg as ConstellationMsg;
-use std::rc::Rc;
 use string_cache::Atom;
 use time;
 use url::Url;
@@ -71,31 +70,14 @@ impl HTMLBodyElementMethods for HTMLBodyElement {
     // https://html.spec.whatwg.org/multipage/#dom-body-text
     make_legacy_color_setter!(SetText, "text");
 
-    // https://html.spec.whatwg.org/multipage/#the-body-element
-    fn GetOnunload(&self) -> Option<Rc<EventHandlerNonNull>> {
-        window_from_node(self).GetOnunload()
-    }
-
-    // https://html.spec.whatwg.org/multipage/#the-body-element
-    fn SetOnunload(&self, listener: Option<Rc<EventHandlerNonNull>>) {
-        window_from_node(self).SetOnunload(listener)
-    }
-
-    // https://html.spec.whatwg.org/multipage/#the-body-element
-    fn GetOnstorage(&self) -> Option<Rc<EventHandlerNonNull>> {
-        window_from_node(self).GetOnstorage()
-    }
-
-    // https://html.spec.whatwg.org/multipage/#the-body-element
-    fn SetOnstorage(&self, listener: Option<Rc<EventHandlerNonNull>>) {
-        window_from_node(self).SetOnstorage(listener)
-    }
-
     // https://html.spec.whatwg.org/multipage/#dom-body-background
     make_getter!(Background, "background");
 
     // https://html.spec.whatwg.org/multipage/#dom-body-background
     make_url_setter!(SetBackground, "background");
+
+    // https://html.spec.whatwg.org/multipage/#windoweventhandlers
+    window_event_handlers!(ForwardToWindow);
 }
 
 pub trait HTMLBodyElementLayoutHelpers {

components/script/dom/htmlelement.rs

@@ -137,6 +137,9 @@ impl HTMLElementMethods for HTMLElement {
     // https://html.spec.whatwg.org/multipage/#globaleventhandlers
     global_event_handlers!(NoOnload);
 
+    // https://html.spec.whatwg.org/multipage/#documentandelementeventhandlers
+    document_and_element_event_handlers!();
+
     // https://html.spec.whatwg.org/multipage/#dom-dataset
     fn Dataset(&self) -> Root<DOMStringMap> {
         self.dataset.or_init(|| DOMStringMap::new(self))
@@ -196,6 +199,42 @@ impl HTMLElementMethods for HTMLElement {
         }
     }
 
+    // https://html.spec.whatwg.org/multipage/#handler-onfocus
+    fn GetOnfocus(&self) -> Option<Rc<EventHandlerNonNull>> {
+        if self.is_body_or_frameset() {
+            window_from_node(self).GetOnfocus()
+        } else {
+            self.upcast::<EventTarget>().get_event_handler_common("focus")
+        }
+    }
+
+    // https://html.spec.whatwg.org/multipage/#handler-onfocus
+    fn SetOnfocus(&self, listener: Option<Rc<EventHandlerNonNull>>) {
+        if self.is_body_or_frameset() {
+            window_from_node(self).SetOnfocus(listener)
+        } else {
+            self.upcast::<EventTarget>().set_event_handler_common("focus", listener)
+        }
+    }
+
+    // https://html.spec.whatwg.org/multipage/#handler-onscroll
+    fn GetOnscroll(&self) -> Option<Rc<EventHandlerNonNull>> {
+        if self.is_body_or_frameset() {
+            window_from_node(self).GetOnscroll()
+        } else {
+            self.upcast::<EventTarget>().get_event_handler_common("scroll")
+        }
+    }
+
+    // https://html.spec.whatwg.org/multipage/#handler-onscroll
+    fn SetOnscroll(&self, listener: Option<Rc<EventHandlerNonNull>>) {
+        if self.is_body_or_frameset() {
+            window_from_node(self).SetOnscroll(listener)
+        } else {
+            self.upcast::<EventTarget>().set_event_handler_common("scroll", listener)
+        }
+    }
+
     // https://html.spec.whatwg.org/multipage/#dom-click
     fn Click(&self) {
         if !self.upcast::<Element>().disabled_state() {

components/script/dom/htmlframesetelement.rs

@@ -2,11 +2,14 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
+use dom::bindings::codegen::Bindings::EventHandlerBinding::{EventHandlerNonNull, OnBeforeUnloadEventHandlerNonNull};
 use dom::bindings::codegen::Bindings::HTMLFrameSetElementBinding;
+use dom::bindings::codegen::Bindings::HTMLFrameSetElementBinding::HTMLFrameSetElementMethods;
+use dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
 use dom::bindings::js::Root;
 use dom::document::Document;
 use dom::htmlelement::HTMLElement;
-use dom::node::Node;
+use dom::node::{Node, window_from_node};
 use string_cache::Atom;
 use util::str::DOMString;
 
@@ -33,3 +36,8 @@ impl HTMLFrameSetElement {
         Node::reflect_node(box element, document, HTMLFrameSetElementBinding::Wrap)
     }
 }
+
+impl HTMLFrameSetElementMethods for HTMLFrameSetElement {
+    // https://html.spec.whatwg.org/multipage/#windoweventhandlers
+    window_event_handlers!(ForwardToWindow);
+}