diff options
Diffstat (limited to 'components/script/dom/mouseevent.rs')
| -rw-r--r-- | components/script/dom/mouseevent.rs | 182 |
1 files changed, 182 insertions, 0 deletions
diff --git a/components/script/dom/mouseevent.rs b/components/script/dom/mouseevent.rs new file mode 100644 index 00000000000..aa750b501ba --- /dev/null +++ b/components/script/dom/mouseevent.rs @@ -0,0 +1,182 @@ +/* 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::Bindings::MouseEventBinding; +use dom::bindings::codegen::Bindings::MouseEventBinding::MouseEventMethods; +use dom::bindings::codegen::Bindings::UIEventBinding::UIEventMethods; +use dom::bindings::codegen::InheritTypes::{UIEventCast, MouseEventDerived}; +use dom::bindings::error::Fallible; +use dom::bindings::global::{GlobalRef, Window}; +use dom::bindings::js::{JS, JSRef, RootedReference, Temporary, OptionalSettable}; +use dom::bindings::trace::Traceable; +use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object}; +use dom::event::{Event, MouseEventTypeId}; +use dom::eventtarget::EventTarget; +use dom::uievent::UIEvent; +use dom::window::Window; +use servo_util::str::DOMString; +use std::cell::Cell; + +#[deriving(Encodable)] +pub struct MouseEvent { + pub mouseevent: UIEvent, + pub screen_x: Traceable<Cell<i32>>, + pub screen_y: Traceable<Cell<i32>>, + pub client_x: Traceable<Cell<i32>>, + pub client_y: Traceable<Cell<i32>>, + pub ctrl_key: Traceable<Cell<bool>>, + pub shift_key: Traceable<Cell<bool>>, + pub alt_key: Traceable<Cell<bool>>, + pub meta_key: Traceable<Cell<bool>>, + pub button: Traceable<Cell<i16>>, + pub related_target: Cell<Option<JS<EventTarget>>> +} + +impl MouseEventDerived for Event { + fn is_mouseevent(&self) -> bool { + self.type_id == MouseEventTypeId + } +} + +impl MouseEvent { + pub fn new_inherited() -> MouseEvent { + MouseEvent { + mouseevent: UIEvent::new_inherited(MouseEventTypeId), + screen_x: Traceable::new(Cell::new(0)), + screen_y: Traceable::new(Cell::new(0)), + client_x: Traceable::new(Cell::new(0)), + client_y: Traceable::new(Cell::new(0)), + ctrl_key: Traceable::new(Cell::new(false)), + shift_key: Traceable::new(Cell::new(false)), + alt_key: Traceable::new(Cell::new(false)), + meta_key: Traceable::new(Cell::new(false)), + button: Traceable::new(Cell::new(0)), + related_target: Cell::new(None) + } + } + + pub fn new_uninitialized(window: &JSRef<Window>) -> Temporary<MouseEvent> { + reflect_dom_object(box MouseEvent::new_inherited(), + &Window(*window), + MouseEventBinding::Wrap) + } + + pub fn new(window: &JSRef<Window>, + type_: DOMString, + canBubble: bool, + cancelable: bool, + view: Option<JSRef<Window>>, + detail: i32, + screenX: i32, + screenY: i32, + clientX: i32, + clientY: i32, + ctrlKey: bool, + altKey: bool, + shiftKey: bool, + metaKey: bool, + button: i16, + relatedTarget: Option<JSRef<EventTarget>>) -> Temporary<MouseEvent> { + let ev = MouseEvent::new_uninitialized(window).root(); + ev.deref().InitMouseEvent(type_, canBubble, cancelable, view, detail, + screenX, screenY, clientX, clientY, + ctrlKey, altKey, shiftKey, metaKey, + button, relatedTarget); + Temporary::from_rooted(&*ev) + } + + pub fn Constructor(global: &GlobalRef, + type_: DOMString, + init: &MouseEventBinding::MouseEventInit) -> Fallible<Temporary<MouseEvent>> { + let event = MouseEvent::new(global.as_window(), type_, + init.parent.parent.bubbles, + init.parent.parent.cancelable, + init.parent.view.root_ref(), + init.parent.detail, + init.screenX, init.screenY, + init.clientX, init.clientY, init.ctrlKey, + init.altKey, init.shiftKey, init.metaKey, + init.button, init.relatedTarget.root_ref()); + Ok(event) + } +} + +impl<'a> MouseEventMethods for JSRef<'a, MouseEvent> { + fn ScreenX(&self) -> i32 { + self.screen_x.deref().get() + } + + fn ScreenY(&self) -> i32 { + self.screen_y.deref().get() + } + + fn ClientX(&self) -> i32 { + self.client_x.deref().get() + } + + fn ClientY(&self) -> i32 { + self.client_y.deref().get() + } + + fn CtrlKey(&self) -> bool { + self.ctrl_key.deref().get() + } + + fn ShiftKey(&self) -> bool { + self.shift_key.deref().get() + } + + fn AltKey(&self) -> bool { + self.alt_key.deref().get() + } + + fn MetaKey(&self) -> bool { + self.meta_key.deref().get() + } + + fn Button(&self) -> i16 { + self.button.deref().get() + } + + fn GetRelatedTarget(&self) -> Option<Temporary<EventTarget>> { + self.related_target.get().clone().map(|target| Temporary::new(target)) + } + + fn InitMouseEvent(&self, + typeArg: DOMString, + canBubbleArg: bool, + cancelableArg: bool, + viewArg: Option<JSRef<Window>>, + detailArg: i32, + screenXArg: i32, + screenYArg: i32, + clientXArg: i32, + clientYArg: i32, + ctrlKeyArg: bool, + altKeyArg: bool, + shiftKeyArg: bool, + metaKeyArg: bool, + buttonArg: i16, + relatedTargetArg: Option<JSRef<EventTarget>>) { + let uievent: &JSRef<UIEvent> = UIEventCast::from_ref(self); + uievent.InitUIEvent(typeArg, canBubbleArg, cancelableArg, viewArg, detailArg); + self.screen_x.deref().set(screenXArg); + self.screen_y.deref().set(screenYArg); + self.client_x.deref().set(clientXArg); + self.client_y.deref().set(clientYArg); + self.ctrl_key.deref().set(ctrlKeyArg); + self.alt_key.deref().set(altKeyArg); + self.shift_key.deref().set(shiftKeyArg); + self.meta_key.deref().set(metaKeyArg); + self.button.deref().set(buttonArg); + self.related_target.assign(relatedTargetArg); + } +} + + +impl Reflectable for MouseEvent { + fn reflector<'a>(&'a self) -> &'a Reflector { + self.mouseevent.reflector() + } +} |