use webcore::value::Reference;
use webcore::try_from::TryInto;
use webapi::event::{IEvent, IUiEvent, UiEvent, Event};
use webapi::events::mouse::{IMouseEvent, MouseEvent};
#[cfg(feature = "experimental_features_which_may_break_on_minor_version_bumps")]
use webapi::events::mouse::MouseButton;
pub trait IPointerEvent: IMouseEvent {
#[inline]
fn pointer_id( &self ) -> i32 {
js!(
return @{self.as_ref()}.pointerId;
).try_into().unwrap()
}
#[inline]
fn width( &self ) -> f64 {
js!(
return @{self.as_ref()}.width;
).try_into().unwrap()
}
#[inline]
fn height( &self ) -> f64 {
js!(
return @{self.as_ref()}.height;
).try_into().unwrap()
}
#[inline]
fn pressure( &self ) -> f64 {
js!(
return @{self.as_ref()}.pressure;
).try_into().unwrap()
}
#[inline]
fn tangential_pressure( &self ) -> f64 {
js!(
return @{self.as_ref()}.tangentialPressure;
).try_into().unwrap()
}
#[inline]
fn tilt_x( &self ) -> i32 {
js!(
return @{self.as_ref()}.tiltX;
).try_into().unwrap()
}
#[inline]
fn tilt_y( &self ) -> i32 {
js!(
return @{self.as_ref()}.tiltY;
).try_into().unwrap()
}
#[inline]
fn twist( &self ) -> i32 {
js!(
return @{self.as_ref()}.twist;
).try_into().unwrap()
}
#[inline]
fn pointer_type( &self ) -> String {
js!(
return @{self.as_ref()}.pointerType;
).try_into().unwrap()
}
#[inline]
fn is_primary( &self ) -> bool {
js!(
return @{self.as_ref()}.isPrimary;
).try_into().unwrap()
}
#[cfg(feature = "experimental_features_which_may_break_on_minor_version_bumps")]
fn button_pointer( &self ) -> Option<MouseButton> {
match js!(
return @{self.as_ref()}.button;
).try_into().unwrap() {
-1 => None,
0 => Some(MouseButton::Left),
1 => Some(MouseButton::Wheel),
2 => Some(MouseButton::Right),
3 => Some(MouseButton::Button4),
4 => Some(MouseButton::Button5),
_ => unreachable!("Unexpected PointerEvent.button value"),
}
}
}
#[derive(Clone, Debug, PartialEq, Eq, ReferenceType)]
#[reference(instance_of = "PointerEvent")]
#[reference(subclass_of(Event, UiEvent, MouseEvent))]
pub struct PointerEvent( Reference );
impl IEvent for PointerEvent {}
impl IUiEvent for PointerEvent {}
impl IMouseEvent for PointerEvent {}
impl IPointerEvent for PointerEvent {}
#[derive(Clone, Debug, PartialEq, Eq, ReferenceType)]
#[reference(instance_of = "PointerEvent")]
#[reference(event = "pointerover")]
#[reference(subclass_of(Event, UiEvent, MouseEvent, PointerEvent))]
pub struct PointerOverEvent( Reference );
impl IEvent for PointerOverEvent {}
impl IUiEvent for PointerOverEvent {}
impl IMouseEvent for PointerOverEvent {}
impl IPointerEvent for PointerOverEvent {}
#[derive(Clone, Debug, PartialEq, Eq, ReferenceType)]
#[reference(instance_of = "PointerEvent")]
#[reference(event = "pointerenter")]
#[reference(subclass_of(Event, UiEvent, MouseEvent, PointerEvent))]
pub struct PointerEnterEvent( Reference );
impl IEvent for PointerEnterEvent {}
impl IUiEvent for PointerEnterEvent {}
impl IMouseEvent for PointerEnterEvent {}
impl IPointerEvent for PointerEnterEvent {}
#[derive(Clone, Debug, PartialEq, Eq, ReferenceType)]
#[reference(instance_of = "PointerEvent")]
#[reference(event = "pointerdown")]
#[reference(subclass_of(Event, UiEvent, MouseEvent, PointerEvent))]
pub struct PointerDownEvent( Reference );
impl IEvent for PointerDownEvent {}
impl IUiEvent for PointerDownEvent {}
impl IMouseEvent for PointerDownEvent {}
impl IPointerEvent for PointerDownEvent {}
#[derive(Clone, Debug, PartialEq, Eq, ReferenceType)]
#[reference(instance_of = "PointerEvent")]
#[reference(event = "pointermove")]
#[reference(subclass_of(Event, UiEvent, MouseEvent, PointerEvent))]
pub struct PointerMoveEvent( Reference );
impl IEvent for PointerMoveEvent {}
impl IUiEvent for PointerMoveEvent {}
impl IMouseEvent for PointerMoveEvent {}
impl IPointerEvent for PointerMoveEvent {}
impl PointerMoveEvent
{
#[inline]
pub fn get_coalesced_events( &self ) -> Vec<PointerEvent> {
js!(
return @{self.as_ref()}.getCoalescedEvents();
).try_into().unwrap()
}
}
#[derive(Clone, Debug, PartialEq, Eq, ReferenceType)]
#[reference(instance_of = "PointerEvent")]
#[reference(event = "pointerup")]
#[reference(subclass_of(Event, UiEvent, MouseEvent, PointerEvent))]
pub struct PointerUpEvent( Reference );
impl IEvent for PointerUpEvent {}
impl IUiEvent for PointerUpEvent {}
impl IMouseEvent for PointerUpEvent {}
impl IPointerEvent for PointerUpEvent {}
#[derive(Clone, Debug, PartialEq, Eq, ReferenceType)]
#[reference(instance_of = "PointerEvent")]
#[reference(event = "pointercancel")]
#[reference(subclass_of(Event, UiEvent, MouseEvent, PointerEvent))]
pub struct PointerCancelEvent( Reference );
impl IEvent for PointerCancelEvent {}
impl IUiEvent for PointerCancelEvent {}
impl IMouseEvent for PointerCancelEvent {}
impl IPointerEvent for PointerCancelEvent {}
#[derive(Clone, Debug, PartialEq, Eq, ReferenceType)]
#[reference(instance_of = "PointerEvent")]
#[reference(event = "pointerout")]
#[reference(subclass_of(Event, UiEvent, MouseEvent, PointerEvent))]
pub struct PointerOutEvent( Reference );
impl IEvent for PointerOutEvent {}
impl IUiEvent for PointerOutEvent {}
impl IMouseEvent for PointerOutEvent {}
impl IPointerEvent for PointerOutEvent {}
#[derive(Clone, Debug, PartialEq, Eq, ReferenceType)]
#[reference(instance_of = "PointerEvent")]
#[reference(event = "pointerleave")]
#[reference(subclass_of(Event, UiEvent, MouseEvent, PointerEvent))]
pub struct PointerLeaveEvent( Reference );
impl IEvent for PointerLeaveEvent {}
impl IUiEvent for PointerLeaveEvent {}
impl IMouseEvent for PointerLeaveEvent {}
impl IPointerEvent for PointerLeaveEvent {}
#[derive(Clone, Debug, PartialEq, Eq, ReferenceType)]
#[reference(instance_of = "PointerEvent")]
#[reference(event = "gotpointercapture")]
#[reference(subclass_of(Event, UiEvent, MouseEvent, PointerEvent))]
pub struct GotPointerCaptureEvent( Reference );
impl IEvent for GotPointerCaptureEvent {}
impl IUiEvent for GotPointerCaptureEvent {}
impl IMouseEvent for GotPointerCaptureEvent {}
impl IPointerEvent for GotPointerCaptureEvent {}
#[derive(Clone, Debug, PartialEq, Eq, ReferenceType)]
#[reference(instance_of = "PointerEvent")]
#[reference(event = "lostpointercapture")]
#[reference(subclass_of(Event, UiEvent, MouseEvent, PointerEvent))]
pub struct LostPointerCaptureEvent( Reference );
impl IEvent for LostPointerCaptureEvent {}
impl IUiEvent for LostPointerCaptureEvent {}
impl IMouseEvent for LostPointerCaptureEvent {}
impl IPointerEvent for LostPointerCaptureEvent {}
#[derive(Clone, Debug, PartialEq, Eq, ReferenceType)]
#[reference(instance_of = "Event")]
#[reference(event = "pointerlockchange")]
#[reference(subclass_of(Event))]
pub struct PointerLockChangeEvent( Reference );
impl IEvent for PointerLockChangeEvent {}
#[derive(Clone, Debug, PartialEq, Eq, ReferenceType)]
#[reference(instance_of = "Event")]
#[reference(event = "pointerlockerror")]
#[reference(subclass_of(Event))]
pub struct PointerLockErrorEvent( Reference );
impl IEvent for PointerLockErrorEvent {}
#[cfg(all(test, feature = "web_test"))]
mod tests {
use super::*;
use webapi::event::ConcreteEvent;
#[test]
fn test_pointer_event() {
let event: PointerMoveEvent = js!(
return new PointerEvent(
@{PointerMoveEvent::EVENT_TYPE},
{
altKey: false,
button: -1,
buttons: 6,
clientX: 3,
clientY: 4,
ctrlKey: true,
metaKey: false,
screenX: 1,
screenY: 2,
shiftKey: true,
pointerId: 5,
width: 8.2,
height: 6.1,
pressure: 0.49,
tangentialPressure: -0.2,
tiltX: 20,
tiltY: -42,
twist: 215,
pointerType: "stdweb-hand-wave",
isPrimary: false,
}
);
).try_into().unwrap();
assert_eq!( event.event_type(), PointerMoveEvent::EVENT_TYPE );
assert_eq!( event.pointer_id(), 5 );
assert_eq!( event.width(), 8.2 );
assert_eq!( event.height(), 6.1 );
assert!( ( event.pressure() - 0.49 ).abs() < 0.00000001 );
assert!( ( event.tangential_pressure() - -0.2 ).abs() < 0.00000001 );
assert_eq!( event.tilt_x(), 20 );
assert_eq!( event.tilt_y(), -42 );
assert_eq!( event.twist(), 215 );
assert_eq!( event.pointer_type(), "stdweb-hand-wave" );
assert_eq!( event.is_primary(), false );
assert_eq!( event.get_coalesced_events().len(), 0 );
}
#[test]
fn test_pointer_over_event() {
let event: PointerOverEvent = js!(
return new PointerEvent( @{PointerOverEvent::EVENT_TYPE} );
).try_into().unwrap();
assert_eq!( event.event_type(), PointerOverEvent::EVENT_TYPE );
}
#[test]
fn test_pointer_enter_event() {
let event: PointerEnterEvent = js!(
return new PointerEvent( @{PointerEnterEvent::EVENT_TYPE} );
).try_into().unwrap();
assert_eq!( event.event_type(), PointerEnterEvent::EVENT_TYPE );
}
#[test]
fn test_pointer_down_event() {
let event: PointerDownEvent = js!(
return new PointerEvent( @{PointerDownEvent::EVENT_TYPE} );
).try_into().unwrap();
assert_eq!( event.event_type(), PointerDownEvent::EVENT_TYPE );
}
#[test]
fn test_pointer_move_event() {
let event: PointerMoveEvent = js!(
return new PointerEvent( @{PointerMoveEvent::EVENT_TYPE} );
).try_into().unwrap();
assert_eq!( event.event_type(), PointerMoveEvent::EVENT_TYPE );
}
#[test]
fn test_pointer_up_event() {
let event: PointerUpEvent = js!(
return new PointerEvent( @{PointerUpEvent::EVENT_TYPE} );
).try_into().unwrap();
assert_eq!( event.event_type(), PointerUpEvent::EVENT_TYPE );
}
#[test]
fn test_pointer_cancel_event() {
let event: PointerCancelEvent = js!(
return new PointerEvent( @{PointerCancelEvent::EVENT_TYPE} );
).try_into().unwrap();
assert_eq!( event.event_type(), PointerCancelEvent::EVENT_TYPE );
}
#[test]
fn test_pointer_out_event() {
let event: PointerOutEvent = js!(
return new PointerEvent( @{PointerOutEvent::EVENT_TYPE} );
).try_into().unwrap();
assert_eq!( event.event_type(), PointerOutEvent::EVENT_TYPE );
}
#[test]
fn test_pointer_leave_event() {
let event: PointerLeaveEvent = js!(
return new PointerEvent( @{PointerLeaveEvent::EVENT_TYPE} );
).try_into().unwrap();
assert_eq!( event.event_type(), PointerLeaveEvent::EVENT_TYPE );
}
#[test]
fn test_got_pointer_capture_event() {
let event: GotPointerCaptureEvent = js!(
return new PointerEvent( @{GotPointerCaptureEvent::EVENT_TYPE} );
).try_into().unwrap();
assert_eq!( event.event_type(), GotPointerCaptureEvent::EVENT_TYPE );
}
#[test]
fn test_lost_pointer_capture_event() {
let event: LostPointerCaptureEvent = js!(
return new PointerEvent( @{LostPointerCaptureEvent::EVENT_TYPE} );
).try_into().unwrap();
assert_eq!( event.event_type(), LostPointerCaptureEvent::EVENT_TYPE );
}
#[test]
fn test_pointer_lock_change_event() {
let event: PointerLockChangeEvent = js!(
return new Event( @{PointerLockChangeEvent::EVENT_TYPE} );
).try_into().unwrap();
assert_eq!( event.event_type(), PointerLockChangeEvent::EVENT_TYPE );
}
#[test]
fn test_pointer_lock_error_event() {
let event: PointerLockErrorEvent = js!(
return new Event( @{PointerLockErrorEvent::EVENT_TYPE} );
).try_into().unwrap();
assert_eq!( event.event_type(), PointerLockErrorEvent::EVENT_TYPE );
}
}