use std::sync::{
Arc,
atomic::{AtomicBool, AtomicU8, AtomicU64, Ordering},
};
use crate::core::Signal;
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Default)]
pub enum Pointer {
#[default]
Fine,
Coarse,
}
impl Pointer {
pub fn platform_default() -> Self {
Self::starting_on(PHONE, browser_says_coarse())
}
pub(crate) fn starting_on(phone: bool, browser_coarse: Option<bool>) -> Self {
match (phone, browser_coarse) {
(true, _) | (false, Some(true)) => Self::Coarse,
_ => Self::Fine,
}
}
fn code(self) -> u8 {
match self {
Self::Fine => 0,
Self::Coarse => 1,
}
}
fn of_code(code: u8) -> Self {
if code == 1 { Self::Coarse } else { Self::Fine }
}
}
const PHONE: bool = cfg!(any(target_os = "ios", target_os = "android"));
#[cfg(target_arch = "wasm32")]
fn browser_says_coarse() -> Option<bool> {
web_sys::window()
.and_then(|window| window.match_media("(pointer: coarse)").ok().flatten())
.map(|query| query.matches())
}
#[cfg(not(target_arch = "wasm32"))]
fn browser_says_coarse() -> Option<bool> {
None
}
#[derive(Clone)]
pub(crate) struct AppPointer {
shared: Arc<PointerShared>,
version: Signal<u64>,
}
struct PointerShared {
now: AtomicU8,
pinned: AtomicBool,
follows: AtomicBool,
told: AtomicU64,
}
impl AppPointer {
pub fn new() -> Self {
Self::starting_at(Pointer::platform_default())
}
pub fn starting_at(pointer: Pointer) -> Self {
Self {
shared: Arc::new(PointerShared {
now: AtomicU8::new(pointer.code()),
pinned: AtomicBool::new(false),
follows: AtomicBool::new(true),
told: AtomicU64::new(0),
}),
version: Signal::new(0),
}
}
pub fn get(&self) -> Pointer {
let _ = self.version.get();
self.now()
}
pub fn now(&self) -> Pointer {
Pointer::of_code(self.shared.now.load(Ordering::Relaxed))
}
pub fn told(&self) -> u64 {
let _ = self.version.get();
self.shared.told.load(Ordering::Relaxed)
}
#[cfg_attr(not(feature = "mcp"), allow(dead_code))]
pub fn state(&self) -> (Pointer, bool, bool) {
(
self.now(),
self.shared.pinned.load(Ordering::Relaxed),
self.shared.follows.load(Ordering::Relaxed),
)
}
pub fn tell(&self, pointer: Pointer, pin: bool) {
self.shared.pinned.store(pin, Ordering::Relaxed);
self.shared.told.fetch_add(1, Ordering::Relaxed);
self.shared.now.store(pointer.code(), Ordering::Relaxed);
self.bump();
}
pub fn follow(&self, follows: bool) {
self.shared.follows.store(follows, Ordering::Relaxed);
if follows {
self.shared.pinned.store(false, Ordering::Relaxed);
}
}
pub fn input(&self, pointer: Pointer) {
let shared = &self.shared;
if shared.now.load(Ordering::Relaxed) == pointer.code()
|| shared.pinned.load(Ordering::Relaxed)
|| !shared.follows.load(Ordering::Relaxed)
{
return;
}
shared.now.store(pointer.code(), Ordering::Relaxed);
self.bump();
}
fn bump(&self) {
self.version.update(|version| *version = version.wrapping_add(1));
}
}
#[cfg(test)]
mod tests {
use super::{AppPointer, Pointer};
#[test]
fn a_phone_starts_coarse_a_desktop_fine_and_the_browser_as_its_media_query_says() {
assert_eq!(Pointer::starting_on(true, None), Pointer::Coarse, "iOS and Android");
assert_eq!(
Pointer::starting_on(false, None),
Pointer::Fine,
"Windows, macOS, Linux"
);
assert_eq!(
Pointer::starting_on(false, Some(true)),
Pointer::Coarse,
"a browser on a phone"
);
assert_eq!(
Pointer::starting_on(false, Some(false)),
Pointer::Fine,
"a browser on a desktop"
);
let phone = cfg!(any(target_os = "ios", target_os = "android"));
assert_eq!(Pointer::platform_default(), Pointer::starting_on(phone, None));
}
#[test]
fn input_moves_it_unless_it_is_pinned_or_does_not_follow() {
let pointer = AppPointer::starting_at(Pointer::Fine);
pointer.input(Pointer::Coarse);
assert_eq!(pointer.now(), Pointer::Coarse, "a finger");
pointer.input(Pointer::Fine);
assert_eq!(pointer.now(), Pointer::Fine, "a mouse");
pointer.tell(Pointer::Coarse, true);
pointer.input(Pointer::Fine);
assert_eq!(pointer.now(), Pointer::Coarse, "pinned");
pointer.follow(true);
pointer.input(Pointer::Fine);
assert_eq!(pointer.now(), Pointer::Fine, "following again lets go of the pin");
pointer.follow(false);
pointer.input(Pointer::Coarse);
assert_eq!(pointer.now(), Pointer::Fine, "not following");
}
#[test]
fn only_a_telling_counts_as_told() {
let pointer = AppPointer::starting_at(Pointer::Fine);
pointer.input(Pointer::Coarse);
assert_eq!(pointer.told(), 0);
pointer.tell(Pointer::Fine, false);
assert_eq!(pointer.told(), 1);
pointer.input(Pointer::Coarse);
assert_eq!(
pointer.now(),
Pointer::Coarse,
"a telling that does not pin leaves input to move it"
);
}
}