use crate::input::{Action, ActionEdge, ButtonState, InputControl, MouseButton};
mod events;
pub use events::{PointerButtonCancellation, PointerButtonEvent, PointerButtonOutcome};
#[derive(Debug, Clone, Copy)]
enum Capture<T> {
Idle,
Outside,
Target(T),
Suppressed,
}
#[derive(Debug)]
pub struct PointerButton<T: Copy + Eq> {
button: MouseButton,
capture: Capture<T>,
}
impl<T: Copy + Eq> PointerButton<T> {
pub const fn new(button: MouseButton) -> Self {
Self {
button,
capture: Capture::Idle,
}
}
pub const fn button(&self) -> MouseButton {
self.button
}
pub const fn captured(&self) -> Option<T> {
match self.capture {
Capture::Target(target) => Some(target),
_ => None,
}
}
pub fn cancel(&mut self) -> Option<T> {
let target = self.captured()?;
self.capture = Capture::Suppressed;
Some(target)
}
pub fn process<A: Action>(
&mut self,
edge: ActionEdge<A>,
hit: Option<T>,
) -> PointerButtonOutcome<T> {
if edge.control() != InputControl::MouseButton(self.button) {
return outcome(false, None);
}
match edge.state() {
ButtonState::Pressed => match self.capture {
Capture::Target(_) | Capture::Suppressed => outcome(true, None),
Capture::Outside => outcome(false, None),
Capture::Idle => {
if let Some((target, pointer)) = hit.zip(edge.pointer())
&& pointer.is_inside_viewport()
{
self.capture = Capture::Target(target);
outcome(
true,
Some(PointerButtonEvent::Pressed {
target,
pointer,
intent: edge.intent(),
}),
)
} else {
self.capture = Capture::Outside;
outcome(false, None)
}
}
},
ButtonState::Released => {
let capture = std::mem::replace(&mut self.capture, Capture::Idle);
match capture {
Capture::Idle | Capture::Outside => outcome(false, None),
Capture::Suppressed => outcome(true, None),
Capture::Target(target) => {
let reason = if let Some(reason) = edge.cancellation_reason() {
PointerButtonCancellation::Input(reason)
} else if let Some(pointer) = edge.pointer() {
if pointer.is_inside_viewport() && hit == Some(target) {
return outcome(
true,
Some(PointerButtonEvent::Clicked {
target,
pointer,
intent: edge.intent(),
}),
);
}
PointerButtonCancellation::ReleasedOutside
} else {
PointerButtonCancellation::MissingPointer
};
outcome(
true,
Some(PointerButtonEvent::Cancelled {
target,
reason,
intent: edge.intent(),
}),
)
}
}
}
}
}
}
fn outcome<T>(claimed: bool, event: Option<PointerButtonEvent<T>>) -> PointerButtonOutcome<T> {
PointerButtonOutcome { claimed, event }
}