Swap two hover buffers, and drive the tests from the harness

The set of hovered widgets is two vectors that trade places, so an input
allocates nothing once they have grown, instead of building a fresh one
each time.

`run_sensors` no longer takes a `window_size`: `UiRenderState` already
holds the output size, and passing it back in was one more thing that
could disagree.

`tests/pointer_routing.rs` drops its own `Rsc`, event manager and layer
scaffolding for `iris::harness`, which is what it was standing in for.
Presses now arrive as a move and then a press, and a scroll after the
hover that precedes it, because that is what the harness delivers and
what a window does.

core/src/event/manager.rs

@@ -79,6 +79,7 @@ type EventData<Rsc, E> = (E, Rc<dyn for<'a> EventFn<Rsc, <E as Event>::Data<'a>>
 pub struct TypeEventManager<Rsc: HasEvents, E: Event> {
     // TODO: reduce visiblity!!
     pub active: HashMap<LayerId, HashMap<WidgetId, E::State>>,
+    pub global: E::Global,
     map: HashMap<WidgetId, Vec<EventData<Rsc, E>>>,
 }
 
@@ -107,6 +108,7 @@ impl<Rsc: HasEvents, E: Event> Default for TypeEventManager<Rsc, E> {
     fn default() -> Self {
         Self {
             active: Default::default(),
+            global: Default::default(),
             map: Default::default(),
         }
     }
@@ -138,11 +140,13 @@ impl<Rsc: HasEvents + 'static, E: Event> TypeEventManager<Rsc, E> {
     pub fn run_fn<'a>(
         &mut self,
         id: impl IdLike,
-    ) -> impl for<'b> FnOnce(EventCtx<'_, Rsc, E::Data<'b>>, &mut Rsc) + 'a {
+    ) -> impl for<'b> FnOnce(EventCtx<'_, Rsc, E::Data<'b>>, &mut Rsc) -> bool + 'a {
         let fs = self.map.get(&id.id()).cloned().unwrap_or_default();
         move |ctx, rsc| {
+            let mut consumed = false;
             for (e, f) in fs {
                 if let Some(data) = e.should_run(&ctx.data) {
+                    consumed |= e.consumes(&data);
                     f(
                         EventCtx {
                             state: ctx.state,
@@ -152,6 +156,7 @@ impl<Rsc: HasEvents + 'static, E: Event> TypeEventManager<Rsc, E> {
                     )
                 }
             }
+            consumed
         }
     }
 }

core/src/event/mod.rs

@@ -9,10 +9,19 @@ pub use rsc::*;
 pub trait Event: Sized + 'static + Clone {
     type Data<'a>: Clone = ();
     type State: Default = ();
+    /// State the whole event type keeps, rather than one copy per widget.
+    type Global: Default = ();
     #[allow(unused_variables)]
     fn should_run<'a>(&self, data: &Self::Data<'a>) -> Option<Self::Data<'a>> {
         Some(data.clone())
     }
