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(),
         }
     }
@@ -135,19 +137,16 @@ impl<Rsc: HasEvents + 'static, E: Event> TypeEventManager<Rsc, E> {
         ));
     }
 
-    /// What this widget registered, without running any of it.
-    pub fn registered(&self, id: WidgetId) -> impl Iterator<Item = &E> {
-        self.map.get(&id).into_iter().flatten().map(|(e, _)| 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,
@@ -157,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

@@ -1,10 +1,6 @@
 use crate::prelude::*;
 use arboard::Clipboard;
-use std::{
-    marker::{PhantomData, Sized},
-    sync::Arc,
-    time::Instant,
-};
+use std::{marker::PhantomData, sync::Arc, time::Instant};
 use winit::{
     event::{Ime, WindowEvent},
     event_loop::{ActiveEventLoop, EventLoopProxy},
@@ -29,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>,
@@ -70,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,
@@ -105,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> {
@@ -181,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);
@@ -227,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
@@ -297,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) {
@@ -309,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

@@ -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 {
@@ -53,17 +71,10 @@ impl CursorSense {
         matches!(self, CursorSense::Pressing(CursorButton::Left))
     }
 
-    /// Takes what this sense answers to out of `cursor`, so a widget below
-    /// does not also get it. Hovering takes nothing: it goes to the topmost
-    /// widget in shape, which is not a question about the input.
-    fn take(&self, cursor: &mut CursorState) {
-        match self {
-            Self::PressStart(button) | Self::Pressing(button) | Self::PressEnd(button) => {
-                *cursor.buttons.select_mut(button) = ActivationState::Off
-            }
-            Self::Scroll => cursor.scroll_delta = Vec2::ZERO,
-            Self::HoverStart | Self::Hovering | Self::HoverEnd => {}
-        }
+    /// 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)
     }
 }
 
@@ -91,14 +102,6 @@ impl CursorButtons {
         }
     }
 
-    pub fn select_mut(&mut self, button: &CursorButton) -> &mut ActivationState {
-        match button {
-            CursorButton::Left => &mut self.left,
-            CursorButton::Right => &mut self.right,
-            CursorButton::Middle => &mut self.middle,
-        }
-    }
-
     pub fn end_frame(&mut self) {
         self.left.end_frame();
         self.middle.end_frame();
@@ -117,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;
@@ -144,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
@@ -168,7 +172,6 @@ pub trait SensorUi {
         rsc: &mut Rsc,
         state: &mut Rsc::State,
         cursor: CursorState,
-        window_size: Vec2,
     );
 }
 
@@ -178,103 +181,111 @@ 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);
-        // Narrowed as it descends: a widget takes what it answers to, and
-        // what is left is what the layers below see.
-        let mut cursor = cursor;
-        let mut hovered = false;
+        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 below = cursor.clone();
-            let mut hovered_here = 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 over = cursor.exists && region.contains(cursor.pos);
-                // Hover goes to the topmost widget in shape and no further.
-                sensor.hover.update(over && !hovered);
-                // `is_off` would be wrong here: it counts `End`, which is
-                // the one frame a hover-end handler has to run on.
-                if !over && 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;
                 }
-                hovered_here |= over;
-
-                // Momentary input belongs to whatever the cursor is on. A
-                // widget it has just left still hears its hover ending, but
-                // a press landing elsewhere is neither its press to receive
-                // nor its press to take.
-                let cursor = match over {
-                    true => cursor.clone(),
-                    false => CursorState {
-                        pos: cursor.pos,
-                        exists: cursor.exists,
-                        ..Default::default()
-                    },
+                hovered.now.push(id);
+                let hover = match hovered.was.contains(&id) {
+                    true => ActivationState::On,
+                    false => ActivationState::Start,
                 };
-
-                for senses in rsc.events_mut().get_type::<CursorSense>().registered(*id) {
-                    for sense in senses.iter() {
-                        if matches(sense, &cursor, sensor.hover) {
-                            sense.take(&mut below);
-                        }
-                    }
-                }
-
-                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,
-                };
-                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;
             }
