use std::collections::{HashMap, HashSet};
use super::action::Action;
use super::action_frame::{ActionFrame, NavigationActions, PointerFrame, ResolvedActionState};
use super::binding::{KeyCode, Modifiers, MouseButton};
use super::context::{KeyboardOwnership, ViewportContext, forward_to_viewport};
use super::event::{ButtonState, ScrollUnits, TouchId, TouchPhase, ViewportEvent};
use super::preset::{BindingPreset, viewer_bindings, viewport_default_bindings};
use super::touch::TouchSettings;
use super::viewport_binding::{ViewportBinding, ViewportGesture};
const PIXELS_PER_LINE: f32 = 28.0;
pub const CLICK_THRESHOLD_PX: f32 = 5.0;
const PINCH_PIXELS_PER_UNIT: f32 = 500.0;
#[derive(Debug, Clone, Copy)]
struct Contact {
id: TouchId,
origin: glam::Vec2,
position: glam::Vec2,
start_time: f32,
travel: f32,
long_pressed: bool,
}
#[derive(Debug, Clone, Copy)]
struct TouchMeasure {
centroid: glam::Vec2,
spread: f32,
angle: f32,
}
fn wrap_angle(a: f32) -> f32 {
use std::f32::consts::{PI, TAU};
(a + PI).rem_euclid(TAU) - PI
}
pub struct ViewportInput {
bindings: Vec<ViewportBinding>,
drag_delta: glam::Vec2,
wheel_delta: glam::Vec2, rotate_gesture: f32, pinch_gesture: f32, pan_gesture: glam::Vec2,
pointer_delta: glam::Vec2,
left_pressed: bool,
left_drag_began: bool,
left_drag_reached: bool,
left_clicked: bool,
keys_pressed: HashSet<KeyCode>,
chars_pressed: HashSet<char>,
text: Vec<char>,
touch_drag: glam::Vec2,
touch_pinch: f32,
touch_twist: f32,
tapped: bool,
double_tapped: bool,
long_pressed: bool,
pointer_pos: Option<glam::Vec2>,
contacts: Vec<Contact>,
touch_ref: Option<TouchMeasure>,
touch_position: Option<glam::Vec2>,
last_tap: Option<(glam::Vec2, f32)>,
touch_settings: TouchSettings,
time: f32,
has_clock: bool,
button_held: [bool; 3], button_press_pos: [Option<glam::Vec2>; 3],
modifiers: Modifiers,
keys_held: HashSet<KeyCode>,
chars_held: HashMap<KeyCode, char>,
ctx: ViewportContext,
}
fn button_index(b: MouseButton) -> Option<usize> {
match b {
MouseButton::Left => Some(0),
MouseButton::Right => Some(1),
MouseButton::Middle => Some(2),
_ => None,
}
}
fn binding_char(key: KeyCode, logical: Option<char>) -> Option<char> {
match logical {
Some(c) if c.is_ascii_graphic() => Some(c.to_ascii_lowercase()),
_ => us_char(key),
}
}
fn us_char(key: KeyCode) -> Option<char> {
use KeyCode as K;
const LETTERS: [KeyCode; 26] = [
K::A,
K::B,
K::C,
K::D,
K::E,
K::F,
K::G,
K::H,
K::I,
K::J,
K::K,
K::L,
K::M,
K::N,
K::O,
K::P,
K::Q,
K::R,
K::S,
K::T,
K::U,
K::V,
K::W,
K::X,
K::Y,
K::Z,
];
const DIGITS: [KeyCode; 10] = [
K::Num0,
K::Num1,
K::Num2,
K::Num3,
K::Num4,
K::Num5,
K::Num6,
K::Num7,
K::Num8,
K::Num9,
];
if let Some(i) = LETTERS.iter().position(|k| *k == key) {
return Some((b'a' + i as u8) as char);
}
if let Some(i) = DIGITS.iter().position(|k| *k == key) {
return Some((b'0' + i as u8) as char);
}
Some(match key {
K::Minus => '-',
K::Equals => '=',
K::LeftBracket => '[',
K::RightBracket => ']',
K::Backslash => '\\',
K::Semicolon => ';',
K::Apostrophe => '\'',
K::Comma => ',',
K::Period => '.',
K::Slash => '/',
K::Backtick => '`',
_ => return None,
})
}
impl ViewportInput {
pub fn new(bindings: Vec<ViewportBinding>) -> Self {
Self {
bindings,
drag_delta: glam::Vec2::ZERO,
wheel_delta: glam::Vec2::ZERO,
rotate_gesture: 0.0,
pinch_gesture: 0.0,
pan_gesture: glam::Vec2::ZERO,
pointer_delta: glam::Vec2::ZERO,
left_pressed: false,
left_drag_began: false,
left_drag_reached: false,
left_clicked: false,
keys_pressed: HashSet::new(),
chars_pressed: HashSet::new(),
text: Vec::new(),
touch_drag: glam::Vec2::ZERO,
touch_pinch: 0.0,
touch_twist: 0.0,
tapped: false,
double_tapped: false,
long_pressed: false,
pointer_pos: None,
contacts: Vec::new(),
touch_ref: None,
touch_position: None,
last_tap: None,
touch_settings: TouchSettings::default(),
time: 0.0,
has_clock: false,
button_held: [false; 3],
button_press_pos: [None, None, None],
modifiers: Modifiers::NONE,
keys_held: HashSet::new(),
chars_held: HashMap::new(),
ctx: ViewportContext::default(),
}
}
pub fn from_preset(preset: BindingPreset) -> Self {
let bindings = match preset {
BindingPreset::Default => viewport_default_bindings(),
BindingPreset::Viewer => viewer_bindings(),
_ => viewport_default_bindings(),
};
Self::new(bindings)
}
pub fn with_bindings(mut self, extra: impl IntoIterator<Item = ViewportBinding>) -> Self {
self.bindings.extend(extra);
self
}
pub fn is_gesture_active(&self) -> bool {
!self.contacts.is_empty() || self.press_armed()
}
pub fn touch_settings(&self) -> TouchSettings {
self.touch_settings
}
pub fn set_touch_settings(&mut self, settings: TouchSettings) {
self.touch_settings = settings;
}
pub fn cancel_gesture(&mut self) {
for held in &mut self.button_held {
*held = false;
}
for pos in &mut self.button_press_pos {
*pos = None;
}
self.drag_delta = glam::Vec2::ZERO;
self.pointer_delta = glam::Vec2::ZERO;
self.left_pressed = false;
self.left_drag_reached = false;
self.left_drag_began = false;
self.left_clicked = false;
self.contacts.clear();
self.touch_ref = None;
self.touch_drag = glam::Vec2::ZERO;
self.touch_pinch = 0.0;
self.touch_twist = 0.0;
self.tapped = false;
self.double_tapped = false;
self.long_pressed = false;
}
pub fn begin_frame(&mut self, ctx: ViewportContext) {
self.ctx = ctx;
self.drag_delta = glam::Vec2::ZERO;
self.wheel_delta = glam::Vec2::ZERO;
self.rotate_gesture = 0.0;
self.pinch_gesture = 0.0;
self.pan_gesture = glam::Vec2::ZERO;
self.pointer_delta = glam::Vec2::ZERO;
self.left_pressed = false;
self.left_drag_began = false;
self.left_clicked = false;
self.keys_pressed.clear();
self.chars_pressed.clear();
self.text.clear();
self.touch_drag = glam::Vec2::ZERO;
self.touch_pinch = 0.0;
self.touch_twist = 0.0;
self.tapped = false;
self.double_tapped = false;
self.long_pressed = false;
}
pub fn set_ownership(&mut self, ownership: crate::input::InputOwnership) {
self.ctx.ownership = ownership;
}
pub fn begin_frame_at(&mut self, ctx: ViewportContext, time_seconds: f32) {
self.has_clock = true;
self.time = time_seconds;
self.begin_frame(ctx);
if self.contacts.len() == 1 {
let dwell = self.touch_settings.long_press_dwell;
let tolerance = self.touch_settings.long_press_tolerance;
let contact = &mut self.contacts[0];
if !contact.long_pressed
&& contact.travel <= tolerance
&& time_seconds - contact.start_time >= dwell
{
contact.long_pressed = true;
self.long_pressed = true;
}
}
}
fn push_touch(&mut self, id: TouchId, phase: TouchPhase, position: glam::Vec2) {
self.touch_position = Some(position);
match phase {
TouchPhase::Started => {
if !self.ctx.ownership.pointer.pointer_inside()
|| self.contacts.iter().any(|c| c.id == id)
{
return;
}
self.contacts.push(Contact {
id,
origin: position,
position,
start_time: self.time,
travel: 0.0,
long_pressed: false,
});
self.rebaseline_touch();
}
TouchPhase::Moved => {
let Some(contact) = self.contacts.iter_mut().find(|c| c.id == id) else {
return;
};
contact.position = position;
contact.travel = contact.travel.max((position - contact.origin).length());
self.accumulate_touch();
}
TouchPhase::Ended | TouchPhase::Cancelled => {
let Some(index) = self.contacts.iter().position(|c| c.id == id) else {
return;
};
let contact = self.contacts.remove(index);
if matches!(phase, TouchPhase::Ended) {
self.finish_tap(&contact);
}
self.rebaseline_touch();
}
}
}
fn measure_touch(&self) -> Option<TouchMeasure> {
match self.contacts.len() {
1 => Some(TouchMeasure {
centroid: self.contacts[0].position,
spread: 0.0,
angle: 0.0,
}),
2 => {
let a = self.contacts[0].position;
let b = self.contacts[1].position;
let d = b - a;
Some(TouchMeasure {
centroid: (a + b) * 0.5,
spread: d.length(),
angle: d.y.atan2(d.x),
})
}
_ => None,
}
}
fn rebaseline_touch(&mut self) {
self.touch_ref = self.measure_touch();
}
fn accumulate_touch(&mut self) {
let Some(now) = self.measure_touch() else {
self.touch_ref = None;
return;
};
if let Some(prev) = self.touch_ref {
self.touch_drag += now.centroid - prev.centroid;
if prev.spread > 1.0 && now.spread > 1.0 {
self.touch_pinch += (now.spread / prev.spread).ln();
self.touch_twist += wrap_angle(now.angle - prev.angle);
}
}
self.touch_ref = Some(now);
}
fn finish_tap(&mut self, contact: &Contact) {
if contact.long_pressed || contact.travel > self.touch_settings.tap_tolerance {
return;
}
self.tapped = true;
if self.has_clock
&& let Some((origin, at)) = self.last_tap
&& self.time - at <= self.touch_settings.double_tap_interval
&& (contact.origin - origin).length() <= self.touch_settings.double_tap_distance
{
self.double_tapped = true;
}
self.last_tap = Some((contact.origin, self.time));
}
fn press_armed(&self) -> bool {
self.button_held
.iter()
.zip(self.button_press_pos.iter())
.any(|(held, press)| *held && press.is_some())
}
fn admits(&self, event: &ViewportEvent) -> bool {
let pointer = self.ctx.ownership.pointer;
let keyboard = self.ctx.ownership.keyboard == KeyboardOwnership::Owned;
match event {
ViewportEvent::Touch {
id,
phase: TouchPhase::Moved,
..
} => pointer.owns_input() || self.contacts.iter().any(|c| c.id == *id),
ViewportEvent::Key {
state: ButtonState::Released,
..
} => true,
ViewportEvent::Key { .. } | ViewportEvent::Character(_) => keyboard,
ev if ev.is_contested() && self.press_armed() => true,
ev => forward_to_viewport(ev, pointer),
}
}
pub fn push_event(&mut self, event: ViewportEvent) {
if !self.admits(&event) {
return;
}
match event {
ViewportEvent::PointerMoved { position } => {
if let Some(prev) = self.pointer_pos {
if self.button_held.iter().any(|&h| h) {
self.drag_delta += position - prev;
}
self.pointer_delta += position - prev;
}
self.pointer_pos = Some(position);
let left_origin = button_index(MouseButton::Left)
.filter(|&i| self.button_held[i])
.and_then(|i| self.button_press_pos[i]);
if let Some(origin) = left_origin {
if !self.left_drag_reached && (position - origin).length() >= CLICK_THRESHOLD_PX
{
self.left_drag_reached = true;
self.left_drag_began = true;
}
}
}
ViewportEvent::MouseButton { button, state } => {
if let Some(idx) = button_index(button) {
match state {
ButtonState::Pressed => {
let ours = self.ctx.ownership.pointer.owns_input();
self.button_held[idx] = true;
self.button_press_pos[idx] = if ours { self.pointer_pos } else { None };
if button == MouseButton::Left {
self.left_pressed = ours;
self.left_drag_reached = false;
}
}
ButtonState::Released => {
if button == MouseButton::Left {
let is_click = !self.left_drag_reached
&& self.button_press_pos[idx]
.zip(self.pointer_pos)
.map(|(origin, cur)| {
(cur - origin).length() < CLICK_THRESHOLD_PX
})
.unwrap_or(false);
self.left_drag_reached = false;
if is_click {
self.left_clicked = true;
}
}
self.button_held[idx] = false;
self.button_press_pos[idx] = None;
}
}
}
}
ViewportEvent::Wheel { delta, units } => {
let scale = match units {
ScrollUnits::Lines => PIXELS_PER_LINE,
ScrollUnits::Pixels => 1.0,
ScrollUnits::Pages => self.ctx.viewport_size[1].max(1.0),
};
if self.ctx.ownership.pointer.pointer_inside() {
self.wheel_delta += delta * scale;
}
}
ViewportEvent::ModifiersChanged(mods) => {
self.modifiers = mods;
}
ViewportEvent::Key {
key,
state,
repeat,
logical,
} => {
let ch = binding_char(key, logical);
match state {
ButtonState::Pressed => {
if !repeat {
self.keys_pressed.insert(key);
self.chars_pressed.extend(ch);
}
self.keys_held.insert(key);
if let Some(ch) = ch {
self.chars_held.insert(key, ch);
}
}
ButtonState::Released => {
self.keys_held.remove(&key);
self.chars_held.remove(&key);
}
}
}
ViewportEvent::Character(c) => {
if !c.is_control() {
self.text.push(c);
}
}
ViewportEvent::PointerLeft => {
self.pointer_pos = None;
for held in &mut self.button_held {
*held = false;
}
for pos in &mut self.button_press_pos {
*pos = None;
}
}
ViewportEvent::FocusLost => {
for held in &mut self.button_held {
*held = false;
}
for pos in &mut self.button_press_pos {
*pos = None;
}
self.contacts.clear();
self.touch_ref = None;
self.keys_held.clear();
self.keys_pressed.clear();
self.chars_held.clear();
self.chars_pressed.clear();
}
ViewportEvent::Touch {
id,
phase,
position,
} => self.push_touch(id, phase, position),
ViewportEvent::TrackpadRotate(angle) => {
if self.ctx.ownership.pointer.pointer_inside() && self.contacts.is_empty() {
self.rotate_gesture += angle;
}
}
ViewportEvent::TrackpadPinch(delta) => {
if self.ctx.ownership.pointer.pointer_inside() && self.contacts.is_empty() {
self.pinch_gesture += delta;
}
}
ViewportEvent::TrackpadPan(delta) => {
if self.ctx.ownership.pointer.pointer_inside() && self.contacts.is_empty() {
self.pan_gesture += delta;
}
}
_ => {}
}
}
pub fn resolve(&self) -> ActionFrame {
let mut orbit = glam::Vec2::ZERO;
let mut pan = glam::Vec2::ZERO;
let mut zoom = 0.0f32;
let mut actions = std::collections::HashMap::new();
let pointer_active = self.ctx.ownership.pointer.pointer_inside() || self.press_armed();
for binding in &self.bindings {
match &binding.gesture {
ViewportGesture::Drag { button, modifiers } => {
if !pointer_active {
continue;
}
let Some(idx) = button_index(*button) else {
continue;
};
let held = self.button_held[idx];
let press_started = self.button_press_pos[idx].is_some();
if held && press_started && modifiers.matches(self.modifiers) {
let delta = self.drag_delta;
match binding.action {
Action::Orbit => {
if orbit == glam::Vec2::ZERO {
orbit += delta;
actions
.entry(binding.action)
.or_insert(ResolvedActionState::Delta(delta));
}
}
Action::Pan => {
if pan == glam::Vec2::ZERO {
pan += delta;
actions
.entry(binding.action)
.or_insert(ResolvedActionState::Delta(delta));
}
}
Action::Zoom => {
if zoom == 0.0 {
zoom += delta.y;
actions
.entry(binding.action)
.or_insert(ResolvedActionState::Delta(delta));
}
}
_ => {
actions
.entry(binding.action)
.or_insert(ResolvedActionState::Delta(delta));
}
}
}
}
ViewportGesture::WheelY { modifiers } => {
if !pointer_active {
continue;
}
if modifiers.matches(self.modifiers) && self.wheel_delta.y != 0.0 {
let y = self.wheel_delta.y;
match binding.action {
Action::Zoom => zoom += y,
Action::Orbit => orbit.y += y,
Action::Pan => pan.y += y,
_ => {}
}
actions
.entry(binding.action)
.or_insert(ResolvedActionState::Delta(glam::Vec2::new(0.0, y)));
}
}
ViewportGesture::WheelXY { modifiers } => {
if !pointer_active {
continue;
}
if modifiers.matches(self.modifiers) && self.wheel_delta != glam::Vec2::ZERO {
let delta = self.wheel_delta;
match binding.action {
Action::Orbit => orbit += delta,
Action::Pan => pan += delta,
Action::Zoom => zoom += delta.y,
_ => {}
}
actions
.entry(binding.action)
.or_insert(ResolvedActionState::Delta(delta));
}
}
ViewportGesture::TouchDrag { contacts } => {
if usize::from(*contacts) != self.contacts.len()
|| self.touch_drag == glam::Vec2::ZERO
{
continue;
}
let delta = match binding.action {
Action::Orbit => self.touch_drag * self.touch_settings.orbit_sensitivity,
Action::Pan => self.touch_drag * self.touch_settings.pan_sensitivity,
_ => self.touch_drag,
};
match binding.action {
Action::Orbit => orbit += delta,
Action::Pan => pan += delta,
Action::Zoom => zoom += delta.y,
_ => {}
}
actions
.entry(binding.action)
.or_insert(ResolvedActionState::Delta(delta));
}
ViewportGesture::TouchPinch => {
if self.contacts.len() != 2 || self.touch_pinch == 0.0 {
continue;
}
let delta = self.touch_pinch
* self.touch_settings.pinch_sensitivity
* PINCH_PIXELS_PER_UNIT;
match binding.action {
Action::Zoom => zoom += delta,
Action::Orbit => orbit.y += delta,
Action::Pan => pan.y += delta,
_ => {}
}
actions
.entry(binding.action)
.or_insert(ResolvedActionState::Delta(glam::Vec2::new(0.0, delta)));
}
ViewportGesture::KeyPress { key, modifiers } => {
if self.keys_pressed.contains(key) && modifiers.matches(self.modifiers) {
actions
.entry(binding.action)
.or_insert(ResolvedActionState::Pressed);
}
}
ViewportGesture::KeyHold { key, modifiers } => {
if self.keys_held.contains(key) && modifiers.matches(self.modifiers) {
actions
.entry(binding.action)
.or_insert(ResolvedActionState::Held);
}
}
ViewportGesture::CharPress { ch, modifiers } => {
if self.chars_pressed.contains(&ch.to_ascii_lowercase())
&& modifiers.matches(self.modifiers)
{
actions
.entry(binding.action)
.or_insert(ResolvedActionState::Pressed);
}
}
ViewportGesture::CharHold { ch, modifiers } => {
let ch = ch.to_ascii_lowercase();
if self.chars_held.values().any(|c| *c == ch)
&& modifiers.matches(self.modifiers)
{
actions
.entry(binding.action)
.or_insert(ResolvedActionState::Held);
}
}
ViewportGesture::ModifiersHeld { modifiers } => {
if self.ctx.ownership.keyboard == KeyboardOwnership::Owned
&& modifiers.matches(self.modifiers)
{
actions
.entry(binding.action)
.or_insert(ResolvedActionState::Held);
}
}
_ => {}
}
}
let mut pointer = PointerFrame::default();
pointer.cursor = self.pointer_pos;
pointer.delta = self.pointer_delta;
pointer.clicked = self.left_clicked;
pointer.pressed = self.left_pressed;
pointer.drag_began = self.left_drag_began;
#[allow(deprecated)]
{
pointer.drag_started = self.left_pressed;
}
pointer.dragging = button_index(MouseButton::Left).is_some_and(|i| self.button_held[i]);
pointer.tapped = self.tapped;
pointer.double_tapped = self.double_tapped;
pointer.long_pressed = self.long_pressed;
pointer.touch_position = self.touch_position;
pointer.contacts = self.contacts.len() as u8;
let mut navigation = NavigationActions::default();
navigation.orbit = orbit;
navigation.pan = pan + self.pan_gesture;
navigation.zoom = zoom + self.pinch_gesture * PINCH_PIXELS_PER_UNIT;
navigation.twist =
self.rotate_gesture + self.touch_twist * self.touch_settings.twist_sensitivity;
let mut frame = ActionFrame::default();
frame.navigation = navigation;
frame.actions = actions;
frame.text = self.text.clone();
frame.pointer = pointer;
frame
}
pub fn modifiers(&self) -> Modifiers {
self.modifiers
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::input::context::{InputOwnership, PointerOwnership};
use crate::input::event::ButtonState;
use crate::input::preset::viewport_default_bindings;
use crate::input::viewport_binding::{ViewportBinding, ViewportGesture};
fn ctx(pointer: PointerOwnership, keyboard: KeyboardOwnership) -> ViewportContext {
ViewportContext::new(InputOwnership { pointer, keyboard }, [800.0, 600.0])
}
fn focused_ctx() -> ViewportContext {
ctx(PointerOwnership::Owned, KeyboardOwnership::Owned)
}
fn drag(input: &mut ViewportInput, from: glam::Vec2, to: glam::Vec2) -> ActionFrame {
input.push_event(ViewportEvent::PointerMoved { position: from });
input.push_event(ViewportEvent::MouseButton {
button: MouseButton::Left,
state: ButtonState::Pressed,
});
input.push_event(ViewportEvent::PointerMoved { position: to });
input.resolve()
}
fn press(input: &mut ViewportInput) {
input.push_event(ViewportEvent::MouseButton {
button: MouseButton::Left,
state: ButtonState::Pressed,
});
}
fn release(input: &mut ViewportInput) {
input.push_event(ViewportEvent::MouseButton {
button: MouseButton::Left,
state: ButtonState::Released,
});
}
fn move_to(input: &mut ViewportInput, x: f32, y: f32) {
input.push_event(ViewportEvent::PointerMoved {
position: glam::Vec2::new(x, y),
});
}
#[test]
fn pressed_fires_once_on_the_press_frame() {
let mut input = ViewportInput::new(viewer_bindings());
input.begin_frame(focused_ctx());
move_to(&mut input, 10.0, 10.0);
press(&mut input);
let frame = input.resolve();
assert!(frame.pointer.pressed);
assert!(!frame.pointer.drag_began, "no movement yet");
#[allow(deprecated)]
let started = frame.pointer.drag_started;
assert!(started, "the deprecated field keeps its value");
input.begin_frame(focused_ctx());
assert!(!input.resolve().pointer.pressed, "only on the press frame");
}
#[test]
fn drag_began_fires_once_when_the_threshold_is_reached() {
let mut input = ViewportInput::new(viewer_bindings());
input.begin_frame(focused_ctx());
move_to(&mut input, 10.0, 10.0);
press(&mut input);
input.resolve();
input.begin_frame(focused_ctx());
move_to(&mut input, 10.0 + CLICK_THRESHOLD_PX - 1.0, 10.0);
assert!(!input.resolve().pointer.drag_began, "under the threshold");
input.begin_frame(focused_ctx());
move_to(&mut input, 10.0 + CLICK_THRESHOLD_PX, 10.0);
assert!(input.resolve().pointer.drag_began, "at the threshold");
input.begin_frame(focused_ctx());
move_to(&mut input, 40.0, 10.0);
assert!(!input.resolve().pointer.drag_began, "once per press");
}
#[test]
fn a_press_released_under_the_threshold_clicks_without_a_drag() {
let mut input = ViewportInput::new(viewer_bindings());
input.begin_frame(focused_ctx());
move_to(&mut input, 10.0, 10.0);
press(&mut input);
move_to(&mut input, 12.0, 10.0);
release(&mut input);
let frame = input.resolve();
assert!(frame.pointer.clicked);
assert!(!frame.pointer.drag_began);
}
#[test]
fn a_drag_that_returns_to_its_press_point_is_not_a_click() {
let mut input = ViewportInput::new(viewer_bindings());
input.begin_frame(focused_ctx());
move_to(&mut input, 10.0, 10.0);
press(&mut input);
move_to(&mut input, 40.0, 10.0);
move_to(&mut input, 10.0, 10.0);
release(&mut input);
let frame = input.resolve();
assert!(frame.pointer.drag_began);
assert!(!frame.pointer.clicked);
input.begin_frame(focused_ctx());
press(&mut input);
release(&mut input);
assert!(input.resolve().pointer.clicked);
}
#[test]
fn a_gesture_is_active_only_between_press_and_release() {
let mut input = ViewportInput::new(viewer_bindings());
input.begin_frame(focused_ctx());
assert!(!input.is_gesture_active(), "nothing held to begin with");
input.push_event(ViewportEvent::PointerMoved {
position: glam::Vec2::new(10.0, 10.0),
});
assert!(!input.is_gesture_active(), "a bare move is not a gesture");
input.push_event(ViewportEvent::MouseButton {
button: MouseButton::Left,
state: ButtonState::Pressed,
});
assert!(input.is_gesture_active(), "the press starts one");
input.push_event(ViewportEvent::MouseButton {
button: MouseButton::Left,
state: ButtonState::Released,
});
assert!(!input.is_gesture_active(), "the release ends it");
}
#[test]
fn cancelling_stops_the_drag_on_the_frame_it_happens() {
let mut input = ViewportInput::new(viewer_bindings());
input.begin_frame(focused_ctx());
input.push_event(ViewportEvent::PointerMoved {
position: glam::Vec2::new(10.0, 10.0),
});
input.push_event(ViewportEvent::MouseButton {
button: MouseButton::Left,
state: ButtonState::Pressed,
});
input.push_event(ViewportEvent::PointerMoved {
position: glam::Vec2::new(40.0, 10.0),
});
input.cancel_gesture();
assert!(!input.is_gesture_active());
let frame = input.resolve();
assert_eq!(
frame.navigation.orbit,
glam::Vec2::ZERO,
"the partial drag must not be applied on the frame it was cancelled",
);
}
#[test]
fn a_cancelled_drag_does_not_resume_when_the_pointer_moves_again() {
let mut input = ViewportInput::new(viewer_bindings());
input.begin_frame(focused_ctx());
drag(
&mut input,
glam::Vec2::new(10.0, 10.0),
glam::Vec2::new(40.0, 10.0),
);
input.cancel_gesture();
input.begin_frame(focused_ctx());
input.push_event(ViewportEvent::PointerMoved {
position: glam::Vec2::new(90.0, 10.0),
});
let frame = input.resolve();
assert_eq!(
frame.navigation.orbit,
glam::Vec2::ZERO,
"the button is no longer held, so moving must not orbit",
);
assert!(!input.is_gesture_active());
}
#[test]
fn cancelling_leaves_keyboard_state_alone() {
let mut input = ViewportInput::new(viewport_default_bindings());
input.begin_frame(focused_ctx());
input.push_event(ViewportEvent::Key {
key: KeyCode::W,
state: ButtonState::Pressed,
repeat: false,
logical: None,
});
input.cancel_gesture();
let frame = input.resolve();
assert!(
frame.is_active(Action::FlyForward),
"W is still held after cancelling a pointer gesture",
);
}
#[test]
fn key_press_fires_once_then_clears() {
let mut input = ViewportInput::new(viewport_default_bindings());
input.begin_frame(focused_ctx());
input.push_event(ViewportEvent::Key {
key: KeyCode::F,
state: ButtonState::Pressed,
repeat: false,
logical: None,
});
let frame = input.resolve();
assert!(
frame.is_active(Action::FocusObject),
"FocusObject should be active on first frame"
);
input.begin_frame(focused_ctx());
let frame2 = input.resolve();
assert!(
!frame2.is_active(Action::FocusObject),
"FocusObject should not be active on second frame"
);
}
#[test]
fn key_ignored_when_not_focused() {
let mut input = ViewportInput::new(viewport_default_bindings());
input.begin_frame(ctx(PointerOwnership::Owned, KeyboardOwnership::Elsewhere));
input.push_event(ViewportEvent::Key {
key: KeyCode::F,
state: ButtonState::Pressed,
repeat: false,
logical: None,
});
let frame = input.resolve();
assert!(
!frame.is_active(Action::FocusObject),
"key should be ignored without focus"
);
}
#[test]
fn resolve_no_events_is_zero() {
let mut input = ViewportInput::new(viewport_default_bindings());
input.begin_frame(focused_ctx());
let frame = input.resolve();
assert_eq!(frame.navigation.orbit, glam::Vec2::ZERO);
assert_eq!(frame.navigation.pan, glam::Vec2::ZERO);
assert_eq!(frame.navigation.zoom, 0.0);
assert_eq!(frame.navigation.twist, 0.0);
assert!(frame.actions.is_empty());
}
#[test]
fn scroll_produces_zoom() {
let mut input = ViewportInput::new(viewport_default_bindings());
input.begin_frame(focused_ctx());
input.push_event(ViewportEvent::Wheel {
delta: glam::Vec2::new(0.0, 3.0),
units: ScrollUnits::Lines,
});
let frame = input.resolve();
assert!((frame.navigation.zoom - 84.0).abs() < 1e-3);
}
#[test]
fn scroll_pixel_units_no_scaling() {
let mut input = ViewportInput::new(viewport_default_bindings());
input.begin_frame(focused_ctx());
input.push_event(ViewportEvent::Wheel {
delta: glam::Vec2::new(0.0, 10.0),
units: ScrollUnits::Pixels,
});
let frame = input.resolve();
assert!((frame.navigation.zoom - 10.0).abs() < 1e-3);
}
#[test]
fn scroll_ignored_when_not_hovered() {
let mut input = ViewportInput::new(viewport_default_bindings());
input.begin_frame(ctx(PointerOwnership::Elsewhere, KeyboardOwnership::Owned));
input.push_event(ViewportEvent::Wheel {
delta: glam::Vec2::new(0.0, 5.0),
units: ScrollUnits::Lines,
});
let frame = input.resolve();
assert_eq!(frame.navigation.zoom, 0.0);
}
#[test]
fn neither_left_nor_right_drag_touches_the_camera() {
for button in [MouseButton::Left, MouseButton::Right] {
let mut input = ViewportInput::new(viewport_default_bindings());
input.begin_frame(focused_ctx());
input.push_event(ViewportEvent::PointerMoved {
position: glam::Vec2::new(100.0, 100.0),
});
input.push_event(ViewportEvent::MouseButton {
button,
state: ButtonState::Pressed,
});
input.push_event(ViewportEvent::PointerMoved {
position: glam::Vec2::new(110.0, 105.0),
});
let frame = input.resolve();
assert_eq!(frame.navigation.pan, glam::Vec2::ZERO, "{button:?} panned");
assert_eq!(
frame.navigation.orbit,
glam::Vec2::ZERO,
"{button:?} orbited"
);
}
}
#[test]
fn middle_drag_orbits_and_shift_middle_pans() {
let cases = [
(Modifiers::NONE, true, false),
(Modifiers::SHIFT, false, true),
];
for (modifiers, want_orbit, want_pan) in cases {
let mut input = ViewportInput::new(viewport_default_bindings());
input.begin_frame(focused_ctx());
input.push_event(ViewportEvent::ModifiersChanged(modifiers));
input.push_event(ViewportEvent::PointerMoved {
position: glam::Vec2::new(100.0, 100.0),
});
input.push_event(ViewportEvent::MouseButton {
button: MouseButton::Middle,
state: ButtonState::Pressed,
});
input.push_event(ViewportEvent::PointerMoved {
position: glam::Vec2::new(110.0, 105.0),
});
let frame = input.resolve();
assert_eq!(
frame.navigation.orbit != glam::Vec2::ZERO,
want_orbit,
"orbit with {modifiers:?}"
);
assert_eq!(
frame.navigation.pan != glam::Vec2::ZERO,
want_pan,
"pan with {modifiers:?}"
);
}
}
#[test]
fn the_viewer_preset_adds_left_drag_orbit() {
let mut input = ViewportInput::new(viewer_bindings());
input.begin_frame(focused_ctx());
input.push_event(ViewportEvent::PointerMoved {
position: glam::Vec2::new(100.0, 100.0),
});
input.push_event(ViewportEvent::MouseButton {
button: MouseButton::Left,
state: ButtonState::Pressed,
});
input.push_event(ViewportEvent::PointerMoved {
position: glam::Vec2::new(110.0, 105.0),
});
assert_ne!(input.resolve().navigation.orbit, glam::Vec2::ZERO);
}
#[test]
fn pointer_move_without_button_no_drag() {
let mut input = ViewportInput::new(viewport_default_bindings());
input.begin_frame(focused_ctx());
input.push_event(ViewportEvent::PointerMoved {
position: glam::Vec2::new(100.0, 100.0),
});
input.push_event(ViewportEvent::PointerMoved {
position: glam::Vec2::new(200.0, 200.0),
});
let frame = input.resolve();
assert_eq!(frame.navigation.orbit, glam::Vec2::ZERO);
assert_eq!(frame.navigation.pan, glam::Vec2::ZERO);
}
#[test]
fn begin_frame_resets_accumulators() {
let mut input = ViewportInput::new(viewport_default_bindings());
input.begin_frame(focused_ctx());
input.push_event(ViewportEvent::Wheel {
delta: glam::Vec2::new(0.0, 5.0),
units: ScrollUnits::Pixels,
});
let frame1 = input.resolve();
assert!(frame1.navigation.zoom != 0.0);
input.begin_frame(focused_ctx());
let frame2 = input.resolve();
assert_eq!(frame2.navigation.zoom, 0.0);
}
#[test]
fn pointer_left_releases_buttons() {
let mut input = ViewportInput::new(viewport_default_bindings());
input.begin_frame(focused_ctx());
input.push_event(ViewportEvent::PointerMoved {
position: glam::Vec2::new(100.0, 100.0),
});
input.push_event(ViewportEvent::MouseButton {
button: MouseButton::Right,
state: ButtonState::Pressed,
});
input.push_event(ViewportEvent::PointerLeft);
input.push_event(ViewportEvent::PointerMoved {
position: glam::Vec2::new(200.0, 200.0),
});
let frame = input.resolve();
assert_eq!(frame.navigation.pan, glam::Vec2::ZERO);
}
#[test]
fn focus_lost_clears_keys() {
let mut input = ViewportInput::new(viewport_default_bindings());
input.begin_frame(focused_ctx());
input.push_event(ViewportEvent::Key {
key: KeyCode::W,
state: ButtonState::Pressed,
repeat: false,
logical: None,
});
input.push_event(ViewportEvent::FocusLost);
let frame = input.resolve();
assert!(
!frame.is_active(Action::FlyForward),
"FlyForward should not be active after focus lost"
);
}
#[test]
fn focus_lost_releases_held_buttons_and_contacts() {
let mut input = ViewportInput::new(viewport_default_bindings());
input.begin_frame(focused_ctx());
move_to(&mut input, 100.0, 100.0);
input.push_event(ViewportEvent::MouseButton {
button: MouseButton::Middle,
state: ButtonState::Pressed,
});
touch(&mut input, 1, TouchPhase::Started, 50.0, 50.0);
assert!(input.is_gesture_active());
input.push_event(ViewportEvent::FocusLost);
assert!(!input.is_gesture_active(), "focus loss ends every gesture");
input.begin_frame(focused_ctx());
move_to(&mut input, 140.0, 120.0);
let frame = input.resolve();
assert_eq!(frame.navigation.orbit, glam::Vec2::ZERO);
assert_eq!(frame.pointer.contacts, 0);
}
#[test]
fn a_drag_that_landed_inside_keeps_going_outside() {
let mut input = ViewportInput::new(viewport_default_bindings());
input.begin_frame(focused_ctx());
move_to(&mut input, 100.0, 100.0);
input.push_event(ViewportEvent::MouseButton {
button: MouseButton::Middle,
state: ButtonState::Pressed,
});
input.resolve();
input.begin_frame(ctx(
PointerOwnership::Elsewhere,
KeyboardOwnership::Elsewhere,
));
move_to(&mut input, 900.0, 100.0);
let frame = input.resolve();
assert_ne!(frame.navigation.orbit, glam::Vec2::ZERO);
}
#[test]
fn the_wheel_accrues_under_chrome_over_the_viewport() {
let mut input = ViewportInput::new(viewport_default_bindings());
input.begin_frame(ctx(PointerOwnership::Inside, KeyboardOwnership::Elsewhere));
input.push_event(ViewportEvent::Wheel {
delta: glam::Vec2::new(0.0, 1.0),
units: ScrollUnits::Lines,
});
assert!(input.resolve().navigation.zoom != 0.0);
}
fn button(input: &mut ViewportInput, button: MouseButton, state: ButtonState) {
input.push_event(ViewportEvent::MouseButton { button, state });
}
fn drag_orbits(b: MouseButton) -> ViewportInput {
ViewportInput::new(vec![ViewportBinding::new(
Action::Orbit,
ViewportGesture::Drag {
button: b,
modifiers: crate::input::ModifiersMatch::Any,
},
)])
}
fn pointer_ctx(pointer: PointerOwnership) -> ViewportContext {
ctx(pointer, KeyboardOwnership::Owned)
}
#[test]
fn a_left_press_on_chrome_over_the_viewport_is_dropped() {
let mut input = ViewportInput::new(viewer_bindings());
input.begin_frame(pointer_ctx(PointerOwnership::Owned));
move_to(&mut input, 10.0, 10.0);
input.resolve();
input.begin_frame(pointer_ctx(PointerOwnership::Inside));
press(&mut input);
move_to(&mut input, 60.0, 10.0);
let frame = input.resolve();
assert!(!frame.pointer.pressed);
assert!(!input.is_gesture_active());
assert_eq!(frame.navigation.orbit, glam::Vec2::ZERO);
}
#[test]
fn a_release_under_elsewhere_still_lands() {
let mut input = ViewportInput::new(viewer_bindings());
input.begin_frame(pointer_ctx(PointerOwnership::Owned));
move_to(&mut input, 10.0, 10.0);
press(&mut input);
input.resolve();
input.begin_frame(pointer_ctx(PointerOwnership::Elsewhere));
release(&mut input);
assert!(!input.is_gesture_active());
assert!(input.button_held.iter().all(|h| !h), "no button stays held");
move_to(&mut input, 80.0, 10.0);
assert_eq!(input.resolve().navigation.orbit, glam::Vec2::ZERO);
}
#[test]
fn a_drag_of_ours_survives_chrome_and_leaving_with_any_button() {
for b in [MouseButton::Left, MouseButton::Right, MouseButton::Middle] {
let mut input = drag_orbits(b);
input.begin_frame(pointer_ctx(PointerOwnership::Owned));
move_to(&mut input, 100.0, 100.0);
button(&mut input, b, ButtonState::Pressed);
input.resolve();
for ownership in [PointerOwnership::Inside, PointerOwnership::Elsewhere] {
input.begin_frame(pointer_ctx(ownership));
let x = input.pointer_pos.unwrap().x + 20.0;
move_to(&mut input, x, 100.0);
let frame = input.resolve();
assert_eq!(
frame.navigation.orbit,
glam::Vec2::new(20.0, 0.0),
"{b:?} under {ownership:?}"
);
}
input.begin_frame(pointer_ctx(PointerOwnership::Elsewhere));
button(&mut input, b, ButtonState::Released);
assert!(!input.is_gesture_active(), "{b:?} released");
}
}
#[test]
fn a_right_press_elsewhere_does_not_orbit() {
let mut input = drag_orbits(MouseButton::Right);
input.begin_frame(pointer_ctx(PointerOwnership::Owned));
move_to(&mut input, 100.0, 100.0);
input.resolve();
for ownership in [PointerOwnership::Elsewhere, PointerOwnership::Inside] {
input.begin_frame(pointer_ctx(ownership));
button(&mut input, MouseButton::Right, ButtonState::Pressed);
move_to(&mut input, 150.0, 120.0);
let frame = input.resolve();
assert_eq!(frame.navigation.orbit, glam::Vec2::ZERO, "{ownership:?}");
assert!(!input.is_gesture_active());
input.begin_frame(pointer_ctx(PointerOwnership::Owned));
move_to(&mut input, 160.0, 120.0);
move_to(&mut input, 190.0, 120.0);
assert_eq!(input.resolve().navigation.orbit, glam::Vec2::ZERO);
button(&mut input, MouseButton::Right, ButtonState::Released);
assert!(input.button_held.iter().all(|h| !h), "no button stays held");
move_to(&mut input, 100.0, 100.0);
}
}
#[test]
fn a_contact_of_ours_keeps_moving_under_chrome() {
let mut input = ViewportInput::new(viewport_default_bindings());
input.begin_frame(pointer_ctx(PointerOwnership::Owned));
touch(&mut input, 1, TouchPhase::Started, 100.0, 100.0);
input.resolve();
input.begin_frame(pointer_ctx(PointerOwnership::Inside));
touch(&mut input, 1, TouchPhase::Moved, 130.0, 100.0);
let frame = input.resolve();
assert_eq!(frame.pointer.contacts, 1);
assert_ne!(frame.navigation.orbit, glam::Vec2::ZERO);
input.begin_frame(pointer_ctx(PointerOwnership::Inside));
touch(&mut input, 1, TouchPhase::Ended, 130.0, 100.0);
touch(&mut input, 2, TouchPhase::Started, 100.0, 100.0);
touch(&mut input, 2, TouchPhase::Moved, 140.0, 100.0);
let frame = input.resolve();
assert_eq!(frame.pointer.contacts, 0);
assert_eq!(frame.navigation.orbit, glam::Vec2::ZERO);
}
#[test]
fn a_cancelled_press_is_not_followed_under_chrome() {
let mut input = ViewportInput::new(viewer_bindings());
input.begin_frame(pointer_ctx(PointerOwnership::Owned));
move_to(&mut input, 10.0, 10.0);
press(&mut input);
input.resolve();
input.cancel_gesture();
input.begin_frame(pointer_ctx(PointerOwnership::Inside));
let before = input.pointer_pos;
move_to(&mut input, 60.0, 10.0);
let frame = input.resolve();
assert_eq!(input.pointer_pos, before, "the move did not reach us");
assert_eq!(frame.navigation.orbit, glam::Vec2::ZERO);
assert_eq!(frame.pointer.delta, glam::Vec2::ZERO);
}
#[test]
fn a_shift_middle_drag_pans_while_a_text_field_has_the_keyboard() {
let mut input = ViewportInput::new(viewport_default_bindings());
input.begin_frame(ctx(PointerOwnership::Owned, KeyboardOwnership::Elsewhere));
input.push_event(ViewportEvent::ModifiersChanged(Modifiers::SHIFT));
move_to(&mut input, 100.0, 100.0);
button(&mut input, MouseButton::Middle, ButtonState::Pressed);
move_to(&mut input, 110.0, 105.0);
let frame = input.resolve();
assert_ne!(frame.navigation.pan, glam::Vec2::ZERO);
assert_eq!(frame.navigation.orbit, glam::Vec2::ZERO);
assert!(!frame.is_active(Action::FlySpeedBoost));
input.begin_frame(focused_ctx());
assert!(input.resolve().is_active(Action::FlySpeedBoost));
}
#[test]
fn a_key_held_when_the_keyboard_moves_away_is_released() {
let mut input = ViewportInput::new(viewport_default_bindings());
input.begin_frame(focused_ctx());
input.push_event(ViewportEvent::Key {
key: KeyCode::W,
state: ButtonState::Pressed,
repeat: false,
logical: Some('w'),
});
assert!(input.resolve().is_active(Action::FlyForward));
input.begin_frame(ctx(PointerOwnership::Owned, KeyboardOwnership::Elsewhere));
input.push_event(ViewportEvent::Key {
key: KeyCode::W,
state: ButtonState::Released,
repeat: false,
logical: Some('w'),
});
input.begin_frame(focused_ctx());
assert!(!input.resolve().is_active(Action::FlyForward));
}
#[test]
fn set_ownership_routes_the_rest_of_the_frame() {
let mut input = ViewportInput::new(viewer_bindings());
input.begin_frame(pointer_ctx(PointerOwnership::Elsewhere));
move_to(&mut input, 10.0, 10.0);
assert_eq!(input.pointer_pos, None);
input.set_ownership(InputOwnership::full_window());
move_to(&mut input, 10.0, 10.0);
press(&mut input);
assert!(input.is_gesture_active());
}
fn key(input: &mut ViewportInput, key: KeyCode, logical: Option<char>, state: ButtonState) {
input.push_event(ViewportEvent::Key {
key,
state,
repeat: false,
logical,
});
}
const TOOL_G: Action = Action::Custom(0x1000_0000);
const TOOL_X: Action = Action::Custom(0x1000_0001);
const TOOL_Y: Action = Action::Custom(0x1000_0002);
const TOOL_Z: Action = Action::Custom(0x1000_0003);
const TOOL_SHIFT_X: Action = Action::Custom(0x1000_0004);
fn tool_bindings() -> Vec<ViewportBinding> {
use crate::input::ModifiersMatch;
let none = ModifiersMatch::Exact(Modifiers::NONE);
let shift = ModifiersMatch::Contains(Modifiers::SHIFT);
let char_press = |action, ch, modifiers| {
ViewportBinding::new(action, ViewportGesture::CharPress { ch, modifiers })
};
vec![
char_press(TOOL_G, 'g', none),
char_press(TOOL_X, 'x', none),
char_press(TOOL_Y, 'y', none),
char_press(TOOL_Z, 'z', none),
char_press(TOOL_SHIFT_X, 'x', shift),
]
}
#[test]
fn appended_bindings_fire_alongside_the_preset() {
let mut input =
ViewportInput::from_preset(BindingPreset::Default).with_bindings(tool_bindings());
input.begin_frame(focused_ctx());
key(&mut input, KeyCode::G, Some('g'), ButtonState::Pressed);
key(&mut input, KeyCode::F, Some('f'), ButtonState::Pressed);
let frame = input.resolve();
assert!(frame.is_active(TOOL_G));
assert!(frame.is_active(Action::FocusObject), "the preset is kept");
}
#[test]
fn the_default_preset_binds_no_characters() {
assert!(!viewport_default_bindings().iter().any(|b| matches!(
b.gesture,
ViewportGesture::CharPress { .. } | ViewportGesture::CharHold { .. }
)));
}
#[test]
fn a_qwertz_z_constrains_to_z() {
let mut input = ViewportInput::new(tool_bindings());
input.begin_frame(focused_ctx());
key(&mut input, KeyCode::Y, Some('z'), ButtonState::Pressed);
let frame = input.resolve();
assert!(frame.is_active(TOOL_Z));
assert!(!frame.is_active(TOOL_Y));
}
#[test]
fn an_application_action_fires_like_a_built_in_one() {
const TOGGLE_WIREFRAME: Action = Action::Custom(7);
let mut input = ViewportInput::new(vec![ViewportBinding::new(
TOGGLE_WIREFRAME,
ViewportGesture::CharPress {
ch: 'w',
modifiers: crate::input::ModifiersMatch::Exact(Modifiers::NONE),
},
)]);
input.begin_frame(focused_ctx());
key(&mut input, KeyCode::W, Some('w'), ButtonState::Pressed);
assert!(input.resolve().is_active(TOGGLE_WIREFRAME));
let mut ctx = focused_ctx();
ctx.ownership.keyboard = KeyboardOwnership::Elsewhere;
input.begin_frame(ctx);
key(&mut input, KeyCode::W, Some('w'), ButtonState::Pressed);
assert!(!input.resolve().is_active(TOGGLE_WIREFRAME));
}
#[test]
fn a_cyrillic_layout_keeps_g_where_it_is() {
let mut input = ViewportInput::new(tool_bindings());
input.begin_frame(focused_ctx());
key(
&mut input,
KeyCode::G,
Some('\u{43f}'),
ButtonState::Pressed,
);
assert!(input.resolve().is_active(TOOL_G));
}
#[test]
fn a_char_binding_folds_case_and_reads_shift_from_the_modifiers() {
let mut input = ViewportInput::new(vec![ViewportBinding::new(
TOOL_G,
ViewportGesture::CharPress {
ch: 'g',
modifiers: crate::input::ModifiersMatch::Exact(Modifiers::SHIFT),
},
)]);
input.begin_frame(focused_ctx());
input.push_event(ViewportEvent::ModifiersChanged(Modifiers::SHIFT));
key(&mut input, KeyCode::G, Some('G'), ButtonState::Pressed);
assert!(input.resolve().is_active(TOOL_G));
input.begin_frame(focused_ctx());
input.push_event(ViewportEvent::ModifiersChanged(Modifiers::NONE));
key(&mut input, KeyCode::G, Some('g'), ButtonState::Released);
key(&mut input, KeyCode::G, Some('g'), ButtonState::Pressed);
assert!(!input.resolve().is_active(TOOL_G));
}
#[test]
fn a_char_hold_lasts_until_its_key_is_released() {
let mut input = ViewportInput::new(vec![ViewportBinding::new(
Action::FlyForward,
ViewportGesture::CharHold {
ch: 'w',
modifiers: crate::input::ModifiersMatch::Any,
},
)]);
input.begin_frame(focused_ctx());
key(&mut input, KeyCode::W, Some('z'), ButtonState::Pressed);
assert!(!input.resolve().is_active(Action::FlyForward));
key(&mut input, KeyCode::W, Some('z'), ButtonState::Released);
input.begin_frame(focused_ctx());
key(&mut input, KeyCode::Z, Some('w'), ButtonState::Pressed);
assert!(input.resolve().is_active(Action::FlyForward));
input.begin_frame(focused_ctx());
assert!(input.resolve().is_active(Action::FlyForward), "still held");
key(&mut input, KeyCode::Z, None, ButtonState::Released);
input.begin_frame(focused_ctx());
assert!(!input.resolve().is_active(Action::FlyForward));
}
#[test]
fn char_bindings_need_the_keyboard() {
let mut input = ViewportInput::new(tool_bindings());
input.begin_frame(ctx(PointerOwnership::Owned, KeyboardOwnership::Elsewhere));
key(&mut input, KeyCode::G, Some('g'), ButtonState::Pressed);
assert!(!input.resolve().is_active(TOOL_G));
}
#[test]
fn character_event_populates_text() {
let mut input = ViewportInput::new(viewport_default_bindings());
input.begin_frame(focused_ctx());
input.push_event(ViewportEvent::Character('3'));
input.push_event(ViewportEvent::Character('.'));
input.push_event(ViewportEvent::Character('5'));
input.push_event(ViewportEvent::Character('a'));
input.push_event(ViewportEvent::Character('\r')); let frame = input.resolve();
assert_eq!(frame.text, vec!['3', '.', '5', 'a']);
}
#[test]
fn character_event_ignored_when_unfocused() {
let mut input = ViewportInput::new(viewport_default_bindings());
input.begin_frame(ctx(PointerOwnership::Owned, KeyboardOwnership::Elsewhere));
input.push_event(ViewportEvent::Character('3'));
let frame = input.resolve();
assert!(frame.text.is_empty());
}
#[test]
fn trackpad_rotate_accumulates_twist() {
let mut input = ViewportInput::new(viewport_default_bindings());
input.begin_frame(focused_ctx());
input.push_event(ViewportEvent::TrackpadRotate(0.1));
input.push_event(ViewportEvent::TrackpadRotate(0.2));
let frame = input.resolve();
assert!((frame.navigation.twist - 0.3).abs() < 1e-5);
}
fn touch(input: &mut ViewportInput, id: u64, phase: TouchPhase, x: f32, y: f32) {
input.push_event(ViewportEvent::Touch {
id: TouchId(id),
phase,
position: glam::Vec2::new(x, y),
});
}
#[test]
fn one_finger_drags_the_camera_and_two_pan_it() {
let mut input = ViewportInput::new(viewport_default_bindings());
input.begin_frame(focused_ctx());
touch(&mut input, 1, TouchPhase::Started, 100.0, 100.0);
touch(&mut input, 1, TouchPhase::Moved, 130.0, 100.0);
let frame = input.resolve();
assert_eq!(frame.navigation.orbit, glam::Vec2::new(30.0, 0.0));
assert_eq!(
frame.navigation.pan,
glam::Vec2::ZERO,
"one finger does not pan"
);
assert_eq!(frame.pointer.contacts, 1);
input.begin_frame(focused_ctx());
touch(&mut input, 2, TouchPhase::Started, 200.0, 100.0);
touch(&mut input, 1, TouchPhase::Moved, 150.0, 100.0);
touch(&mut input, 2, TouchPhase::Moved, 220.0, 100.0);
let frame = input.resolve();
assert_eq!(frame.navigation.pan, glam::Vec2::new(20.0, 0.0));
assert_eq!(
frame.navigation.orbit,
glam::Vec2::ZERO,
"two fingers do not orbit"
);
}
#[test]
fn spreading_two_fingers_zooms_in_and_turning_them_twists() {
let mut input = ViewportInput::new(viewport_default_bindings());
input.begin_frame(focused_ctx());
touch(&mut input, 1, TouchPhase::Started, 100.0, 100.0);
touch(&mut input, 2, TouchPhase::Started, 200.0, 100.0);
touch(&mut input, 1, TouchPhase::Moved, 50.0, 100.0);
touch(&mut input, 2, TouchPhase::Moved, 250.0, 100.0);
let frame = input.resolve();
assert!(frame.navigation.zoom > 0.0, "got {}", frame.navigation.zoom);
assert!(
frame.navigation.pan.length() < 1e-4,
"a symmetric spread does not pan"
);
input.begin_frame(focused_ctx());
touch(&mut input, 1, TouchPhase::Moved, 150.0, 0.0);
touch(&mut input, 2, TouchPhase::Moved, 150.0, 200.0);
let frame = input.resolve();
assert!(
frame.navigation.twist.abs() > 1.0,
"got {}",
frame.navigation.twist
);
}
#[test]
fn lifting_one_of_two_fingers_does_not_throw_the_camera() {
let mut input = ViewportInput::new(viewport_default_bindings());
input.begin_frame(focused_ctx());
touch(&mut input, 1, TouchPhase::Started, 100.0, 100.0);
touch(&mut input, 2, TouchPhase::Started, 300.0, 100.0);
input.begin_frame(focused_ctx());
touch(&mut input, 2, TouchPhase::Ended, 300.0, 100.0);
let frame = input.resolve();
assert_eq!(
frame.navigation.orbit,
glam::Vec2::ZERO,
"the centroid moving 100px because a finger lifted is not an orbit",
);
input.begin_frame(focused_ctx());
touch(&mut input, 1, TouchPhase::Moved, 110.0, 100.0);
let frame = input.resolve();
assert_eq!(frame.navigation.orbit, glam::Vec2::new(10.0, 0.0));
}
#[test]
fn a_third_finger_parks_the_gesture() {
let mut input = ViewportInput::new(viewport_default_bindings());
input.begin_frame(focused_ctx());
touch(&mut input, 1, TouchPhase::Started, 100.0, 100.0);
touch(&mut input, 2, TouchPhase::Started, 200.0, 100.0);
touch(&mut input, 3, TouchPhase::Started, 300.0, 100.0);
input.begin_frame(focused_ctx());
touch(&mut input, 1, TouchPhase::Moved, 150.0, 150.0);
let frame = input.resolve();
assert_eq!(frame.pointer.contacts, 3);
assert_eq!(frame.navigation.orbit, glam::Vec2::ZERO);
assert_eq!(frame.navigation.pan, glam::Vec2::ZERO);
assert_eq!(frame.navigation.zoom, 0.0);
}
#[test]
fn a_cancelled_contact_leaves_nothing_behind() {
let mut input = ViewportInput::new(viewport_default_bindings());
input.begin_frame(focused_ctx());
touch(&mut input, 1, TouchPhase::Started, 100.0, 100.0);
touch(&mut input, 1, TouchPhase::Moved, 105.0, 100.0);
touch(&mut input, 1, TouchPhase::Cancelled, 105.0, 100.0);
let frame = input.resolve();
assert_eq!(frame.pointer.contacts, 0);
assert!(!frame.pointer.tapped, "a cancelled contact is not a tap");
assert!(!input.is_gesture_active());
input.begin_frame(focused_ctx());
touch(&mut input, 1, TouchPhase::Moved, 400.0, 100.0);
assert_eq!(input.resolve().navigation.orbit, glam::Vec2::ZERO);
}
#[test]
fn a_short_contact_taps_and_a_long_travel_does_not() {
let mut input = ViewportInput::new(viewport_default_bindings());
input.begin_frame(focused_ctx());
touch(&mut input, 1, TouchPhase::Started, 100.0, 100.0);
touch(&mut input, 1, TouchPhase::Ended, 102.0, 100.0);
let frame = input.resolve();
assert!(frame.pointer.tapped);
assert_eq!(
frame.pointer.touch_position,
Some(glam::Vec2::new(102.0, 100.0))
);
input.begin_frame(focused_ctx());
touch(&mut input, 2, TouchPhase::Started, 100.0, 100.0);
touch(&mut input, 2, TouchPhase::Moved, 300.0, 100.0);
touch(&mut input, 2, TouchPhase::Ended, 300.0, 100.0);
assert!(!input.resolve().pointer.tapped, "a drag is not a tap");
}
#[test]
fn a_second_tap_doubles_only_when_it_is_soon_and_close() {
let mut input = ViewportInput::new(viewport_default_bindings());
let tap = |input: &mut ViewportInput, id, x: f32| {
touch(input, id, TouchPhase::Started, x, 100.0);
touch(input, id, TouchPhase::Ended, x, 100.0);
};
input.begin_frame_at(focused_ctx(), 0.0);
tap(&mut input, 1, 100.0);
assert!(
!input.resolve().pointer.double_tapped,
"the first tap is not a double"
);
input.begin_frame_at(focused_ctx(), 0.1);
tap(&mut input, 2, 105.0);
assert!(input.resolve().pointer.double_tapped);
assert!(input.resolve().pointer.tapped, "a double tap is also a tap");
input.begin_frame_at(focused_ctx(), 5.0);
tap(&mut input, 3, 105.0);
assert!(!input.resolve().pointer.double_tapped);
input.begin_frame_at(focused_ctx(), 5.1);
tap(&mut input, 4, 600.0);
assert!(!input.resolve().pointer.double_tapped);
}
#[test]
fn a_held_finger_long_presses_once_and_then_is_not_a_tap() {
let mut input = ViewportInput::new(viewport_default_bindings());
input.begin_frame_at(focused_ctx(), 0.0);
touch(&mut input, 1, TouchPhase::Started, 100.0, 100.0);
assert!(!input.resolve().pointer.long_pressed, "not yet");
input.begin_frame_at(focused_ctx(), 1.0);
assert!(input.resolve().pointer.long_pressed, "the dwell has passed");
input.begin_frame_at(focused_ctx(), 1.1);
assert!(!input.resolve().pointer.long_pressed, "it fires once");
input.begin_frame_at(focused_ctx(), 1.2);
touch(&mut input, 1, TouchPhase::Ended, 100.0, 100.0);
assert!(
!input.resolve().pointer.tapped,
"lifting after a long press is not also a tap",
);
}
#[test]
fn a_long_press_needs_a_clock_and_a_still_finger() {
let mut input = ViewportInput::new(viewport_default_bindings());
input.begin_frame(focused_ctx());
touch(&mut input, 1, TouchPhase::Started, 100.0, 100.0);
for _ in 0..10 {
input.begin_frame(focused_ctx());
assert!(!input.resolve().pointer.long_pressed);
}
let mut input = ViewportInput::new(viewport_default_bindings());
input.begin_frame_at(focused_ctx(), 0.0);
touch(&mut input, 2, TouchPhase::Started, 100.0, 100.0);
touch(&mut input, 2, TouchPhase::Moved, 200.0, 100.0);
input.begin_frame_at(focused_ctx(), 2.0);
assert!(!input.resolve().pointer.long_pressed);
}
#[test]
fn contacts_win_over_the_hosts_own_gesture_events() {
let mut input = ViewportInput::new(viewport_default_bindings());
input.begin_frame(focused_ctx());
touch(&mut input, 1, TouchPhase::Started, 100.0, 100.0);
touch(&mut input, 2, TouchPhase::Started, 200.0, 100.0);
input.push_event(ViewportEvent::TrackpadPinch(0.5));
input.push_event(ViewportEvent::TrackpadPan(glam::Vec2::new(30.0, 0.0)));
input.push_event(ViewportEvent::TrackpadRotate(0.5));
let frame = input.resolve();
assert_eq!(frame.navigation.zoom, 0.0);
assert_eq!(frame.navigation.pan, glam::Vec2::ZERO);
assert_eq!(frame.navigation.twist, 0.0);
input.begin_frame(focused_ctx());
touch(&mut input, 1, TouchPhase::Ended, 100.0, 100.0);
touch(&mut input, 2, TouchPhase::Ended, 200.0, 100.0);
input.push_event(ViewportEvent::TrackpadPinch(0.5));
assert!(input.resolve().navigation.zoom > 0.0);
}
#[test]
fn a_contact_landing_outside_the_viewport_is_not_ours() {
let mut input = ViewportInput::new(viewport_default_bindings());
input.begin_frame(ctx(
PointerOwnership::Elsewhere,
KeyboardOwnership::Elsewhere,
));
touch(&mut input, 1, TouchPhase::Started, 100.0, 100.0);
touch(&mut input, 1, TouchPhase::Moved, 200.0, 100.0);
let frame = input.resolve();
assert_eq!(frame.pointer.contacts, 0);
assert_eq!(frame.navigation.orbit, glam::Vec2::ZERO);
}
#[test]
fn touch_sensitivities_scale_and_invert() {
let mut settings = TouchSettings::default();
settings.orbit_sensitivity = glam::Vec2::new(2.0, -1.0);
let mut input = ViewportInput::new(viewport_default_bindings());
input.set_touch_settings(settings);
input.begin_frame(focused_ctx());
touch(&mut input, 1, TouchPhase::Started, 100.0, 100.0);
touch(&mut input, 1, TouchPhase::Moved, 110.0, 110.0);
let frame = input.resolve();
assert_eq!(frame.navigation.orbit, glam::Vec2::new(20.0, -10.0));
}
#[test]
fn unmodelled_events_do_not_perturb_navigation() {
use crate::input::event::Theme;
use std::path::PathBuf;
let mut input = ViewportInput::new(viewport_default_bindings());
input.begin_frame(focused_ctx());
input.push_event(ViewportEvent::FileDropped(PathBuf::from("/x")));
input.push_event(ViewportEvent::FileHovered(PathBuf::from("/x")));
input.push_event(ViewportEvent::FileHoverCancelled);
input.push_event(ViewportEvent::RawMotion {
delta: glam::Vec2::new(9.0, 9.0),
});
input.push_event(ViewportEvent::ThemeChanged(Theme::Dark));
input.push_event(ViewportEvent::Occluded(true));
input.push_event(ViewportEvent::MouseButton {
button: MouseButton::Back,
state: ButtonState::Pressed,
});
let frame = input.resolve();
assert_eq!(frame.navigation.orbit, glam::Vec2::ZERO);
assert_eq!(frame.navigation.pan, glam::Vec2::ZERO);
assert_eq!(frame.navigation.zoom, 0.0);
assert!(frame.navigation.twist.abs() < 1e-6);
assert!(!frame.pointer.clicked);
assert!(!frame.pointer.dragging);
}
#[test]
fn a_trackpad_pinch_zooms_and_a_pan_pans() {
let mut input = ViewportInput::new(viewport_default_bindings());
input.begin_frame(focused_ctx());
input.push_event(ViewportEvent::TrackpadPinch(0.1));
input.push_event(ViewportEvent::TrackpadPan(glam::Vec2::new(5.0, -3.0)));
let frame = input.resolve();
assert!(
frame.navigation.zoom > 0.0,
"spreading the fingers zooms in, got {}",
frame.navigation.zoom
);
assert_eq!(frame.navigation.pan, glam::Vec2::new(5.0, -3.0));
}
#[test]
fn pinching_together_zooms_the_other_way() {
let mut input = ViewportInput::new(viewport_default_bindings());
input.begin_frame(focused_ctx());
input.push_event(ViewportEvent::TrackpadPinch(-0.1));
assert!(input.resolve().navigation.zoom < 0.0);
}
#[test]
fn gestures_accumulate_within_a_frame_and_reset_between_them() {
let mut input = ViewportInput::new(viewport_default_bindings());
input.begin_frame(focused_ctx());
input.push_event(ViewportEvent::TrackpadPinch(0.05));
input.push_event(ViewportEvent::TrackpadPinch(0.05));
let both = input.resolve().navigation.zoom;
input.begin_frame(focused_ctx());
input.push_event(ViewportEvent::TrackpadPinch(0.1));
let one = input.resolve().navigation.zoom;
assert!(
(both - one).abs() < 1e-3,
"two half-pinches must equal one whole: {both} vs {one}"
);
input.begin_frame(focused_ctx());
assert_eq!(
input.resolve().navigation.zoom,
0.0,
"a new frame starts from nothing"
);
}
#[test]
fn trackpad_gestures_are_dropped_when_not_hovered() {
let mut input = ViewportInput::new(viewport_default_bindings());
input.begin_frame(ctx(
PointerOwnership::Elsewhere,
KeyboardOwnership::Elsewhere,
));
input.push_event(ViewportEvent::TrackpadPinch(0.5));
input.push_event(ViewportEvent::TrackpadPan(glam::Vec2::new(5.0, 5.0)));
input.push_event(ViewportEvent::TrackpadRotate(0.5));
let frame = input.resolve();
assert_eq!(frame.navigation.zoom, 0.0);
assert_eq!(frame.navigation.pan, glam::Vec2::ZERO);
assert_eq!(frame.navigation.twist, 0.0);
}
#[test]
fn key_hold_active_every_frame() {
let mut input = ViewportInput::new(viewport_default_bindings());
input.begin_frame(focused_ctx());
input.push_event(ViewportEvent::Key {
key: KeyCode::W,
state: ButtonState::Pressed,
repeat: false,
logical: None,
});
let frame1 = input.resolve();
assert!(frame1.is_active(Action::FlyForward));
input.begin_frame(focused_ctx());
let frame2 = input.resolve();
assert!(
frame2.is_active(Action::FlyForward),
"FlyForward should persist while key is held"
);
}
#[test]
fn key_release_stops_hold() {
let mut input = ViewportInput::new(viewport_default_bindings());
input.begin_frame(focused_ctx());
input.push_event(ViewportEvent::Key {
key: KeyCode::W,
state: ButtonState::Pressed,
repeat: false,
logical: None,
});
let frame1 = input.resolve();
assert!(frame1.is_active(Action::FlyForward));
input.begin_frame(focused_ctx());
input.push_event(ViewportEvent::Key {
key: KeyCode::W,
state: ButtonState::Released,
repeat: false,
logical: None,
});
let frame2 = input.resolve();
assert!(
!frame2.is_active(Action::FlyForward),
"FlyForward should stop after key release"
);
}
#[test]
fn modifiers_changed_affects_bindings() {
let mut input = ViewportInput::new(tool_bindings());
input.begin_frame(focused_ctx());
input.push_event(ViewportEvent::ModifiersChanged(Modifiers::SHIFT));
input.push_event(ViewportEvent::Key {
key: KeyCode::X,
state: ButtonState::Pressed,
repeat: false,
logical: Some('X'),
});
let frame = input.resolve();
assert!(frame.is_active(TOOL_SHIFT_X), "Shift+X should fire");
assert!(!frame.is_active(TOOL_X), "plain X should not");
}
#[test]
fn repeat_key_does_not_fire_press() {
let mut input = ViewportInput::new(viewport_default_bindings());
input.begin_frame(focused_ctx());
input.push_event(ViewportEvent::Key {
key: KeyCode::F,
state: ButtonState::Pressed,
repeat: true,
logical: None,
});
let frame = input.resolve();
assert!(
!frame.is_active(Action::FocusObject),
"repeat should not fire KeyPress bindings"
);
}
#[test]
fn middle_drag_shift_produces_pan() {
let mut input = ViewportInput::new(viewport_default_bindings());
input.begin_frame(focused_ctx());
input.push_event(ViewportEvent::PointerMoved {
position: glam::Vec2::new(50.0, 50.0),
});
input.push_event(ViewportEvent::ModifiersChanged(Modifiers::SHIFT));
input.push_event(ViewportEvent::MouseButton {
button: MouseButton::Middle,
state: ButtonState::Pressed,
});
input.push_event(ViewportEvent::PointerMoved {
position: glam::Vec2::new(60.0, 55.0),
});
let frame = input.resolve();
assert!((frame.navigation.pan.x - 10.0).abs() < 1e-3);
assert!((frame.navigation.pan.y - 5.0).abs() < 1e-3);
}
}