+
+    /// Whether having run on this data uses up whatever triggered it, so
+    /// nothing further should see it.
+    #[allow(unused_variables)]
+    fn consumes(&self, data: &Self::Data<'_>) -> bool {
+        false
+    }
 }
 
 pub trait EventLike {

core/src/event/rsc.rs

@@ -21,12 +21,13 @@ pub trait HasEvents: Sized + UiRsc + HasState {
 }
 
 pub trait RunEvents: HasEvents {
+    /// Whether anything that ran used up what triggered it.
     fn run_event<E: EventLike>(
         &mut self,
         id: impl IdLike,
         data: <E::Event as Event>::Data<'_>,
         state: &mut Self::State,
-    ) {
+    ) -> bool {
         let f = self.events_mut().get_type::<E>().run_fn(id);
         f(EventCtx { state, data }, self)
     }

core/src/orientation/pos.rs

@@ -421,7 +421,7 @@ impl Display for UiRegion {
     }
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone, Copy, PartialEq)]
 pub struct PixelRegion {
     pub top_left: Vec2,
     pub bot_right: Vec2,

core/src/ui/render_state.rs

@@ -34,6 +34,10 @@ impl UiRenderState {
         self.resized = true;
     }
 
+    pub fn output_size(&self) -> Vec2 {
+        self.output_size
+    }
+
     pub fn update<'a>(&mut self, root: impl Into<Option<&'a StrongWidget>>, rsc: &mut dyn UiRsc) {
         // safety mechanism for memory leaks; might wanna return a result instead so user can
         // decide whether to panic or not

examples/minimal.rs

@@ -10,11 +10,7 @@ struct State {
 }
 
 impl DefaultAppState for State {
-    fn new(
-        mut ui_state: DefaultUiState,
-        rsc: &mut DefaultRsc<Self>,
-        _: Proxy<Self::Event>,
-    ) -> Self {
+    fn new(mut ui_state: DefaultUiState, rsc: &mut DefaultRsc<Self>, _: Proxy<Self>) -> Self {
         rect(Color::RED).set_root(rsc, &mut ui_state);
         Self { ui_state }
     }

examples/tabs/main.rs

@@ -15,11 +15,7 @@ pub struct Client {
 }
 
 impl DefaultAppState for Client {
-    fn new(
-        mut ui_state: DefaultUiState,
-        rsc: &mut DefaultRsc<Self>,
-        _: Proxy<Self::Event>,
-    ) -> Self {
+    fn new(mut ui_state: DefaultUiState, rsc: &mut DefaultRsc<Self>, _: Proxy<Self>) -> Self {
         let rrect = rect(Color::WHITE).radius(20);
         let pad_test = (
             rrect.color(Color::BLUE),

examples/task.rs

@@ -11,11 +11,7 @@ struct State {
 }
 
 impl DefaultAppState for State {
-    fn new(
-        mut ui_state: DefaultUiState,
-        rsc: &mut DefaultRsc<Self>,
-        _: Proxy<Self::Event>,
-    ) -> Self {
+    fn new(mut ui_state: DefaultUiState, rsc: &mut DefaultRsc<Self>, _: Proxy<Self>) -> Self {
         let rect = rect(Color::RED).add(rsc);
         rect.task_on(CursorSense::click(), async move |mut ctx| {
             tokio::time::sleep(Duration::from_secs(1)).await;

examples/view.rs

@@ -36,11 +36,7 @@ impl Test {
 }
 
 impl DefaultAppState for State {
-    fn new(
-        mut ui_state: DefaultUiState,
-        rsc: &mut DefaultRsc<Self>,
-        _: Proxy<Self::Event>,
-    ) -> Self {
+    fn new(mut ui_state: DefaultUiState, rsc: &mut DefaultRsc<Self>, _: Proxy<Self>) -> Self {
         let test = Test::new(rsc);
 
         test.on(CursorSense::click(), move |_, rsc| {

src/default/mod.rs

@@ -25,7 +25,35 @@ pub use sense::*;
 pub use state::*;
 pub use task::*;
 
-pub type Proxy<Event> = EventLoopProxy<Event>;
+/// Sends an application's own events to its event loop. It wraps the proxy
+/// rather than being one because task updates travel the same way: what an
+/// application sends is its `Event`, not the loop's whole message type.
+pub struct Proxy<State: DefaultAppState>(EventLoopProxy<DefaultEvent<State>>);
+
+impl<State: DefaultAppState> Clone for Proxy<State> {
+    fn clone(&self) -> Self {
+        Self(self.0.clone())
+    }
+}
+
+impl<State: DefaultAppState> Proxy<State> {
+    pub fn send_event(&self, event: State::Event) {
+        let _ = self.0.send_event(DefaultEvent::User(event));
+    }
+}
+
+/// What the event loop carries: the application's own events, and the
+/// updates tasks send back to the ui thread.
+pub enum DefaultEvent<State: DefaultAppState> {
+    User(State::Event),
+    Update(Box<dyn TaskUpdate<DefaultRsc<State>>>),
+}
+
+impl<State: DefaultAppState> TaskQueue<DefaultRsc<State>> for Proxy<State> {
+    fn send(&self, update: Box<dyn TaskUpdate<DefaultRsc<State>>>) {
+        let _ = self.0.send_event(DefaultEvent::Update(update));
+    }
+}
 
 pub struct DefaultUiState {
     pub root: Option<StrongWidget>,
@@ -66,9 +94,8 @@ pub trait HasDefaultUiState: Sized + 'static {
 }
 
 pub trait DefaultAppState: HasDefaultUiState {
-    type Event = ();
-    fn new(ui_state: DefaultUiState, rsc: &mut DefaultRsc<Self>, proxy: Proxy<Self::Event>)
-    -> Self;
+    type Event: Send = ();
+    fn new(ui_state: DefaultUiState, rsc: &mut DefaultRsc<Self>, proxy: Proxy<Self>) -> Self;
     #[allow(unused_variables)]
     fn event(
         &mut self,
@@ -101,18 +128,14 @@ pub struct DefaultRsc<State: 'static> {
 }
 
 impl<State> DefaultRsc<State> {
-    fn init(window: Arc<Window>) -> (Self, TaskMsgReceiver<Self>) {
-        let (tasks, recv) = Tasks::init(window);
-        (
-            Self {
-                ui: Default::default(),
-                events: Default::default(),
-                tasks,
-                state: Default::default(),
-                _state: Default::default(),
-            },
-            recv,
-        )
+    pub fn init(queue: Arc<dyn TaskQueue<Self>>) -> Self {
+        Self {
+            ui: Default::default(),
+            events: Default::default(),
+            tasks: Tasks::init(queue),
+            state: Default::default(),
+            _state: Default::default(),
+        }
     }
 
     pub fn create_state<T: 'static>(&mut self, id: impl IdLike, data: T) -> WeakState<T> {
@@ -177,43 +200,32 @@ pub struct DefaultApp<State: DefaultAppState> {
     rsc: DefaultRsc<State>,
     render: UiRenderState,
     state: State,
-    task_recv: TaskMsgReceiver<DefaultRsc<State>>,
 }
 
 impl<State: DefaultAppState> AppState for DefaultApp<State> {
-    type Event = State::Event;
+    type Event = DefaultEvent<State>;
 
     fn new(event_loop: &ActiveEventLoop, proxy: EventLoopProxy<Self::Event>) -> Self {
         let window = event_loop
             .create_window(State::window_attributes())
             .unwrap();
         let default_state = DefaultUiState::new(window);
-        let (mut rsc, task_recv) = DefaultRsc::init(default_state.window.clone());
-        let state = State::new(default_state, &mut rsc, proxy);
+        let mut rsc = DefaultRsc::init(Arc::new(Proxy(proxy.clone())));
+        let state = State::new(default_state, &mut rsc, Proxy(proxy));
         let render = UiRenderState::new();
-        Self {
-            rsc,
-            state,
-            render,
-            task_recv,
-        }
+        Self { rsc, state, render }
     }
 
     fn event(&mut self, event: Self::Event, _: &ActiveEventLoop) {
-        self.state.event(event, &mut self.rsc, &mut self.render);
+        match event {
+            DefaultEvent::User(event) => self.state.event(event, &mut self.rsc, &mut self.render),
+            DefaultEvent::Update(update) => update(&mut self.state, &mut self.rsc),
+        }
+        self.request_redraw_if_needed();
     }
 
     fn window_event(&mut self, event: WindowEvent, event_loop: &ActiveEventLoop) {
-        let Self {
-            rsc,
-            render,
-            state,
-            task_recv,
-        } = self;
-
-        for update in task_recv.try_iter() {
-            update(state, rsc);
-        }
+        let Self { rsc, render, state } = self;
 
         let ui_state = state.default_state_mut();
         let input_changed = ui_state.input.event(&event);
@@ -223,8 +235,7 @@ impl<State: DefaultAppState> AppState for DefaultApp<State> {
             ui_state.focus = None;
         }
         if input_changed {
-            let window_size = ui_state.window_size();
-            render.run_sensors(rsc, state, cursor_state, window_size);
+            render.run_sensors(rsc, state, cursor_state);
         }
         let ui_state = state.default_state_mut();
         if old != ui_state.focus
@@ -293,11 +304,8 @@ impl<State: DefaultAppState> AppState for DefaultApp<State> {
             _ => (),
         }
         state.window_event(event, rsc, render);
-        let ui_state = self.state.default_state_mut();
-        if render.needs_redraw(&ui_state.root, rsc.widgets()) {
-            ui_state.renderer.window().request_redraw();
-        }
-        ui_state.input.end_frame();
+        self.request_redraw_if_needed();
+        self.state.default_state_mut().input.end_frame();
     }
 
     fn exit(&mut self) {
@@ -305,6 +313,15 @@ impl<State: DefaultAppState> AppState for DefaultApp<State> {
     }
 }
 
+impl<State: DefaultAppState> DefaultApp<State> {
+    fn request_redraw_if_needed(&mut self) {
+        let ui_state = self.state.default_state_mut();
+        if self.render.needs_redraw(&ui_state.root, self.rsc.widgets()) {
+            ui_state.renderer.window().request_redraw();
+        }
+    }
+}
+
 pub trait RscIdx<Rsc> {
     type Output;
     fn get(self, rsc: &Rsc) -> &Self::Output;

src/default/sense.rs

@@ -4,14 +4,14 @@ use std::{
     rc::Rc,
 };
 
-#[derive(Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq)]
 pub enum CursorButton {
     Left,
     Right,
     Middle,
 }
 
-#[derive(Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq)]
 pub enum CursorSense {
     PressStart(CursorButton),
     Pressing(CursorButton),
@@ -27,7 +27,7 @@ pub struct CursorSenses(Vec<CursorSense>);
 
 impl Event for CursorSenses {
     type Data<'a> = CursorData<'a>;
-    type State = SensorState;
+    type Global = Hovered;
     fn should_run<'a>(&self, data: &Self::Data<'a>) -> Option<Self::Data<'a>> {
         if let Some(sense) = should_run(self, &data.cursor, data.hover) {
             let mut data = data.clone();
@@ -37,6 +37,24 @@ impl Event for CursorSenses {
             None
         }
     }
+
+    /// A press or a scroll is used up by whatever answered it, so it stops
+    /// there. Hovering is not: a cursor resting somewhere goes on resting.
+    fn consumes(&self, data: &Self::Data<'_>) -> bool {
+        !data.sense.position_only()
+    }
+}
+
+/// Who the cursor was inside, before and after an input. The difference is
+/// whose hover has ended -- including a widget a higher layer has covered,
+/// which the walk stops before reaching.
+///
+/// Two buffers that swap rather than one rebuilt, so an input allocates
+/// nothing once they have grown.
+#[derive(Default)]
+pub struct Hovered {
+    was: Vec<WidgetId>,
+    now: Vec<WidgetId>,
 }
 
 impl CursorSense {
@@ -52,6 +70,12 @@ impl CursorSense {
     pub fn is_dragging(&self) -> bool {
         matches!(self, CursorSense::Pressing(CursorButton::Left))
     }
+
+    /// False if the sense is a button or a scroll, true if it is only about
+    /// where the cursor is.
+    fn position_only(&self) -> bool {
+        matches!(self, Self::HoverStart | Self::Hovering | Self::HoverEnd)
+    }
 }
 
 #[derive(Default, Clone)]
@@ -96,6 +120,12 @@ impl CursorButtons {
 }
 
 impl CursorState {
+    /// True if the cursor is only reporting where it is: no button and no
+    /// scroll this frame.
+    pub fn position_only(&self) -> bool {
+        self.scroll_delta == Vec2::ZERO && self.buttons.iter().all(|(_, state)| state.is_off())
+    }
+
     pub fn end_frame(&mut self) {
         self.buttons.end_frame();
         self.scroll_delta = Vec2::ZERO;
@@ -123,11 +153,6 @@ pub struct Sensor<Ctx: HasEvents, Data> {
 
 pub type SenseShape = UiRegion;
 
-#[derive(Default, Debug)]
-pub struct SensorState {
-    pub hover: ActivationState,
-}
-
 #[derive(Clone)]
 pub struct CursorData<'a> {
     /// where this widget was hit
@@ -147,7 +172,6 @@ pub trait SensorUi {
         rsc: &mut Rsc,
         state: &mut Rsc::State,
         cursor: CursorState,
-        window_size: Vec2,
     );
 }
 
@@ -157,54 +181,98 @@ impl SensorUi for UiRenderState {
         rsc: &mut Rsc,
         state: &mut Rsc::State,
         cursor: CursorState,
-        window_size: Vec2,
     ) {
         // in order to remove this take, need to store active list in UiRenderState somehow
         // this would probably be done through a generic parameter that adds yet another rsc /
         // state like thing, but local to render state, and is passed to UiRsc events so you can
         // update it there?
-        let mut active = std::mem::take(&mut rsc.events_mut().get_type::<CursorSense>().active);
+        let active = std::mem::take(&mut rsc.events_mut().get_type::<CursorSense>().active);
+        let mut hovered = std::mem::take(&mut rsc.events_mut().get_type::<CursorSense>().global);
+        hovered.now.clear();
+        let position_only = cursor.position_only();
+        let region_of = |id| self.window_region(&id);
+
         for layer in self.layers.indices().rev() {
-            let mut sensed = false;
-            for (id, sensor) in active.get_mut(&layer).into_flat_iter() {
-                let shape = self.active.get(id).unwrap().region;
-                let region = shape.to_px(window_size);
-                let in_shape = cursor.exists && region.contains(cursor.pos);
-                sensor.hover.update(in_shape);
-                if sensor.hover == ActivationState::Off {
+            let mut consumed = false;
+            for id in active.get(&layer).into_flat_iter().map(|(id, _)| *id) {
+                let Some(region) = region_of(id) else {
+                    continue;
+                };
+                if !cursor.exists || !region.contains(cursor.pos) {
                     continue;
                 }
-                sensed = true;
-
-                let cursor = cursor.clone();
-
-                let data = CursorData {
-                    pos: cursor.pos - region.top_left,
-                    size: region.bot_right - region.top_left,
-                    scroll_delta: cursor.scroll_delta,
-                    hover: sensor.hover,
-                    cursor,
-                    // this does not have any meaning;
-                    // might wanna set up Event to have a prepare stage
-                    sense: CursorSense::Hovering,
-                    render: self,
+                hovered.now.push(id);
+                let hover = match hovered.was.contains(&id) {
+                    true => ActivationState::On,
+                    false => ActivationState::Start,
                 };
-                rsc.run_event::<CursorSense>(*id, data, state);
+                // A press or a scroll stops where something answered it, so a
+                // button over a list does not swallow the list's scrolling.
+                consumed |= deliver(self, rsc, state, id, hover, &cursor, region);
+                // A cursor doing neither stops at whatever it is over, so
+                // hovering does not reach through.
+                consumed |= position_only;
             }
-            if sensed {
+            // Applied after the layer, never during it: senses on one layer do
+            // not block each other.
+            if consumed {
                 break;
             }
         }
-        rsc.events_mut().get_type::<CursorSense>().active = active;
+
+        // Whatever the cursor was inside and is not now, whether it left or a
+        // layer above took the input before the walk reached it. A widget that
+        // stopped being drawn has no region to report and is simply dropped.
+        for &id in &hovered.was {
+            if !hovered.now.contains(&id)
+                && let Some(region) = region_of(id)
+            {
+                deliver(self, rsc, state, id, ActivationState::End, &cursor, region);
+            }
+        }
+        std::mem::swap(&mut hovered.was, &mut hovered.now);
+
+        let senses = rsc.events_mut().get_type::<CursorSense>();
+        senses.active = active;
+        senses.global = hovered;
     }
 }
 
+/// Runs one widget's cursor senses, and says whether they used up the input.
+fn deliver<Rsc: HasEvents>(
+    render: &UiRenderState,
+    rsc: &mut Rsc,
+    state: &mut Rsc::State,
+    id: WidgetId,
+    hover: ActivationState,
+    cursor: &CursorState,
+    region: PixelRegion,
+) -> bool {
+    let data = CursorData {
+        pos: cursor.pos - region.top_left,
+        size: region.bot_right - region.top_left,
+        scroll_delta: cursor.scroll_delta,
+        hover,
+        cursor: cursor.clone(),
+        // this does not have any meaning;
+        // might wanna set up Event to have a prepare stage
+        sense: CursorSense::Hovering,
+        render,
+    };
+    rsc.run_event::<CursorSense>(id, data, state)
+}
+
 pub fn should_run(
     senses: &CursorSenses,
     cursor: &CursorState,
     hover: ActivationState,
 ) -> Option<CursorSense> {
     for sense in senses.iter() {
+        // A widget the cursor is no longer inside senses only its position:
+        // the press that ended its hover landed on something else.
+        if !hover.is_on() && !sense.position_only() {
+            continue;
+        }
         if match sense {
             CursorSense::PressStart(button) => cursor.buttons.select(button).is_start(),
             CursorSense::Pressing(button) => cursor.buttons.select(button).is_on(),

src/default/task.rs

@@ -1,11 +1,5 @@
 use iris_core::HasState;
-use std::{
-    pin::Pin,
-    sync::{
-        Arc,
-        mpsc::{Receiver as SyncReceiver, Sender as SyncSender, channel as sync_channel},
-    },
-};
+use std::{pin::Pin, sync::Arc};
 use tokio::{
     runtime::Runtime,
     sync::mpsc::{
@@ -13,64 +7,52 @@ use tokio::{
         unbounded_channel as async_channel,
     },
 };
-use winit::window::Window;
-
-pub type TaskMsgSender<Rsc> = SyncSender<Box<dyn TaskUpdate<Rsc>>>;
-pub type TaskMsgReceiver<Rsc> = SyncReceiver<Box<dyn TaskUpdate<Rsc>>>;
 
 pub trait TaskUpdate<Rsc: HasState>: FnOnce(&mut Rsc::State, &mut Rsc) + Send {}
 impl<F: FnOnce(&mut Rsc::State, &mut Rsc) + Send, Rsc: HasState> TaskUpdate<Rsc> for F {}
 
+/// Hands an update from a task to the thread that owns the ui. Delivery and
+/// waking are one act: a host posts the update as a message its loop already
+/// carries, so nothing has to wake the loop separately, or claim a redraw to
+/// be looked at.
+pub trait TaskQueue<Rsc: HasState>: Send + Sync + 'static {
+    fn send(&self, update: Box<dyn TaskUpdate<Rsc>>);
+}
+
 pub struct Tasks<Rsc: HasState> {
     start: AsyncSender<BoxTask>,
-    window: Arc<Window>,
-    msg_send: SyncSender<Box<dyn TaskUpdate<Rsc>>>,
+    queue: Arc<dyn TaskQueue<Rsc>>,
 }
 
 pub struct TaskCtx<Rsc: HasState> {
-    send: TaskMsgSender<Rsc>,
+    queue: Arc<dyn TaskQueue<Rsc>>,
 }
 
 impl<Rsc: HasState> TaskCtx<Rsc> {
     pub fn update(&mut self, f: impl TaskUpdate<Rsc> + 'static) {
-        let _ = self.send.send(Box::new(f));
-    }
-}
-impl<Rsc: HasState + 'static> TaskCtx<Rsc> {
-    fn new(send: TaskMsgSender<Rsc>) -> Self {
-        Self { send }
+        self.queue.send(Box::new(f));
     }
 }
 
 type BoxTask = Pin<Box<dyn Future<Output = ()> + Send>>;
 
 impl<Rsc: HasState> Tasks<Rsc> {
-    pub fn init(window: Arc<Window>) -> (Self, TaskMsgReceiver<Rsc>) {
+    pub fn init(queue: Arc<dyn TaskQueue<Rsc>>) -> Self {
         let (start, start_recv) = async_channel();
-        let (msgs, msgs_recv) = sync_channel();
         std::thread::spawn(|| {
             let rt = Runtime::new().unwrap();
             rt.block_on(listen(start_recv))
         });
-        (
-            Self {
-                start,
-                msg_send: msgs,
-                window,
-            },
-            msgs_recv,
-        )
+        Self { start, queue }
     }
 
     pub fn spawn<F: AsyncFnOnce(TaskCtx<Rsc>) + 'static + std::marker::Send>(&mut self, task: F)
     where
         F::CallOnceFuture: Send,
     {
-        let send = self.msg_send.clone();
-        let window = self.window.clone();
+        let queue = self.queue.clone();
         let _ = self.start.send(Box::pin(async move {
-            task(TaskCtx::new(send)).await;
-            window.request_redraw();
+            task(TaskCtx { queue }).await;
         }));
     }
 }

src/harness.rs

@@ -0,0 +1,180 @@
+//! A ui with no window: build a tree, run frames, move a pointer, and read
+//! back where widgets landed.
+//!
+//! It does not draw. A claim about pixels still needs a real surface.
+
+use crate::prelude::*;
+use std::{
+    sync::{
+        Arc,
+        mpsc::{Receiver, SyncSender, sync_channel},
+    },
+    time::Duration,
+};
+
+/// There is no loop here to post to, so updates queue until the test asks
+/// for them.
+struct Queue(SyncSender<Box<dyn TaskUpdate<DefaultRsc<HarnessState>>>>);
+
+impl TaskQueue<DefaultRsc<HarnessState>> for Queue {
+    fn send(&self, update: Box<dyn TaskUpdate<DefaultRsc<HarnessState>>>) {
+        let _ = self.0.send(update);
+    }
+}
+
+/// `assert_eq!` for where a frame put a widget, written as its two corners.
+#[macro_export]
+macro_rules! assert_corners {
+    ($harness:expr, $id:expr, ($x0:expr, $y0:expr), ($x1:expr, $y1:expr)) => {
+        assert_eq!(
+            $harness.region(&$id).expect("widget drew nothing"),
+            $crate::core::PixelRegion {
+                top_left: $crate::core::util::Vec2::new($x0 as f32, $y0 as f32),
+                bot_right: $crate::core::util::Vec2::new($x1 as f32, $y1 as f32),
+            }
+        );
+    };
+}
+pub use crate::assert_corners;
+
+#[derive(Default)]
+pub struct HarnessState {
+    pub root: Option<StrongWidget>,
+}
+
+impl HasRoot for HarnessState {
+    fn set_root(&mut self, root: StrongWidget) {
+        self.root = Some(root);
+    }
+}
+
+pub struct Harness {
+    pub rsc: DefaultRsc<HarnessState>,
+    pub render: UiRenderState,
+    pub state: HarnessState,
+    updates: Receiver<Box<dyn TaskUpdate<DefaultRsc<HarnessState>>>>,
+    cursor: CursorState,
+}
+
+impl Harness {
+    /// `size` is the output in physical pixels.
+    pub fn new(size: impl Into<Vec2>) -> Self {
+        // A `TaskQueue` must be `Sync`, which `mpsc::Sender` is not; the
+        // bound that comes with `SyncSender` is far past anything a test
+        // leaves unread.
+        let (send, updates) = sync_channel(1024);
+        let rsc = DefaultRsc::init(Arc::new(Queue(send)));
+        let mut render = UiRenderState::new();
+        render.resize(size);
+        Self {
+            rsc,
+            render,
+            state: HarnessState::default(),
+            updates,
+            cursor: CursorState::default(),
+        }
+    }
+
+    pub fn size(&self) -> Vec2 {
+        self.render.output_size()
+    }
+
+    pub fn resize(&mut self, size: impl Into<Vec2>) {
+        self.render.resize(size);
+    }
+
+    /// Sets the root and lays it out, so a pointer event has something to hit.
+    pub fn set_root<T>(&mut self, widget: impl WidgetLike<DefaultRsc<HarnessState>, T>) {
+        widget.set_root(&mut self.rsc, &mut self.state);
+        self.frame();
+    }
+
+    pub fn needs_redraw(&self) -> bool {
+        self.render
+            .needs_redraw(&self.state.root, self.rsc.widgets())
+    }
+
+    pub fn apply_updates(&mut self) -> usize {
+        let mut applied = 0;
+        while let Ok(update) = self.updates.try_recv() {
+            update(&mut self.state, &mut self.rsc);
+            applied += 1;
+        }
+        applied
+    }
+
+    /// Waits for a task's first update, then applies everything waiting.
+    /// False if none arrived in time.
+    #[must_use]
+    pub fn await_update(&mut self, timeout: Duration) -> bool {
+        let Ok(update) = self.updates.recv_timeout(timeout) else {
+            return false;
+        };
+        update(&mut self.state, &mut self.rsc);
+        self.apply_updates();
+        true
+    }
+
+    /// Lays the tree out and builds its primitives.
+    pub fn frame(&mut self) {
+        self.apply_updates();
+        self.render.update(&self.state.root, &mut self.rsc);
+    }
+
+    /// Where the last frame put a widget, or `None` if it drew nothing.
+    pub fn region(&self, id: &impl IdLike) -> Option<PixelRegion> {
+        self.render.window_region(id)
+    }
+
+    pub fn move_to(&mut self, pos: impl Into<Vec2>) {
+        self.cursor.pos = pos.into();
+        self.cursor.exists = true;
+        self.sense();
+    }
+
+    pub fn leave(&mut self) {
+        self.cursor.exists = false;
+        self.sense();
+    }
+
+    pub fn press(&mut self, button: CursorButton) {
+        self.button(button).update(true);
+        self.sense();
+    }
+
+    pub fn release(&mut self, button: CursorButton) {
+        self.button(button).update(false);
+        self.sense();
+    }
+
+    /// A wheel carries no position, so this goes wherever the cursor was last
+    /// moved to -- nowhere, until it has been moved.
+    pub fn scroll(&mut self, delta: impl Into<Vec2>) {
+        self.cursor.scroll_delta = delta.into();
+        self.sense();
+    }
+
+    pub fn click(&mut self, pos: impl Into<Vec2>) {
+        self.move_to(pos);
+        self.press(CursorButton::Left);
+        self.release(CursorButton::Left);
+    }
+
+    fn button(&mut self, button: CursorButton) -> &mut ActivationState {
+        let buttons = &mut self.cursor.buttons;
+        match button {
+            CursorButton::Left => &mut buttons.left,
+            CursorButton::Middle => &mut buttons.middle,
+            CursorButton::Right => &mut buttons.right,
+        }
+    }
+
+    /// Dispatches against the layout of the last frame, which is what a
+    /// window delivers input against too.
+    fn sense(&mut self) {
+        let cursor = self.cursor.clone();
+        self.render
+            .run_sensors(&mut self.rsc, &mut self.state, cursor);
+        self.cursor.end_frame();
+    }
+}

src/lib.rs

@@ -7,6 +7,7 @@
 
 pub mod default;
 pub mod event;
+pub mod harness;
 pub mod widget;
 
 pub use iris_core as core;

tests/layout.rs

@@ -0,0 +1,34 @@
+//! Where a frame puts things, with no window to put them in.
+
+use iris::harness::{Harness, assert_corners};
+use iris::prelude::*;
+
+/// A fixed 100 wide, and the rest of the 400 to its neighbour.
+fn two_rects(h: &mut Harness) -> (WidgetId, WidgetId) {
+    let left = rect(Color::RED).width(100).add(&mut h.rsc);
+    let right = rect(Color::BLUE).add(&mut h.rsc);
+    h.set_root((left, right).span(Dir::RIGHT));
+    (left.id(), right.id())
+}
+
+#[test]
+fn a_span_gives_each_child_the_width_it_asked_for() {
+    let mut h = Harness::new((400, 200));
+    let (left, right) = two_rects(&mut h);
+
+    assert_corners!(h, left, (0, 0), (100, 200));
+    assert_corners!(h, right, (100, 0), (400, 200));
+}
+
+#[test]
+fn resizing_relays_out_against_the_new_output() {
+    let mut h = Harness::new((400, 200));
+    let (left, right) = two_rects(&mut h);
+
+    h.resize((800, 100));
+    assert!(h.needs_redraw());
+    h.frame();
+
+    assert_corners!(h, left, (0, 0), (100, 100));
+    assert_corners!(h, right, (100, 0), (800, 100));
+}

tests/pointer.rs

@@ -0,0 +1,60 @@
+//! Which widget an input reaches.
+
+use std::{cell::RefCell, rc::Rc};
+
+use iris::harness::Harness;
+use iris::prelude::*;
+
+#[test]
+fn a_press_reaches_only_the_widget_under_the_cursor() {
+    let mut h = Harness::new((400, 200));
+    let clicks = Rc::new(RefCell::new(Vec::new()));
+
+    let (on_left, on_right) = (clicks.clone(), clicks.clone());
+    let left = rect(Color::RED)
+        .width(100)
+        .on(CursorSense::click(), move |_, _| {
+            on_left.borrow_mut().push("left")
+        })
+        .add(&mut h.rsc);
+    let right = rect(Color::BLUE)
+        .on(CursorSense::click(), move |_, _| {
+            on_right.borrow_mut().push("right")
+        })
+        .add(&mut h.rsc);
+    h.set_root((left, right).span(Dir::RIGHT));
+
+    h.click((50, 100));
+    assert_eq!(*clicks.borrow(), ["left"]);
+
+    h.click((300, 100));
+    assert_eq!(*clicks.borrow(), ["left", "right"]);
+}
+
+#[test]
+fn hover_ends_when_the_cursor_leaves_the_window() {
+    let mut h = Harness::new((400, 200));
+    let hovered = Rc::new(RefCell::new(0));
+    let ended = Rc::new(RefCell::new(0));
+
+    let (h_count, e_count) = (hovered.clone(), ended.clone());
+    let widget = rect(Color::RED)
+        .on(CursorSense::HoverStart, move |_, _| {
+            *h_count.borrow_mut() += 1
+        })
+        .on(CursorSense::HoverEnd, move |_, _| {
+            *e_count.borrow_mut() += 1
+        })
+        .add(&mut h.rsc);
+    h.set_root(widget);
+
+    h.move_to((200, 100));
+    assert_eq!((*hovered.borrow(), *ended.borrow()), (1, 0));
+
+    // A second sample inside the same widget is not a second hover.
+    h.move_to((210, 100));
+    assert_eq!((*hovered.borrow(), *ended.borrow()), (1, 0));
+
+    h.leave();
+    assert_eq!((*hovered.borrow(), *ended.borrow()), (1, 1));
+}

tests/pointer_routing.rs

@@ -0,0 +1,225 @@
+//! Input across layers: what stops at a layer, what passes through it, and
+//! where hovering stops.
+
+use std::{cell::RefCell, rc::Rc};
+
+use iris::harness::Harness;
+use iris::prelude::*;
+
+const WINDOW: f32 = 100.0;
+
+/// Every sense that has fired on one widget since it was last read.
+#[derive(Default, Clone)]
+struct Fired(Rc<RefCell<Vec<CursorSense>>>);
+
+impl Fired {
+    fn take(&self) -> Vec<CursorSense> {
+        std::mem::take(&mut self.0.borrow_mut())
+    }
+}
+
+/// A widget filling whatever it is given, recording the senses it is sent.
+fn listener(h: &mut Harness, senses: impl Into<CursorSenses>) -> (WeakWidget<Rect>, Fired) {
+    let fired = Fired::default();
+    let record = fired.clone();
+    let id = rect(Color::WHITE)
+        .on(senses.into(), move |ctx, _| {
+            record.0.borrow_mut().push(ctx.data.sense)
+        })
+        .add(&mut h.rsc);
+    (id, fired)
+}
+
+/// A widget with no senses of its own, to leave a gap beside one that has.
+fn blank(h: &mut Harness) -> WeakWidget<Rect> {
+    rect(Color::WHITE).add(&mut h.rsc)
+}
+
+fn harness() -> Harness {
+    Harness::new((WINDOW, WINDOW))
+}
+
+#[test]
+fn hover_stops_at_the_topmost_widget() {
+    let mut h = harness();
+    let (bottom, bottom_hover) = listener(&mut h, CursorSense::HoverStart);
+    let (middle, middle_hover) = listener(&mut h, CursorSense::HoverStart);
+    let (top, top_hover) = listener(&mut h, CursorSense::HoverStart);
+    h.set_root((bottom, middle, top).stack());
+
+    h.move_to((50, 50));
+
+    assert_eq!(top_hover.take(), [CursorSense::HoverStart]);
+    assert_eq!(
+        middle_hover.take(),
+        [],
+        "hover is not shared with a layer below"
+    );
+    assert_eq!(bottom_hover.take(), []);
+}
+
+#[test]
+fn a_scroll_passes_through_every_widget_that_does_not_want_it() {
+    let mut h = harness();
+    let (list, scrolled) = listener(&mut h, CursorSense::Scroll);
+    let (button, clicked) = listener(&mut h, CursorSense::click());
+    let (overlay, overlay_clicked) = listener(&mut h, CursorSense::click());
+    h.set_root((list, button, overlay).stack());
+
+    h.move_to((50, 50));
+    h.scroll((0, 10));
+
+    assert_eq!(
+        scrolled.take(),
+        [CursorSense::Scroll],
+        "two layers of click-only widgets do not stop a scroll"
+    );
+    assert_eq!(clicked.take(), []);
+    assert_eq!(overlay_clicked.take(), []);
+}
+
+#[test]
+fn hovering_a_button_above_does_not_stop_a_later_scroll() {
+    let mut h = harness();
+    let (list, scrolled) = listener(&mut h, CursorSense::Scroll);
+    let (button, _clicked) = listener(&mut h, CursorSense::click());
+    h.set_root((list, button).stack());
+
+    // The hover arrives in its own frame, as a window delivers it.
+    h.move_to((50, 50));
+    assert_eq!(scrolled.take(), []);
+
+    h.scroll((0, 10));
+    assert_eq!(
+        scrolled.take(),
+        [CursorSense::Scroll],
+        "a hover already resting on the button must not consume the wheel"
+    );
+}
+
+#[test]
+fn only_the_topmost_listener_takes_a_press() {
+    let mut h = harness();
+    let (below, below_clicked) = listener(&mut h, CursorSense::click());
+    let (above, above_clicked) = listener(&mut h, CursorSense::click());
+    h.set_root((below, above).stack());
+
+    h.click((50, 50));
+
+    assert_eq!(above_clicked.take(), [CursorSense::click()]);
+    assert_eq!(below_clicked.take(), [], "one press goes to one widget");
+}
+
+#[test]
+fn a_press_beside_the_button_reaches_the_layer_below() {
+    let mut h = harness();
+    let (list, list_clicked) = listener(&mut h, CursorSense::click());
+    // The row above the list covers it, but only its left half is the button.
+    let (button, button_clicked) = listener(&mut h, CursorSense::click());
+    let row = (button, blank(&mut h)).span(Dir::RIGHT).add(&mut h.rsc);
+    h.set_root((list, row).stack());
+
+    h.click((20, 50));
+    assert_eq!(button_clicked.take(), [CursorSense::click()]);
+    assert_eq!(list_clicked.take(), []);
+
+    h.click((80, 50));
+    assert_eq!(button_clicked.take(), [], "the cursor is not on the button");
+    assert_eq!(
+        list_clicked.take(),
+        [CursorSense::click()],
+        "a press beside the button belongs to what is under it"
+    );
+}
+
+#[test]
+fn leaving_a_widget_still_ends_its_hover() {
+    let mut h = harness();
+    let (widget, hover) = listener(&mut h, CursorSense::HoverStart | CursorSense::HoverEnd);
+    h.set_root(widget);
+
+    h.move_to((50, 50));
+    assert_eq!(hover.take(), [CursorSense::HoverStart]);
+
+    h.leave();
+    assert_eq!(hover.take(), [CursorSense::HoverEnd]);
+}
+
+#[test]
+fn leaving_a_widget_does_not_block_the_layer_below() {
+    let mut h = harness();
+    let (below, below_hover) = listener(&mut h, CursorSense::HoverStart);
+    // Only the left half of the layer above is a widget, so the cursor can
+    // leave it without leaving the one underneath.
+    let (above, above_hover) = listener(&mut h, CursorSense::HoverStart | CursorSense::HoverEnd);
+    let row = (above, blank(&mut h)).span(Dir::RIGHT).add(&mut h.rsc);
+    h.set_root((below, row).stack());
+
+    h.move_to((20, 50));
+    assert_eq!(above_hover.take(), [CursorSense::HoverStart]);
+    assert_eq!(below_hover.take(), [], "the layer above is over it");
+
+    h.move_to((80, 50));
+    assert_eq!(above_hover.take(), [CursorSense::HoverEnd]);
+    assert_eq!(
+        below_hover.take(),
+        [CursorSense::HoverStart],
+        "ending a hover above must not stop the hover below"
+    );
+}
+
+#[test]
+fn covering_a_widget_ends_its_hover() {
+    let mut h = harness();
+    let (below, below_hover) = listener(&mut h, CursorSense::HoverStart | CursorSense::HoverEnd);
+    let (above, above_hover) = listener(&mut h, CursorSense::HoverStart);
+    let row = (above, blank(&mut h)).span(Dir::RIGHT).add(&mut h.rsc);
+    h.set_root((below, row).stack());
+
+    h.move_to((80, 50));
+    assert_eq!(below_hover.take(), [CursorSense::HoverStart]);
+
+    h.move_to((20, 50));
+    assert_eq!(above_hover.take(), [CursorSense::HoverStart]);
+    assert_eq!(
+        below_hover.take(),
+        [CursorSense::HoverEnd],
+        "a widget covered by one that took the input is no longer hovered"
+    );
+
+    h.move_to((80, 50));
+    assert_eq!(
+        below_hover.take(),
+        [CursorSense::HoverStart],
+        "uncovering it hovers it again"
+    );
+}
+
+#[test]
+fn hover_starts_and_ends_once_each() {
+    let mut h = harness();
+    // Only the left half is the widget, so the cursor can leave it without
+    // leaving the window.
+    let (widget, hover) = listener(&mut h, CursorSense::HoverStart | CursorSense::HoverEnd);
+    let row = (widget, blank(&mut h)).span(Dir::RIGHT).add(&mut h.rsc);
+    h.set_root(row);
+
+    h.move_to((20, 50));
+    assert_eq!(hover.take(), [CursorSense::HoverStart]);
+
+    h.move_to((30, 50));
+    assert_eq!(hover.take(), [], "staying inside is not a second start");
+
+    h.move_to((80, 50));
+    assert_eq!(hover.take(), [CursorSense::HoverEnd]);
+
+    h.move_to((90, 50));
+    assert_eq!(hover.take(), [], "an ended hover does not end again");
+
+    h.move_to((20, 50));
+    assert_eq!(
+        hover.take(),
+        [CursorSense::HoverStart],
+        "re-entering starts it"
+    );
+}

tests/scroll.rs

@@ -0,0 +1,26 @@
+//! Scrolling moves content and stops at its ends.
+
+use iris::harness::{Harness, assert_corners};
+use iris::prelude::*;
+
+#[test]
+fn a_wheel_scrolls_the_content_and_stops_at_its_end() {
+    let mut h = Harness::new((400, 200));
+    // Twice the window's height, so there is 200 to scroll.
+    let top = rect(Color::RED).height(200).add(&mut h.rsc);
+    let bottom = rect(Color::BLUE).height(200).add(&mut h.rsc);
+    h.set_root((top, bottom).span(Dir::DOWN).scrollable());
+    h.move_to((200, 100));
+
+    // `Scroll` starts snapped to the end.
+    assert_corners!(h, top, (0, -200), (400, 0));
+
+    // The handler scales a wheel line by 50.
+    h.scroll((0, 1));
+    h.frame();
+    assert_corners!(h, top, (0, -150), (400, 50));
+
+    h.scroll((0, 10));
+    h.frame();
+    assert_corners!(h, top, (0, 0), (400, 200));
+}

tests/tasks.rs

@@ -0,0 +1,23 @@
+//! What a background task can change, and how it gets back to the ui.
+
+use std::time::Duration;
+
+use iris::harness::Harness;
+use iris::prelude::*;
+
+#[test]
+fn a_task_update_reaches_the_tree() {
+    let mut h = Harness::new((400, 200));
+    let widget = rect(Color::RED).add(&mut h.rsc);
+    h.set_root(widget.task_on(CursorSense::click(), async move |mut ctx| {
+        ctx.update(move |_, rsc| widget(rsc).color = Color::BLUE);
+    }));
+
+    h.click((200, 100));
+
+    assert!(
+        h.await_update(Duration::from_secs(5)),
+        "the task sent no update"
+    );
+    assert_eq!(h.rsc[widget].color, Color::BLUE);
+}