servo/src/components/script/dom/mouseevent.rs

197 lines
5.9 KiB
Rust

/* 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::BindingDeclarations::MouseEventBinding;
use dom::bindings::codegen::InheritTypes::{UIEventCast, MouseEventDerived};
use dom::bindings::js::{JS, JSRef, RootedReference, Temporary, OptionalSettable};
use dom::bindings::error::Fallible;
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::event::{Event, MouseEventTypeId};
use dom::eventtarget::EventTarget;
use dom::uievent::{UIEvent, UIEventMethods};
use dom::window::Window;
use servo_util::str::DOMString;
#[deriving(Encodable)]
pub struct MouseEvent {
pub mouseevent: UIEvent,
pub screen_x: i32,
pub screen_y: i32,
pub client_x: i32,
pub client_y: i32,
pub ctrl_key: bool,
pub shift_key: bool,
pub alt_key: bool,
pub meta_key: bool,
pub button: u16,
pub related_target: 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: 0,
screen_y: 0,
client_x: 0,
client_y: 0,
ctrl_key: false,
shift_key: false,
alt_key: false,
meta_key: false,
button: 0,
related_target: None
}
}
pub fn new(window: &JSRef<Window>) -> Temporary<MouseEvent> {
reflect_dom_object(~MouseEvent::new_inherited(),
window,
MouseEventBinding::Wrap)
}
pub fn Constructor(owner: &JSRef<Window>,
type_: DOMString,
init: &MouseEventBinding::MouseEventInit) -> Fallible<Temporary<MouseEvent>> {
let mut ev = MouseEvent::new(owner).root();
ev.InitMouseEvent(type_, init.bubbles, init.cancelable, init.view.root_ref(),
init.detail, init.screenX, init.screenY,
init.clientX, init.clientY, init.ctrlKey,
init.altKey, init.shiftKey, init.metaKey,
init.button, init.relatedTarget.root_ref());
Ok(Temporary::from_rooted(&*ev))
}
}
pub trait MouseEventMethods {
fn ScreenX(&self) -> i32;
fn ScreenY(&self) -> i32;
fn ClientX(&self) -> i32;
fn ClientY(&self) -> i32;
fn CtrlKey(&self) -> bool;
fn ShiftKey(&self) -> bool;
fn AltKey(&self) -> bool;
fn MetaKey(&self) -> bool;
fn Button(&self) -> u16;
fn Buttons(&self)-> u16;
fn GetRelatedTarget(&self) -> Option<Temporary<EventTarget>>;
fn GetModifierState(&self, _keyArg: DOMString) -> bool;
fn InitMouseEvent(&mut 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: u16,
relatedTargetArg: Option<JSRef<EventTarget>>);
}
impl<'a> MouseEventMethods for JSRef<'a, MouseEvent> {
fn ScreenX(&self) -> i32 {
self.screen_x
}
fn ScreenY(&self) -> i32 {
self.screen_y
}
fn ClientX(&self) -> i32 {
self.client_x
}
fn ClientY(&self) -> i32 {
self.client_y
}
fn CtrlKey(&self) -> bool {
self.ctrl_key
}
fn ShiftKey(&self) -> bool {
self.shift_key
}
fn AltKey(&self) -> bool {
self.alt_key
}
fn MetaKey(&self) -> bool {
self.meta_key
}
fn Button(&self) -> u16 {
self.button
}
fn Buttons(&self)-> u16 {
//TODO
0
}
fn GetRelatedTarget(&self) -> Option<Temporary<EventTarget>> {
self.related_target.clone().map(|target| Temporary::new(target))
}
fn GetModifierState(&self, _keyArg: DOMString) -> bool {
//TODO
false
}
fn InitMouseEvent(&mut 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: u16,
relatedTargetArg: Option<JSRef<EventTarget>>) {
{
let uievent: &mut JSRef<UIEvent> = UIEventCast::from_mut_ref(self);
uievent.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.assign(relatedTargetArg);
}
}
impl Reflectable for MouseEvent {
fn reflector<'a>(&'a self) -> &'a Reflector {
self.mouseevent.reflector()
}
fn mut_reflector<'a>(&'a mut self) -> &'a mut Reflector {
self.mouseevent.mut_reflector()
}
}