-            hovered |= hovered_here;
-            cursor = below;
-            if hovered && !is_momentary(&cursor) {
+            // 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> {
-    senses
-        .iter()
-        .find(|sense| matches(sense, cursor, hover))
-        .copied()
-}
-
-fn matches(sense: &CursorSense, cursor: &CursorState, hover: ActivationState) -> bool {
-    match sense {
-        CursorSense::PressStart(button) => cursor.buttons.select(button).is_start(),
-        CursorSense::Pressing(button) => cursor.buttons.select(button).is_on(),
-        CursorSense::PressEnd(button) => cursor.buttons.select(button).is_end(),
-        CursorSense::HoverStart => hover.is_start(),
-        CursorSense::Hovering => hover.is_on(),
-        CursorSense::HoverEnd => hover.is_end(),
-        CursorSense::Scroll => cursor.scroll_delta != Vec2::ZERO,
+    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(),
+            CursorSense::PressEnd(button) => cursor.buttons.select(button).is_end(),
+            CursorSense::HoverStart => hover.is_start(),
+            CursorSense::Hovering => hover.is_on(),
+            CursorSense::HoverEnd => hover.is_end(),
+            CursorSense::Scroll => cursor.scroll_delta != Vec2::ZERO,
+        } {
+            return Some(*sense);
+        }
     }
