use super::event::ViewportEvent;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
pub enum PointerOwnership {
#[default]
Elsewhere,
Inside,
Owned,
Grabbed,
}
impl PointerOwnership {
pub fn pointer_inside(self) -> bool {
!matches!(self, PointerOwnership::Elsewhere)
}
pub fn owns_input(self) -> bool {
matches!(self, PointerOwnership::Owned | PointerOwnership::Grabbed)
}
}
pub fn forward_to_viewport(event: &ViewportEvent, ownership: PointerOwnership) -> bool {
match event {
ViewportEvent::PointerLeft => !matches!(ownership, PointerOwnership::Grabbed),
_ if event.is_contested() => ownership.owns_input(),
_ => true,
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
pub enum KeyboardOwnership {
#[default]
Elsewhere,
Owned,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
pub struct InputOwnership {
pub pointer: PointerOwnership,
pub keyboard: KeyboardOwnership,
}
impl InputOwnership {
pub const NONE: Self = Self {
pointer: PointerOwnership::Elsewhere,
keyboard: KeyboardOwnership::Elsewhere,
};
pub const fn full_window() -> Self {
Self {
pointer: PointerOwnership::Owned,
keyboard: KeyboardOwnership::Owned,
}
}
pub const fn pointer_only(pointer: PointerOwnership) -> Self {
let keyboard = match pointer {
PointerOwnership::Owned | PointerOwnership::Grabbed => KeyboardOwnership::Owned,
_ => KeyboardOwnership::Elsewhere,
};
Self { pointer, keyboard }
}
}
#[derive(Debug, Clone, Copy)]
pub struct ViewportContext {
pub ownership: InputOwnership,
pub viewport_size: [f32; 2],
}
impl ViewportContext {
pub const fn new(ownership: InputOwnership, viewport_size: [f32; 2]) -> Self {
Self {
ownership,
viewport_size,
}
}
#[deprecated(
note = "use ViewportContext::new(InputOwnership::pointer_only(ownership), size), or set the keyboard axis from your text focus"
)]
pub const fn with_ownership(ownership: PointerOwnership, viewport_size: [f32; 2]) -> Self {
Self::new(InputOwnership::pointer_only(ownership), viewport_size)
}
}
impl Default for ViewportContext {
fn default() -> Self {
Self::new(InputOwnership::NONE, [1.0, 1.0])
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::input::{ButtonState, MouseButton, ScrollUnits, TouchId, TouchPhase};
fn left(state: ButtonState) -> ViewportEvent {
ViewportEvent::MouseButton {
button: MouseButton::Left,
state,
}
}
fn wheel() -> ViewportEvent {
ViewportEvent::Wheel {
delta: glam::Vec2::new(0.0, 1.0),
units: ScrollUnits::Lines,
}
}
#[test]
fn pointer_only_keeps_the_keyboard_with_the_pointer() {
let cases = [
(PointerOwnership::Elsewhere, KeyboardOwnership::Elsewhere),
(PointerOwnership::Inside, KeyboardOwnership::Elsewhere),
(PointerOwnership::Owned, KeyboardOwnership::Owned),
(PointerOwnership::Grabbed, KeyboardOwnership::Owned),
];
for (pointer, keyboard) in cases {
let o = InputOwnership::pointer_only(pointer);
assert_eq!(o.pointer, pointer);
assert_eq!(o.keyboard, keyboard, "keyboard for {pointer:?}");
#[allow(deprecated)]
let ctx = ViewportContext::with_ownership(pointer, [800.0, 600.0]);
assert_eq!(ctx.ownership, o);
assert_eq!(ctx.viewport_size, [800.0, 600.0]);
}
}
#[test]
fn the_named_ownerships() {
assert_eq!(InputOwnership::NONE, InputOwnership::default());
assert_eq!(InputOwnership::NONE.pointer, PointerOwnership::Elsewhere);
assert_eq!(InputOwnership::NONE.keyboard, KeyboardOwnership::Elsewhere);
let full = InputOwnership::full_window();
assert_eq!(full.pointer, PointerOwnership::Owned);
assert_eq!(full.keyboard, KeyboardOwnership::Owned);
assert_eq!(ViewportContext::default().ownership, InputOwnership::NONE);
}
#[test]
fn a_tool_over_the_viewport_keeps_the_wheel_with_the_camera() {
let o = PointerOwnership::Inside;
assert!(!forward_to_viewport(&left(ButtonState::Pressed), o));
assert!(!forward_to_viewport(
&ViewportEvent::PointerMoved {
position: glam::Vec2::ZERO
},
o
));
assert!(forward_to_viewport(&wheel(), o));
assert!(forward_to_viewport(
&ViewportEvent::MouseButton {
button: MouseButton::Right,
state: ButtonState::Pressed
},
o
));
}
#[test]
fn owning_the_input_forwards_everything() {
for o in [PointerOwnership::Owned, PointerOwnership::Grabbed] {
assert!(forward_to_viewport(&left(ButtonState::Pressed), o));
assert!(forward_to_viewport(&left(ButtonState::Released), o));
assert!(forward_to_viewport(&wheel(), o));
}
}
#[test]
fn a_left_release_always_lands() {
assert!(left(ButtonState::Pressed).is_contested());
assert!(!left(ButtonState::Released).is_contested());
for o in [
PointerOwnership::Elsewhere,
PointerOwnership::Inside,
PointerOwnership::Owned,
PointerOwnership::Grabbed,
] {
assert!(
forward_to_viewport(&left(ButtonState::Released), o),
"{o:?}"
);
}
}
#[test]
fn a_contact_is_withheld_but_its_end_is_not() {
let touch = |phase| ViewportEvent::Touch {
id: TouchId(1),
phase,
position: glam::Vec2::ZERO,
};
assert!(!forward_to_viewport(
&touch(TouchPhase::Started),
PointerOwnership::Inside
));
for phase in [TouchPhase::Ended, TouchPhase::Cancelled] {
for o in [
PointerOwnership::Elsewhere,
PointerOwnership::Inside,
PointerOwnership::Owned,
] {
assert!(
forward_to_viewport(&touch(phase), o),
"{phase:?} under {o:?}"
);
}
}
}
#[test]
fn a_grabbed_pointer_never_hears_pointer_left() {
assert!(!forward_to_viewport(
&ViewportEvent::PointerLeft,
PointerOwnership::Grabbed
));
for o in [
PointerOwnership::Elsewhere,
PointerOwnership::Inside,
PointerOwnership::Owned,
] {
assert!(forward_to_viewport(&ViewportEvent::PointerLeft, o));
}
}
}