Generate DOM bindings for UIEvent and MouseEvent.

src/components/script/dom/mouseevent.rs

@@ -0,0 +1,184 @@
+/* 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::codegen::MouseEventBinding;
+use dom::bindings::utils::{ErrorResult, DOMString};
+use dom::bindings::utils::{CacheableWrapper, WrapperCache, BindingObject, DerivedWrapper};
+use dom::eventtarget::EventTarget;
+use dom::uievent::UIEvent;
+use dom::window::Window;
+use dom::windowproxy::WindowProxy;
+use script_task::{global_script_context};
+
+use js::glue::RUST_OBJECT_TO_JSVAL;
+use js::jsapi::{JSObject, JSContext, JSVal};
+
+pub struct MouseEvent {
+    parent: UIEvent,
+    screen_x: i32,
+    screen_y: i32,
+    client_x: i32,
+    client_y: i32,
+    ctrl_key: bool,
+    shift_key: bool,
+    alt_key: bool,
+    meta_key: bool,
+    button: u16,
+    related_target: Option<@mut EventTarget>
+}
+
+impl MouseEvent {
+    pub fn new(type_: DOMString, can_bubble: bool, cancelable: bool,
+               view: Option<@mut WindowProxy>, detail: i32, screen_x: i32,
+               screen_y: i32, client_x: i32, client_y: i32, ctrl_key: bool,
+               shift_key: bool, alt_key: bool, meta_key: bool, button: u16,
+               _buttons: u16, related_target: Option<@mut EventTarget>) -> MouseEvent {
+        MouseEvent {
+            parent: UIEvent::new(type_, can_bubble, cancelable, view, detail),
+            screen_x: screen_x,
+            screen_y: screen_y,
+            client_x: client_x,
+            client_y: client_y,
+            ctrl_key: ctrl_key,
+            shift_key: shift_key,
+            alt_key: alt_key,
+            meta_key: meta_key,
+            button: button,
+            related_target: related_target
+        }
+    }
+
+    pub fn init_wrapper(@mut self) {
+        let script_context = global_script_context();
+        let cx = script_context.js_compartment.cx.ptr;
+        let owner = script_context.root_frame.get_ref().window;
+        let cache = owner.get_wrappercache();
+        let scope = cache.get_wrapper();
+        self.wrap_object_shared(cx, scope);
+    }
+
+    pub fn Constructor(_owner: @mut Window,
+                       type_: DOMString,
+                       init: &MouseEventBinding::MouseEventInit,
+                       _rv: &mut ErrorResult) -> @mut MouseEvent {
+        @mut MouseEvent::new(type_, init.bubbles, init.cancelable, init.view, init.detail,
+                             init.screenX, init.screenY, init.clientX, init.clientY,
+                             init.ctrlKey, init.shiftKey, init.altKey, init.metaKey,
+                             init.button, init.buttons, init.relatedTarget)
+    }
+
+    pub fn ScreenX(&self) -> i32 {
+        self.screen_x
+    }
+
+    pub fn ScreenY(&self) -> i32 {
+        self.screen_y
+    }
+
+    pub fn ClientX(&self) -> i32 {
+        self.client_x
+    }
+
+    pub fn ClientY(&self) -> i32 {
+        self.client_y
+    }
+
+    pub fn CtrlKey(&self) -> bool {
+        self.ctrl_key
+    }
+
+    pub fn ShiftKey(&self) -> bool {
+        self.shift_key
+    }
+
+    pub fn AltKey(&self) -> bool {
+        self.alt_key
+    }
+
+    pub fn MetaKey(&self) -> bool {
+        self.meta_key
+    }
+
+    pub fn Button(&self) -> u16 {
+        self.button
+    }
+
+    pub fn Buttons(&self)-> u16 {
+        //TODO
+        0
+    }
+
+    pub fn GetRelatedTarget(&self) -> Option<@mut EventTarget> {
+        self.related_target
+    }
+
+    pub fn GetModifierState(&self, _keyArg: DOMString) -> bool {
+        //TODO
+        false
+    }
+
+    pub fn InitMouseEvent(&mut self,
+                          typeArg: DOMString,
+                          canBubbleArg: bool,
+                          cancelableArg: bool,
+                          viewArg: Option<@mut WindowProxy>,
+                          detailArg: i32,
+                          screenXArg: i32,
+                          screenYArg: i32,
+                          clientXArg: i32,
+                          clientYArg: i32,
+                          ctrlKeyArg: bool,
+                          altKeyArg: bool,
+                          shiftKeyArg: bool,
+                          metaKeyArg: bool,
+                          buttonArg: u16,
+                          relatedTargetArg: Option<@mut EventTarget>,
+                          _rv: &mut ErrorResult) {
+        self.parent.InitUIEvent(typeArg, canBubbleArg, cancelableArg, viewArg, detailArg);
+        self.screen_x = screenXArg;
+        self.screen_y = screenYArg;
+        self.client_x = clientXArg;
+        self.client_y = clientYArg;
+        self.ctrl_key = ctrlKeyArg;
+        self.alt_key = altKeyArg;
+        self.shift_key = shiftKeyArg;
+        self.meta_key = metaKeyArg;
+        self.button = buttonArg;
+        self.related_target = relatedTargetArg;
+    }
+}
+
+impl CacheableWrapper for MouseEvent {
+    fn get_wrappercache(&mut self) -> &mut WrapperCache {
+        return self.parent.get_wrappercache()
+    }
+
+    fn wrap_object_shared(@mut self, cx: *JSContext, scope: *JSObject) -> *JSObject {
+        let mut unused = false;
+        MouseEventBinding::Wrap(cx, scope, self, &mut unused)
+    }
+}
+
+impl BindingObject for MouseEvent {
+    fn GetParentObject(&self, cx: *JSContext) -> @mut CacheableWrapper {
+        self.parent.GetParentObject(cx)
+    }
+}
+
+impl DerivedWrapper for MouseEvent {
+    fn wrap(&mut self, _cx: *JSContext, _scope: *JSObject, _vp: *mut JSVal) -> i32 {
+        fail!(~"nyi")
+    }
+
+    fn wrap_shared(@mut self, cx: *JSContext, scope: *JSObject, vp: *mut JSVal) -> i32 {
+        let obj = self.wrap_object_shared(cx, scope);
+        if obj.is_null() {
+            return 0;
+        } else {
+            unsafe { *vp = RUST_OBJECT_TO_JSVAL(obj) };
+            return 1;
+        }
+    }
+
+}