use std::path::PathBuf;
use super::binding::{KeyCode, Modifiers, MouseButton};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum ButtonState {
Pressed,
Released,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum Theme {
Light,
Dark,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum ScrollUnits {
Lines,
Pixels,
Pages,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct TouchId(pub u64);
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum TouchPhase {
Started,
Moved,
Ended,
Cancelled,
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum ImeEvent {
Enabled,
Preedit {
text: String,
cursor: Option<(usize, usize)>,
},
Commit(String),
Disabled,
}
#[non_exhaustive]
#[derive(Debug, Clone)]
pub enum ViewportEvent {
PointerMoved {
position: glam::Vec2,
},
MouseButton {
button: MouseButton,
state: ButtonState,
},
Wheel {
delta: glam::Vec2,
units: ScrollUnits,
},
Key {
key: KeyCode,
state: ButtonState,
repeat: bool,
logical: Option<char>,
},
ModifiersChanged(Modifiers),
PointerLeft,
FocusLost,
Character(char),
TrackpadRotate(f32),
TrackpadPinch(f32),
TrackpadPan(glam::Vec2),
Touch {
id: TouchId,
phase: TouchPhase,
position: glam::Vec2,
},
RawMotion {
delta: glam::Vec2,
},
ThemeChanged(Theme),
Occluded(bool),
FileDropped(PathBuf),
FileHovered(PathBuf),
FileHoverCancelled,
Ime(ImeEvent),
}
macro_rules! viewport_event_variants {
($($name:ident),* $(,)?) => {
impl ViewportEvent {
#[doc(hidden)]
pub const VARIANTS: &'static [&'static str] = &[$(stringify!($name)),*];
#[doc(hidden)]
pub fn variant_name(&self) -> &'static str {
match self {
$(ViewportEvent::$name { .. } => stringify!($name),)*
}
}
}
};
}
viewport_event_variants! {
PointerMoved,
MouseButton,
Wheel,
Key,
ModifiersChanged,
PointerLeft,
FocusLost,
Character,
TrackpadRotate,
TrackpadPinch,
TrackpadPan,
Touch,
RawMotion,
ThemeChanged,
Occluded,
FileDropped,
FileHovered,
FileHoverCancelled,
Ime,
}
impl ViewportEvent {
pub fn is_contested(&self) -> bool {
matches!(
self,
ViewportEvent::MouseButton {
button: MouseButton::Left,
state: ButtonState::Pressed,
} | ViewportEvent::PointerMoved { .. }
| ViewportEvent::Touch {
phase: TouchPhase::Started,
..
}
)
}
pub fn offset_by(&self, origin: glam::Vec2) -> ViewportEvent {
match self {
ViewportEvent::PointerMoved { position } => ViewportEvent::PointerMoved {
position: *position - origin,
},
ViewportEvent::Touch {
id,
phase,
position,
} => ViewportEvent::Touch {
id: *id,
phase: *phase,
position: *position - origin,
},
other => other.clone(),
}
}
}
#[cfg(test)]
mod contested_tests {
use super::*;
#[test]
fn every_variant_has_a_listed_name() {
assert!(ViewportEvent::VARIANTS.contains(&ViewportEvent::PointerLeft.variant_name()));
assert_eq!(ViewportEvent::FocusLost.variant_name(), "FocusLost");
assert_eq!(ViewportEvent::Character('a').variant_name(), "Character");
let unique: std::collections::HashSet<_> = ViewportEvent::VARIANTS.iter().collect();
assert_eq!(unique.len(), ViewportEvent::VARIANTS.len());
}
#[test]
fn only_positions_are_offset() {
let origin = glam::Vec2::new(200.0, 100.0);
let moved = ViewportEvent::PointerMoved {
position: glam::Vec2::new(300.0, 120.0),
}
.offset_by(origin);
assert!(
matches!(moved, ViewportEvent::PointerMoved { position } if position == glam::Vec2::new(100.0, 20.0))
);
let touch = ViewportEvent::Touch {
id: TouchId(3),
phase: TouchPhase::Moved,
position: glam::Vec2::new(300.0, 120.0),
}
.offset_by(origin);
match touch {
ViewportEvent::Touch {
id,
phase,
position,
} => {
assert_eq!(id, TouchId(3));
assert_eq!(phase, TouchPhase::Moved);
assert_eq!(position, glam::Vec2::new(100.0, 20.0));
}
other => panic!("expected Touch, got {other:?}"),
}
let wheel = ViewportEvent::Wheel {
delta: glam::Vec2::Y,
units: ScrollUnits::Lines,
}
.offset_by(origin);
assert!(matches!(wheel, ViewportEvent::Wheel { delta, .. } if delta == glam::Vec2::Y));
assert!(matches!(
ViewportEvent::PointerLeft.offset_by(origin),
ViewportEvent::PointerLeft
));
}
#[test]
fn only_the_left_press_pointer_motion_and_a_landing_are_contested() {
assert!(
ViewportEvent::PointerMoved {
position: glam::Vec2::ZERO
}
.is_contested()
);
assert!(
ViewportEvent::MouseButton {
button: MouseButton::Left,
state: ButtonState::Pressed
}
.is_contested()
);
assert!(
!ViewportEvent::MouseButton {
button: MouseButton::Left,
state: ButtonState::Released
}
.is_contested(),
"a release is teardown"
);
let touch = |phase| ViewportEvent::Touch {
id: TouchId(1),
phase,
position: glam::Vec2::ZERO,
};
assert!(touch(TouchPhase::Started).is_contested());
for phase in [TouchPhase::Moved, TouchPhase::Ended, TouchPhase::Cancelled] {
assert!(!touch(phase).is_contested(), "{phase:?}");
}
for button in [MouseButton::Right, MouseButton::Middle] {
assert!(
!ViewportEvent::MouseButton {
button,
state: ButtonState::Pressed
}
.is_contested(),
"{button:?} must stay ambient"
);
}
assert!(
!ViewportEvent::Wheel {
delta: glam::Vec2::Y,
units: ScrollUnits::Lines
}
.is_contested()
);
assert!(!ViewportEvent::ModifiersChanged(Modifiers::NONE).is_contested());
assert!(!ViewportEvent::PointerLeft.is_contested());
}
}