use super::*;
use day_spec::{Insets, KeyPhase, PointerKind};
use objc2_app_kit::{
NSEventMask, NSEventSubtype, NSPointingDeviceType, NSUserInterfaceLayoutDirection,
};
pub(super) fn grow_rect(rect: NSRect, slop: Insets, flipped: bool, rtl: bool) -> NSRect {
let (left, right) = if rtl {
(slop.trailing, slop.leading)
} else {
(slop.leading, slop.trailing)
};
let (low_y, high_y) = if flipped {
(slop.top, slop.bottom)
} else {
(slop.bottom, slop.top)
};
NSRect::new(
NSPoint::new(rect.origin.x - left, rect.origin.y - low_y),
NSSize::new(
(rect.size.width + left + right).max(0.0),
(rect.size.height + low_y + high_y).max(0.0),
),
)
}
pub(super) fn rect_contains(rect: NSRect, p: NSPoint) -> bool {
p.x >= rect.origin.x
&& p.x < rect.origin.x + rect.size.width
&& p.y >= rect.origin.y
&& p.y < rect.origin.y + rect.size.height
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(super) enum TapDisposition {
Immediate,
Pending,
Drop,
}
pub(super) fn tap_disposition(double_enabled: bool, click_count: isize) -> TapDisposition {
if !double_enabled {
TapDisposition::Immediate
} else if click_count >= 2 && click_count % 2 == 0 {
TapDisposition::Drop
} else {
TapDisposition::Pending
}
}
pub(super) fn classify_pointer(
kind: NSEventType,
subtype: NSEventSubtype,
entering: bool,
device: NSPointingDeviceType,
) -> Option<PointerKind> {
if kind == NSEventType::TabletProximity {
let pen = device == NSPointingDeviceType::Pen || device == NSPointingDeviceType::Eraser;
return (entering && pen).then_some(PointerKind::Stylus);
}
if kind == NSEventType::TabletPoint {
return Some(PointerKind::Stylus);
}
if subtype == NSEventSubtype::TabletPoint || subtype == NSEventSubtype::TabletProximity {
Some(PointerKind::Stylus)
} else {
Some(PointerKind::Mouse)
}
}
#[derive(Default)]
pub(super) struct KeyClaims {
held: Vec<KeyClaim>,
}
#[derive(Clone, Debug, PartialEq)]
struct KeyClaim {
code: u16,
node: NodeId,
key: String,
responder: usize,
}
impl KeyClaims {
pub(super) fn down(&mut self, code: u16, node: NodeId, key: String, responder: usize) {
self.held.retain(|c| c.code != code);
self.held.push(KeyClaim {
code,
node,
key,
responder,
});
}
pub(super) fn fresh_press(&mut self, code: u16) {
self.held.retain(|c| c.code != code);
}
pub(super) fn owns_repeat(&self, code: u16, responder: usize) -> bool {
self.held
.iter()
.any(|c| c.code == code && c.responder == responder)
}
pub(super) fn up(&mut self, code: u16, responder: usize) -> Option<(NodeId, String)> {
let at = self.held.iter().position(|c| c.code == code)?;
let claim = self.held.remove(at);
(claim.responder == responder).then_some((claim.node, claim.key))
}
pub(super) fn forget_node(&mut self, node: NodeId) {
self.held.retain(|c| c.node != node);
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(super) enum Prior {
Control(bool),
Text { editable: bool, selectable: bool },
Composed,
}
pub(super) struct Ledger<H> {
roots: Vec<LedgerRoot<H>>,
}
struct LedgerRoot<H> {
key: usize,
depth: u32,
views: Vec<(usize, H, Prior)>,
}
impl<H> Default for Ledger<H> {
fn default() -> Self {
Ledger { roots: Vec::new() }
}
}
impl<H: Clone> Ledger<H> {
pub(super) fn disable(
&mut self,
key: usize,
collect: impl FnOnce() -> Vec<(usize, H, Prior)>,
) -> Vec<H> {
if let Some(root) = self.roots.iter_mut().find(|r| r.key == key) {
root.depth += 1;
return Vec::new();
}
let mut fresh = Vec::new();
let mut views = Vec::new();
for (view_key, handle, prior) in collect() {
if let Some(held) = self.prior_of(view_key) {
views.push((view_key, handle, held));
} else {
fresh.push(handle.clone());
views.push((view_key, handle, prior));
}
}
self.roots.push(LedgerRoot {
key,
depth: 1,
views,
});
fresh
}
pub(super) fn enable(&mut self, key: usize) -> Vec<(H, Prior)> {
let Some(at) = self.roots.iter().position(|r| r.key == key) else {
return Vec::new();
};
self.roots[at].depth -= 1;
if self.roots[at].depth > 0 {
return Vec::new();
}
self.release_root(at)
}
pub(super) fn forget(&mut self, key: usize) -> Vec<(H, Prior)> {
match self.roots.iter().position(|r| r.key == key) {
Some(at) => self.release_root(at),
None => Vec::new(),
}
}
fn release_root(&mut self, at: usize) -> Vec<(H, Prior)> {
let root = self.roots.remove(at);
root.views
.into_iter()
.filter(|(view_key, _, _)| self.prior_of(*view_key).is_none())
.map(|(_, handle, prior)| (handle, prior))
.collect()
}
fn prior_of(&self, view_key: usize) -> Option<Prior> {
self.roots.iter().find_map(|r| {
r.views
.iter()
.find(|(k, _, _)| *k == view_key)
.map(|(_, _, p)| *p)
})
}
pub(super) fn is_root(&self, key: usize) -> bool {
self.roots.iter().any(|r| r.key == key)
}
pub(super) fn is_empty(&self) -> bool {
self.roots.is_empty()
}
}
struct ActivePress {
view: Retained<NSView>,
node: NodeId,
window: usize,
last: Point,
}
struct InputMonitor(Retained<AnyObject>);
impl Drop for InputMonitor {
fn drop(&mut self) {
unsafe { NSEvent::removeMonitor(&self.0) };
}
}
day_core::tls_group! {
pub(super) static PRESS_NODES: SideTable<NodeId> = SideTable::new();
pub(super) static HIT_SLOPS: SideTable<Insets> = SideTable::new();
static ANY_SLOP: Cell<bool> = const { Cell::new(false) };
pub(super) static HOVER_AREAS: SideTable<Retained<NSTrackingArea>> = SideTable::new();
static PENDING_TAPS: SideTable<u64> = SideTable::new();
static TAP_GENERATION: Cell<u64> = const { Cell::new(0) };
pub(super) static LONG_HELD: SideTable<()> = SideTable::new();
static PRESSES: RefCell<Vec<ActivePress>> = const { RefCell::new(Vec::new()) };
static PRESS_POLL: Cell<bool> = const { Cell::new(false) };
static KEY_CLAIMS: RefCell<KeyClaims> = RefCell::new(KeyClaims::default());
static LEDGER: RefCell<Ledger<Retained<NSView>>> = RefCell::new(Ledger::default());
static POINTER: Cell<PointerKind> = const { Cell::new(PointerKind::Mouse) };
static MONITOR: RefCell<Option<InputMonitor>> = const { RefCell::new(None) };
}
pub(super) fn top_left(view: &NSView, p: NSPoint) -> Point {
if view.isFlipped() {
Point::new(p.x, p.y)
} else {
Point::new(p.x, view.bounds().size.height - p.y)
}
}
fn event_point(view: &NSView, event: &NSEvent) -> Point {
top_left(
view,
view.convertPoint_fromView(event.locationInWindow(), None),
)
}
fn is_rtl(view: &NSView) -> bool {
view.userInterfaceLayoutDirection() == NSUserInterfaceLayoutDirection::RightToLeft
}
pub(super) fn hit_area(view: &NSView) -> NSRect {
let bounds = view.bounds();
match HIT_SLOPS.with(|t| t.get(ptr_of(view))) {
Some(slop) => grow_rect(bounds, slop, view.isFlipped(), is_rtl(view)),
None => bounds,
}
}
pub(super) fn takes_pointer(view: &NSView) -> bool {
let key = ptr_of(view);
GESTURES.with(|m| m.borrow().contains_key(&key))
|| PRESS_NODES.with(|t| t.contains(key))
|| PAN_NODES.with(|t| t.contains(key))
|| ROTATE_NODES.with(|t| t.contains(key))
|| HOVER_NODES.with(|t| t.contains(key))
|| FOCUSABLE_NODES.with(|t| t.contains(key))
|| CTX_MENU_FNS.with(|t| t.contains(key))
|| view.menu().is_some()
|| view.toolTip().is_some_and(|t| t.length() > 0)
|| transfer::involved(view)
|| window_chrome::is_drag_region(view)
}
fn passive_leaf(view: &NSView) -> bool {
let leaf = view
.downcast_ref::<objc2_app_kit::NSImageView>()
.is_some_and(|iv| !unsafe { iv.isEditable() })
|| view.downcast_ref::<NSBox>().is_some();
leaf && !takes_pointer(view)
}
pub(super) fn container_hit_test(this: &NSView, point: NSPoint) -> Option<Retained<NSView>> {
if this.isHidden() {
return None;
}
let local = match unsafe { this.superview() } {
Some(sup) => this.convertPoint_fromView(point, Some(&sup)),
None => point,
};
let inside = rect_contains(this.bounds(), local);
if !inside && !ANY_SLOP.with(Cell::get) {
return None;
}
if subtree_disabled(this) {
return None;
}
for child in unsafe { this.subviews() }.to_vec().into_iter().rev() {
if child.isHidden() {
continue;
}
if let Some(hit) = child.hitTest(local)
&& (ptr_of(&hit) != ptr_of(&child) || !passive_leaf(&child))
{
return Some(hit);
}
if let Some(slop) = HIT_SLOPS.with(|t| t.get(ptr_of(&child)))
&& takes_pointer(&child)
&& rect_contains(
grow_rect(child.frame(), slop, this.isFlipped(), is_rtl(&child)),
local,
)
{
return Some(child.clone());
}
}
(inside && takes_pointer(this)).then(|| Retained::from(this))
}
pub(super) fn leaf_hit_test(
this: &NSView,
hit: Option<Retained<NSView>>,
takes: bool,
) -> Option<Retained<NSView>> {
let hit = hit?;
if subtree_disabled(this) {
return None;
}
if ptr_of(&hit) == ptr_of(this) && !takes {
return None;
}
Some(hit)
}
pub(super) fn set_hit_slop(view: &NSView, slop: Insets) {
let key = ptr_of(view);
if slop == Insets::ZERO {
HIT_SLOPS.with(|t| t.take(key));
} else {
HIT_SLOPS.with(|t| t.insert(key, slop));
ANY_SLOP.with(|c| c.set(true));
}
if HOVER_AREAS.with(|t| t.contains(key)) {
install_hover_area(view);
}
}
pub(super) fn install_hover_area(view: &NSView) {
let key = ptr_of(view);
if let Some(old) = HOVER_AREAS.with(|t| t.take(key)) {
unsafe { view.removeTrackingArea(&old) };
}
let base = NSTrackingAreaOptions::MouseEnteredAndExited
| NSTrackingAreaOptions::MouseMoved
| NSTrackingAreaOptions::ActiveInKeyWindow;
let (rect, opts) = if HIT_SLOPS.with(|t| t.contains(key)) {
(hit_area(view), base)
} else {
(NSRect::ZERO, base | NSTrackingAreaOptions::InVisibleRect)
};
let owner: &AnyObject = view;
let area = unsafe {
NSTrackingArea::initWithRect_options_owner_userInfo(
NSTrackingArea::alloc(),
rect,
opts,
Some(owner),
None,
)
};
unsafe { view.addTrackingArea(&area) };
HOVER_AREAS.with(|t| t.insert(key, area));
}
pub(super) fn report_hover(view: &NSView, event: &NSEvent, phase: day_spec::DragPhase) -> bool {
let Some(node) = HOVER_NODES.with(|t| t.get(ptr_of(view))) else {
return false;
};
let loc = view.convertPoint_fromView(event.locationInWindow(), None);
let b = hit_area(view);
let inside = loc.x >= b.origin.x
&& loc.x <= b.origin.x + b.size.width
&& loc.y >= b.origin.y
&& loc.y <= b.origin.y + b.size.height;
if inside || phase == day_spec::DragPhase::Ended {
emit(
node,
Event::Hover {
phase,
location: top_left(view, loc),
},
);
}
true
}
pub(super) fn refresh_hover_area(view: &NSView) {
let key = ptr_of(view);
if HOVER_AREAS.with(|t| t.contains(key)) && HIT_SLOPS.with(|t| t.contains(key)) {
install_hover_area(view);
}
}
pub(super) fn install_monitor() {
MONITOR.with(|slot| {
if slot.borrow().is_some() {
return;
}
let block = block2::RcBlock::new(|raw: std::ptr::NonNull<NSEvent>| -> *mut NSEvent {
let event = unsafe { raw.as_ref() };
ffi_guard::contain(raw.as_ptr(), || {
if observe(event) {
std::ptr::null_mut()
} else {
raw.as_ptr()
}
})
});
let mask = NSEventMask::LeftMouseDown
| NSEventMask::LeftMouseDragged
| NSEventMask::LeftMouseUp
| NSEventMask::MouseMoved
| NSEventMask::TabletPoint
| NSEventMask::TabletProximity
| NSEventMask::KeyDown
| NSEventMask::KeyUp;
*slot.borrow_mut() =
unsafe { NSEvent::addLocalMonitorForEventsMatchingMask_handler(mask, &block) }
.map(InputMonitor);
});
}
fn observe(event: &NSEvent) -> bool {
let kind = event.r#type();
if kind == NSEventType::KeyDown {
if !event.isARepeat() {
KEY_CLAIMS.with(|k| k.borrow_mut().fresh_press(event.keyCode()));
}
return false;
}
if kind == NSEventType::KeyUp {
return key_released(event);
}
let pointer = if kind == NSEventType::TabletProximity {
classify_pointer(
kind,
NSEventSubtype::MouseEvent,
unsafe { event.isEnteringProximity() },
unsafe { event.pointingDeviceType() },
)
} else {
classify_pointer(
kind,
unsafe { event.subtype() },
false,
NSPointingDeviceType::Unknown,
)
};
if let Some(now) = pointer
&& POINTER.with(|p| p.replace(now)) != now
{
emit(WINDOW_NODE, Event::PointerKindChanged(now));
}
if kind == NSEventType::LeftMouseDown {
press_down(event);
} else if kind == NSEventType::LeftMouseDragged {
press_moved(event);
} else if kind == NSEventType::LeftMouseUp {
press_up(event);
}
false
}
pub(super) fn pointer_kind() -> PointerKind {
POINTER.with(Cell::get)
}
fn press_down(event: &NSEvent) {
release_all(None);
if event
.modifierFlags()
.contains(NSEventModifierFlags::Control)
{
return;
}
let Some(mtm) = MainThreadMarker::new() else {
return;
};
let Some(window) = event.window(mtm) else {
return;
};
let Some(content) = window.contentView() else {
return;
};
let mut view = content.hitTest(event.locationInWindow());
if !window.isKeyWindow()
&& view
.as_ref()
.is_none_or(|v| !v.acceptsFirstMouse(Some(event)))
{
return;
}
let mut pressed = Vec::new();
while let Some(v) = view {
if let Some(node) = PRESS_NODES.with(|t| t.get(ptr_of(&v))) {
let at = event_point(&v, event);
emit(
node,
Event::Press {
pressed: true,
location: at,
},
);
pressed.push(ActivePress {
view: v.clone(),
node,
window: Retained::as_ptr(&window) as usize,
last: at,
});
}
view = unsafe { v.superview() };
}
if pressed.is_empty() {
return;
}
PRESSES.with(|p| p.borrow_mut().extend(pressed));
schedule_press_poll();
}
fn press_moved(event: &NSEvent) {
let left: Vec<ActivePress> = PRESSES.with(|p| {
let mut p = p.borrow_mut();
let mut left = Vec::new();
let mut i = 0;
while i < p.len() {
let local = p[i]
.view
.convertPoint_fromView(event.locationInWindow(), None);
let at = top_left(&p[i].view, local);
if rect_contains(hit_area(&p[i].view), local) {
p[i].last = at;
i += 1;
} else {
let mut gone = p.remove(i);
gone.last = at;
left.push(gone);
}
}
left
});
for press in left {
end_press(&press);
}
}
fn press_up(event: &NSEvent) {
let ended: Vec<ActivePress> = PRESSES.with(|p| std::mem::take(&mut *p.borrow_mut()));
for mut press in ended {
press.last = event_point(&press.view, event);
end_press(&press);
}
}
fn end_press(press: &ActivePress) {
emit(
press.node,
Event::Press {
pressed: false,
location: press.last,
},
);
}
fn release_all(filter: Option<&dyn Fn(&ActivePress) -> bool>) {
let ended: Vec<ActivePress> = PRESSES.with(|p| {
let mut p = p.borrow_mut();
let (gone, keep): (Vec<_>, Vec<_>) = std::mem::take(&mut *p)
.into_iter()
.partition(|press| filter.is_none_or(|f| f(press)));
*p = keep;
gone
});
for press in &ended {
end_press(press);
}
}
fn schedule_press_poll() {
if PRESS_POLL.with(|p| p.replace(true)) {
return;
}
let when = dispatch2::DispatchTime::try_from(std::time::Duration::from_millis(50))
.unwrap_or(dispatch2::DispatchTime::NOW);
let queued = dispatch2::DispatchQueue::main().after(when, || {
ffi_guard::contain((), press_poll);
});
if queued.is_err() {
PRESS_POLL.with(|p| p.set(false));
}
}
fn press_poll() {
PRESS_POLL.with(|p| p.set(false));
let button_up = NSEvent::pressedMouseButtons() & 1 == 0;
release_all(Some(&|press: &ActivePress| {
button_up
|| press.view.isHiddenOrHasHiddenAncestor()
|| press
.view
.window()
.is_none_or(|w| Retained::as_ptr(&w) as usize != press.window || !w.isKeyWindow())
}));
if PRESSES.with(|p| !p.borrow().is_empty()) {
schedule_press_poll();
}
}
pub(super) fn hold_tap(view: &NSView, node: NodeId, at: Point) {
let key = ptr_of(view);
let generation = TAP_GENERATION.with(|g| {
let next = g.get().wrapping_add(1);
g.set(next);
next
});
PENDING_TAPS.with(|t| t.insert(key, generation));
let interval = NSEvent::doubleClickInterval().clamp(0.0, 5.0);
let when = dispatch2::DispatchTime::try_from(std::time::Duration::from_secs_f64(interval))
.unwrap_or(dispatch2::DispatchTime::NOW);
let queued = dispatch2::DispatchQueue::main().after(when, move || {
ffi_guard::contain((), || {
if PENDING_TAPS.with(|t| t.get(key)) == Some(generation) {
PENDING_TAPS.with(|t| t.take(key));
emit(node, Event::Tap(at));
}
});
});
if queued.is_err() {
PENDING_TAPS.with(|t| t.take(key));
emit(node, Event::Tap(at));
}
}
pub(super) fn cancel_held_tap(view: &NSView) {
PENDING_TAPS.with(|t| t.take(ptr_of(view)));
}
fn responder_of(event: &NSEvent) -> Option<usize> {
let mtm = MainThreadMarker::new()?;
let window = event.window(mtm)?;
let responder = window.firstResponder()?;
Some(Retained::as_ptr(&responder) as usize)
}
pub(super) fn claim_key(event: &NSEvent, node: NodeId, key: String) {
if let Some(responder) = responder_of(event) {
install_monitor();
KEY_CLAIMS.with(|k| {
k.borrow_mut().down(event.keyCode(), node, key, responder);
});
}
}
pub(super) fn owns_repeat(event: &NSEvent) -> bool {
responder_of(event).is_some_and(|responder| {
KEY_CLAIMS.with(|k| k.borrow().owns_repeat(event.keyCode(), responder))
})
}
pub(super) fn forget_keys(node: NodeId) {
KEY_CLAIMS.with(|k| k.borrow_mut().forget_node(node));
}
fn key_released(event: &NSEvent) -> bool {
let Some(responder) = responder_of(event) else {
KEY_CLAIMS.with(|k| k.borrow_mut().fresh_press(event.keyCode()));
return false;
};
let Some((node, key)) = KEY_CLAIMS.with(|k| k.borrow_mut().up(event.keyCode(), responder))
else {
return false;
};
emit(
node,
Event::Key(
day_spec::KeyEvent::named(key, key_modifiers(event.modifierFlags()))
.with_phase(KeyPhase::Up),
),
);
true
}
pub(super) fn subtree_disabled(view: &NSView) -> bool {
LEDGER.with(|l| {
let l = l.borrow();
if l.is_empty() {
return false;
}
let mut cur = Some(Retained::from(view));
while let Some(v) = cur {
if l.is_root(ptr_of(&v)) {
return true;
}
cur = unsafe { v.superview() };
}
false
})
}
fn prior_of(view: &NSView) -> Option<Prior> {
if view.downcast_ref::<DayFlipped>().is_some() || view.downcast_ref::<DayCanvas>().is_some() {
return Some(Prior::Composed);
}
if let Some(text) = view.downcast_ref::<NSTextView>() {
if text.isFieldEditor() {
return None;
}
return Some(Prior::Text {
editable: text.isEditable(),
selectable: text.isSelectable(),
});
}
if let Some(field) = view.downcast_ref::<NSTextField>()
&& !field.isEditable()
{
return None;
}
if view.downcast_ref::<objc2_app_kit::NSImageView>().is_some()
|| view.downcast_ref::<objc2_app_kit::NSScroller>().is_some()
{
return None;
}
view.downcast_ref::<NSControl>()
.map(|c| Prior::Control(c.isEnabled()))
}
fn collect(view: &NSView, out: &mut Vec<(usize, Retained<NSView>, Prior)>) {
if let Some(prior) = prior_of(view) {
out.push((ptr_of(view), Retained::from(view), prior));
}
for sub in &unsafe { view.subviews() } {
collect(&sub, out);
}
}
fn turn_off(view: &NSView) {
match prior_of(view) {
Some(Prior::Composed) => view.setAccessibilityEnabled(false),
Some(Prior::Text { .. }) => {
if let Some(text) = view.downcast_ref::<NSTextView>() {
text.setEditable(false);
text.setSelectable(false);
}
}
Some(Prior::Control(_)) => {
if let Some(control) = view.downcast_ref::<NSControl>() {
control.setEnabled(false);
}
}
None => {}
}
}
fn restore(view: &NSView, prior: Prior) {
match prior {
Prior::Composed => view.setAccessibilityEnabled(true),
Prior::Text {
editable,
selectable,
} => {
if let Some(text) = view.downcast_ref::<NSTextView>() {
text.setSelectable(selectable);
text.setEditable(editable);
}
}
Prior::Control(enabled) => {
if let Some(control) = view.downcast_ref::<NSControl>() {
control.setEnabled(enabled);
}
}
}
}
pub(super) fn set_subtree_enabled(root: &NSView, enabled: bool) {
let key = ptr_of(root);
if enabled {
let back = LEDGER.with(|l| l.borrow_mut().enable(key));
for (view, prior) in back {
restore(&view, prior);
}
return;
}
if let Some(window) = root.window()
&& let Some(responder) = window.firstResponder()
&& responder_inside(&responder, root)
{
window.makeFirstResponder(None);
}
PRESSES.with(|p| {
p.borrow_mut()
.retain(|press| !unsafe { press.view.isDescendantOf(root) });
});
let fresh = LEDGER.with(|l| {
l.borrow_mut().disable(key, || {
let mut views = Vec::new();
collect(root, &mut views);
views
})
});
for view in fresh {
turn_off(&view);
}
}
fn responder_inside(responder: &NSResponder, root: &NSView) -> bool {
if let Some(text) = responder.downcast_ref::<NSText>()
&& let Some(delegate) = unsafe { text.delegate() }
&& let Some(field) = AsRef::<AnyObject>::as_ref(&*delegate).downcast_ref::<NSView>()
&& unsafe { field.isDescendantOf(root) }
{
return true;
}
responder
.downcast_ref::<NSView>()
.is_some_and(|v| unsafe { v.isDescendantOf(root) })
}
pub(super) fn forget_disabled_root(key: usize) {
let back = LEDGER.with(|l| {
let mut l = l.borrow_mut();
if l.is_root(key) {
l.forget(key)
} else {
Vec::new()
}
});
for (view, prior) in back {
restore(&view, prior);
}
}
#[cfg(test)]
mod tests {
use super::*;
fn rect(x: f64, y: f64, w: f64, h: f64) -> NSRect {
NSRect::new(NSPoint::new(x, y), NSSize::new(w, h))
}
#[test]
fn slop_grows_each_edge_in_flipped_coordinates() {
let slop = Insets {
top: 1.0,
leading: 2.0,
bottom: 3.0,
trailing: 4.0,
};
let r = grow_rect(rect(10.0, 10.0, 12.0, 12.0), slop, true, false);
assert_eq!(
(r.origin.x, r.origin.y, r.size.width, r.size.height),
(8.0, 9.0, 18.0, 16.0)
);
let r = grow_rect(rect(10.0, 10.0, 12.0, 12.0), slop, true, true);
assert_eq!((r.origin.x, r.size.width), (6.0, 18.0));
let r = grow_rect(rect(10.0, 10.0, 12.0, 12.0), slop, false, false);
assert_eq!((r.origin.y, r.size.height), (7.0, 16.0));
}
#[test]
fn a_dot_with_slop_takes_presses_near_it_only() {
let dot = rect(0.0, 0.0, 12.0, 12.0);
let grown = grow_rect(dot, Insets::all(30.0), true, false);
assert!(rect_contains(grown, NSPoint::new(-20.0, 6.0)));
assert!(!rect_contains(grown, NSPoint::new(-40.0, 6.0)));
assert!(rect_contains(dot, NSPoint::new(0.0, 0.0)));
assert!(!rect_contains(dot, NSPoint::new(12.0, 6.0)));
}
#[test]
fn taps_wait_only_beside_a_double_tap() {
assert_eq!(tap_disposition(false, 1), TapDisposition::Immediate);
assert_eq!(tap_disposition(false, 2), TapDisposition::Immediate);
assert_eq!(tap_disposition(true, 1), TapDisposition::Pending);
assert_eq!(tap_disposition(true, 2), TapDisposition::Drop);
assert_eq!(tap_disposition(true, 3), TapDisposition::Pending);
assert_eq!(tap_disposition(true, 4), TapDisposition::Drop);
}
#[test]
fn a_pen_is_a_stylus_and_a_trackpad_a_mouse() {
let plain = NSEventSubtype::MouseEvent;
let none = NSPointingDeviceType::Unknown;
assert_eq!(
classify_pointer(NSEventType::LeftMouseDown, plain, false, none),
Some(PointerKind::Mouse)
);
assert_eq!(
classify_pointer(
NSEventType::LeftMouseDown,
NSEventSubtype::TabletPoint,
false,
none
),
Some(PointerKind::Stylus)
);
assert_eq!(
classify_pointer(NSEventType::MouseMoved, NSEventSubtype::Touch, false, none),
Some(PointerKind::Mouse)
);
assert_eq!(
classify_pointer(
NSEventType::TabletProximity,
plain,
true,
NSPointingDeviceType::Pen
),
Some(PointerKind::Stylus)
);
assert_eq!(
classify_pointer(
NSEventType::TabletProximity,
plain,
false,
NSPointingDeviceType::Pen
),
None
);
assert_eq!(
classify_pointer(
NSEventType::TabletProximity,
plain,
true,
NSPointingDeviceType::Cursor
),
None
);
}
#[test]
fn a_release_goes_to_the_node_that_heard_the_press() {
let mut k = KeyClaims::default();
let (canvas, other) = (NodeId(1), NodeId(2));
k.down(124, canvas, "ArrowRight".into(), 10);
assert!(k.owns_repeat(124, 10));
assert!(!k.owns_repeat(124, 11), "focus moved: not this press");
assert_eq!(k.up(124, 10), Some((canvas, "ArrowRight".to_string())));
assert_eq!(k.up(124, 10), None, "one release per press");
assert_eq!(k.up(125, 10), None);
k.down(126, other, "ArrowUp".into(), 10);
assert_eq!(k.up(126, 11), None);
assert!(!k.owns_repeat(126, 10));
k.down(123, canvas, "ArrowLeft".into(), 10);
k.forget_node(canvas);
assert_eq!(k.up(123, 10), None);
k.down(18, canvas, "1".into(), 10);
k.fresh_press(18);
assert_eq!(k.up(18, 10), None);
}
#[test]
fn a_view_under_two_disabled_roots_waits_for_both() {
let mut l: Ledger<usize> = Ledger::default();
let off = l.disable(1, || {
vec![
(10, 10, Prior::Control(true)),
(11, 11, Prior::Control(false)),
]
});
assert_eq!(off, vec![10, 11]);
let off = l.disable(2, || vec![(10, 10, Prior::Control(false))]);
assert_eq!(off, Vec::<usize>::new(), "already off");
assert_eq!(l.enable(1), vec![(11, Prior::Control(false))]);
assert_eq!(l.enable(2), vec![(10, Prior::Control(true))]);
assert!(l.is_empty());
}
#[test]
fn the_same_root_disabled_twice_needs_two_enables() {
let mut l: Ledger<usize> = Ledger::default();
l.disable(1, || vec![(10, 10, Prior::Composed)]);
let again = l.disable(1, || panic!("not collected twice"));
assert_eq!(again, Vec::<usize>::new());
assert_eq!(l.enable(1), Vec::new());
assert!(l.is_root(1));
assert_eq!(l.enable(1), vec![(10, Prior::Composed)]);
assert!(!l.is_root(1));
assert_eq!(l.enable(1), Vec::new());
l.disable(3, || {
vec![(
12,
12,
Prior::Text {
editable: true,
selectable: true,
},
)]
});
assert_eq!(
l.forget(3),
vec![(
12,
Prior::Text {
editable: true,
selectable: true
}
)]
);
}
}