-}
-
-/// Whether anything is happening to the cursor beyond where it rests.
-fn is_momentary(cursor: &CursorState) -> bool {
-    cursor.scroll_delta != Vec2::ZERO || cursor.buttons.iter().any(|(_, state)| !state.is_off())
+    None
 }
 
 impl ActivationState {

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;

src/widget/position/mod.rs

@@ -4,7 +4,7 @@ mod max_size;
 mod offset;
 mod pad;
 mod scroll;
-mod sized;
+mod set_size;
 mod span;
 mod stack;
 
@@ -14,6 +14,6 @@ pub use max_size::*;
 pub use offset::*;
 pub use pad::*;
 pub use scroll::*;
-pub use sized::*;
+pub use set_size::*;
 pub use span::*;
 pub use stack::*;

src/widget/position/set_size.rs

@@ -1,12 +1,12 @@
 use crate::prelude::*;
 
-pub struct Sized {
+pub struct SetSize {
     pub inner: StrongWidget,
     pub x: Option<Len>,
     pub y: Option<Len>,
 }
 
-impl Sized {
+impl SetSize {
     fn apply_to_outer(&self, ctx: &mut SizeCtx) {
         if let Some(x) = self.x {
             ctx.outer.x.select_len(x.apply_rest());
@@ -17,7 +17,7 @@ impl Sized {
     }
 }
 
-impl Widget for Sized {
+impl Widget for SetSize {
     fn draw(&mut self, painter: &mut Painter) {
         painter.widget(&self.inner);
     }

src/widget/ptr.rs

@@ -1,5 +1,5 @@
 use crate::prelude::*;
-use std::marker::{Sized, Unsize};
+use std::marker::Unsize;
 
 pub struct WidgetPtr {
     pub inner: Option<StrongWidget>,

src/widget/text/build.rs

@@ -1,5 +1,5 @@
 use crate::prelude::*;
-use std::marker::{PhantomData, Sized};
+use std::marker::PhantomData;
 
 pub struct TextBuilder<State, O = TextOutput, H: WidgetOption<State> = ()> {
     pub content: String,

src/widget/trait_fns.rs

@@ -31,9 +31,9 @@ widget_trait! {
         }
     }
 
-    fn sized(self, size: impl Into<Size>) -> impl WidgetFn<Rsc, Sized> {
+    fn sized(self, size: impl Into<Size>) -> impl WidgetFn<Rsc, SetSize> {
         let size = size.into();
-        move |state| Sized {
+        move |state| SetSize {
             inner: self.add_strong(state),
             x: Some(size.x),
             y: Some(size.y),
@@ -58,18 +58,18 @@ widget_trait! {
         }
     }
 
-    fn width(self, len: impl Into<Len>) -> impl WidgetFn<Rsc, Sized> {
+    fn width(self, len: impl Into<Len>) -> impl WidgetFn<Rsc, SetSize> {
         let len = len.into();
-        move |state| Sized {
+        move |state| SetSize {
             inner: self.add_strong(state),
             x: Some(len),
             y: None,
         }
     }
 
-    fn height(self, len: impl Into<Len>) -> impl WidgetFn<Rsc, Sized> {
+    fn height(self, len: impl Into<Len>) -> impl WidgetFn<Rsc, SetSize> {
         let len = len.into();
-        move |state| Sized {
+        move |state| SetSize {
             inner: self.add_strong(state),
             x: None,
             y: Some(len),

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

@@ -1,45 +1,10 @@
-//! Input across layers: what a widget takes, what passes through it, and
-//! where hovering stops. These drive `run_sensors` directly, which needs no
-//! GPU and no window.
+//! Input across layers: what stops at a layer, what passes through it, and
+//! where hovering stops.
 
-use iris::prelude::*;
 use std::{cell::RefCell, rc::Rc};
 
-struct SenseRsc {
-    ui: UiData,
-    events: EventManager<SenseRsc>,
-}
-
-impl UiRsc for SenseRsc {
-    fn ui(&self) -> &UiData {
-        &self.ui
-    }
-    fn ui_mut(&mut self) -> &mut UiData {
-        &mut self.ui
-    }
-    fn on_draw(&mut self, active: &ActiveData) {
-        self.events.draw(active);
-    }
-    fn on_undraw(&mut self, active: &ActiveData) {
-        self.events.undraw(active);
-    }
-    fn on_remove(&mut self, id: WidgetId) {
-        self.events.remove(id);
-    }
-}
-
-impl HasState for SenseRsc {
-    type State = ();
-}
-
-impl HasEvents for SenseRsc {
-    fn events(&self) -> &EventManager<Self> {
-        &self.events
-    }
-    fn events_mut(&mut self) -> &mut EventManager<Self> {
-        &mut self.events
-    }
-}
+use iris::harness::Harness;
+use iris::prelude::*;
 
 const WINDOW: f32 = 100.0;
 
@@ -53,88 +18,36 @@ impl Fired {
     }
 }
 
-struct Ui {
-    rsc: SenseRsc,
-    render: UiRenderState,
-    state: (),
+/// 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)
 }
 
-impl Ui {
-    fn new() -> Self {
-        Self {
-            rsc: SenseRsc {
-                ui: UiData::default(),
-                events: EventManager::default(),
-            },
-            render: UiRenderState::new(),
-            state: (),
-        }
-    }
-
-    fn listen<W: Widget + ?core::marker::Sized + 'static>(
-        &mut self,
-        widget: &StrongWidget<W>,
-        senses: impl Into<CursorSenses>,
-    ) -> Fired {
-        let fired = Fired::default();
-        let sink = fired.clone();
-        self.rsc
-            .register_event(widget.weak(), senses.into(), move |ctx, _rsc| {
-                sink.0.borrow_mut().push(ctx.data.sense)
-            });
-        fired
-    }
-
-    /// Stacks the widgets bottom first, each on its own layer, and lays them
-    /// out in a square window.
-    fn stack(&mut self, children: Vec<StrongWidget>) {
-        let root = self
-            .rsc
-            .ui
-            .widgets
-            .add_strong(Stack {
-                children,
-                size: StackSize::default(),
-            })
-            .any();
-        self.render.resize((WINDOW, WINDOW));
-        self.render.update(&root, &mut self.rsc);
-    }
-
-    fn cursor(&mut self, at: (f32, f32)) -> CursorState {
-        CursorState {
-            pos: at.into(),
-            exists: true,
-            buttons: Default::default(),
-            scroll_delta: Vec2::ZERO,
-        }
-    }
-
-    fn run(&mut self, cursor: CursorState) {
-        self.render.run_sensors(
-            &mut self.rsc,
-            &mut self.state,
-            cursor,
-            (WINDOW, WINDOW).into(),
-        );
-    }
+/// 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 full(ui: &mut Ui) -> StrongWidget<Rect> {
-    rect(UiColor::WHITE).add_strong(&mut ui.rsc)
+fn harness() -> Harness {
+    Harness::new((WINDOW, WINDOW))
 }
 
 #[test]
 fn hover_stops_at_the_topmost_widget() {
-    let mut ui = Ui::new();
-    let (bottom, middle, top) = (full(&mut ui), full(&mut ui), full(&mut ui));
-    let bottom_hover = ui.listen(&bottom, CursorSense::HoverStart);
-    let middle_hover = ui.listen(&middle, CursorSense::HoverStart);
-    let top_hover = ui.listen(&top, CursorSense::HoverStart);
-    ui.stack(vec![bottom.any(), middle.any(), top.any()]);
+    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());
 
-    let cursor = ui.cursor((50.0, 50.0));
-    ui.run(cursor);
+    h.move_to((50, 50));
 
     assert_eq!(top_hover.take(), [CursorSense::HoverStart]);
     assert_eq!(
@@ -147,16 +60,14 @@ fn hover_stops_at_the_topmost_widget() {
 
 #[test]
 fn a_scroll_passes_through_every_widget_that_does_not_want_it() {
-    let mut ui = Ui::new();
-    let (list, button, overlay) = (full(&mut ui), full(&mut ui), full(&mut ui));
-    let scrolled = ui.listen(&list, CursorSense::Scroll);
-    let clicked = ui.listen(&button, CursorSense::click());
-    let overlay_clicked = ui.listen(&overlay, CursorSense::click());
-    ui.stack(vec![list.any(), button.any(), overlay.any()]);
+    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());
 
-    let mut cursor = ui.cursor((50.0, 50.0));
-    cursor.scroll_delta = (0.0, 10.0).into();
-    ui.run(cursor);
+    h.move_to((50, 50));
+    h.scroll((0, 10));
 
     assert_eq!(
         scrolled.take(),
@@ -168,37 +79,32 @@ fn a_scroll_passes_through_every_widget_that_does_not_want_it() {
 }
 
 #[test]
-fn a_click_and_a_scroll_in_one_frame_go_to_different_widgets() {
-    let mut ui = Ui::new();
-    let (list, button) = (full(&mut ui), full(&mut ui));
-    let scrolled = ui.listen(&list, CursorSense::Scroll);
-    let clicked = ui.listen(&button, CursorSense::click());
-    ui.stack(vec![list.any(), button.any()]);
+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());
 
-    let mut cursor = ui.cursor((50.0, 50.0));
-    cursor.scroll_delta = (0.0, 10.0).into();
-    cursor.buttons.left = ActivationState::Start;
-    ui.run(cursor);
+    // The hover arrives in its own frame, as a window delivers it.
+    h.move_to((50, 50));
+    assert_eq!(scrolled.take(), []);
 
-    assert_eq!(clicked.take(), [CursorSense::click()]);
+    h.scroll((0, 10));
     assert_eq!(
         scrolled.take(),
         [CursorSense::Scroll],
-        "taking the click must not take the scroll with it"
+        "a hover already resting on the button must not consume the wheel"
     );
 }
 
 #[test]
 fn only_the_topmost_listener_takes_a_press() {
-    let mut ui = Ui::new();
-    let (below, above) = (full(&mut ui), full(&mut ui));
-    let below_clicked = ui.listen(&below, CursorSense::click());
-    let above_clicked = ui.listen(&above, CursorSense::click());
-    ui.stack(vec![below.any(), above.any()]);
+    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());
 
-    let mut cursor = ui.cursor((50.0, 50.0));
-    cursor.buttons.left = ActivationState::Start;
-    ui.run(cursor);
+    h.click((50, 50));
 
     assert_eq!(above_clicked.take(), [CursorSense::click()]);
     assert_eq!(below_clicked.take(), [], "one press goes to one widget");
@@ -206,29 +112,18 @@ fn only_the_topmost_listener_takes_a_press() {
 
 #[test]
 fn a_press_beside_the_button_reaches_the_layer_below() {
-    let mut ui = Ui::new();
-    let list = full(&mut ui);
+    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 = full(&mut ui);
-    let gap = full(&mut ui);
-    let list_clicked = ui.listen(&list, CursorSense::click());
-    let button_clicked = ui.listen(&button, CursorSense::click());
-    let row = ui.rsc.ui.widgets.add_strong(Span {
-        children: vec![button.any(), gap.any()],
-        dir: Dir::RIGHT,
-        gap: 0.0,
-    });
-    ui.stack(vec![list.any(), row.any()]);
+    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());
 
-    let mut on_button = ui.cursor((20.0, 50.0));
-    on_button.buttons.left = ActivationState::Start;
-    ui.run(on_button);
+    h.click((20, 50));
     assert_eq!(button_clicked.take(), [CursorSense::click()]);
     assert_eq!(list_clicked.take(), []);
 
-    let mut beside_it = ui.cursor((80.0, 50.0));
-    beside_it.buttons.left = ActivationState::Start;
-    ui.run(beside_it);
+    h.click((80, 50));
     assert_eq!(button_clicked.take(), [], "the cursor is not on the button");
     assert_eq!(
         list_clicked.take(),
@@ -239,17 +134,92 @@ fn a_press_beside_the_button_reaches_the_layer_below() {
 
 #[test]
 fn leaving_a_widget_still_ends_its_hover() {
-    let mut ui = Ui::new();
-    let widget = full(&mut ui);
-    let hover = ui.listen(&widget, CursorSense::HoverStart | CursorSense::HoverEnd);
-    ui.stack(vec![widget.any()]);
+    let mut h = harness();
+    let (widget, hover) = listener(&mut h, CursorSense::HoverStart | CursorSense::HoverEnd);
+    h.set_root(widget);
 
-    let cursor = ui.cursor((50.0, 50.0));
-    ui.run(cursor);
+    h.move_to((50, 50));
     assert_eq!(hover.take(), [CursorSense::HoverStart]);
 
-    let mut gone = ui.cursor((50.0, 50.0));
-    gone.exists = false;
-    ui.run(gone);
+    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);
+}