From 123bfc76e0f85085a6abc71acce93fc2cb8717a1 Mon Sep 17 00:00:00 2001
From: Richard Dodd <richard.o.dodd@gmail.com>
Date: Sun, 15 Dec 2024 16:39:54 +0000
Subject: [PATCH 1/2] Add animation to progress bar

---
 masonry/src/event_loop_runner.rs   | 21 ++++++++
 masonry/src/widget/progress_bar.rs | 77 +++++++++++++++++++++++++++++-
 2 files changed, 97 insertions(+), 1 deletion(-)

diff --git a/masonry/src/event_loop_runner.rs b/masonry/src/event_loop_runner.rs
index dda6a5636..c5d3a989a 100644
--- a/masonry/src/event_loop_runner.rs
+++ b/masonry/src/event_loop_runner.rs
@@ -1,8 +1,11 @@
 // Copyright 2024 the Xilem Authors
 // SPDX-License-Identifier: Apache-2.0
 
+use std::cmp::Reverse;
+use std::collections::BinaryHeap;
 use std::num::NonZeroUsize;
 use std::sync::Arc;
+use std::time::Instant;
 
 use accesskit_winit::Adapter;
 use tracing::{debug, info_span, warn};
@@ -81,6 +84,8 @@ pub struct MasonryState<'a> {
     proxy: EventLoopProxy,
     #[cfg(feature = "tracy")]
     frame: Option<tracing_tracy::client::Frame>,
+    // timers as a min priority queue
+    timers: BinaryHeap<Reverse<Instant>>,
 
     // Per-Window state
     // In future, this will support multiple windows
@@ -159,6 +164,22 @@ impl ApplicationHandler<MasonryUserEvent> for MainState<'_> {
         self.masonry_state.handle_suspended(event_loop);
     }
 
+    fn new_events(&mut self, event_loop: &ActiveEventLoop, cause: StartCause) {
+        // check if timers have elapsed and set event loop to wake at next timer deadline
+        let now = Instant::now();
+        loop {
+            let Some(next_timer) = self.masonry_state.timers.peek().cloned() else {
+                break;
+            };
+            let next_timer = next_timer.0;
+            if next_timer > now {
+                break;
+            }
+            // timer has elapsed - remove from heap and handle
+            self.masonry_state.timers.pop();
+        }
+    }
+
     fn window_event(
         &mut self,
         event_loop: &ActiveEventLoop,
diff --git a/masonry/src/widget/progress_bar.rs b/masonry/src/widget/progress_bar.rs
index 64b53b5b7..d98b07845 100644
--- a/masonry/src/widget/progress_bar.rs
+++ b/masonry/src/widget/progress_bar.rs
@@ -3,11 +3,14 @@
 
 //! A progress bar widget.
 
+use std::time::Duration;
+
 use accesskit::{Node, Role};
 use smallvec::{smallvec, SmallVec};
 use tracing::{trace_span, Span};
 use vello::Scene;
 
+use crate::contexts::TimerToken;
 use crate::kurbo::Size;
 use crate::paint_scene_helpers::{fill_lin_gradient, stroke, UnitPoint};
 use crate::text::ArcStr;
@@ -27,6 +30,10 @@ pub struct ProgressBar {
     /// It is also used if an invalid float (outside of [0, 1]) is passed.
     progress: Option<f64>,
     label: WidgetPod<Label>,
+    animate: bool,
+    anim_pixel_position: f64,
+    anim_prev_interval: Option<u64>,
+    next_anim_token: Option<TimerToken>,
 }
 
 impl ProgressBar {
@@ -40,7 +47,39 @@ impl ProgressBar {
         let label = WidgetPod::new(
             Label::new(Self::value(progress)).with_line_break_mode(LineBreaking::Overflow),
         );
-        Self { progress, label }
+        Self {
+            progress,
+            label,
+            animate: false,
+            anim_pixel_position: 0.,
+            anim_prev_interval: None,
+            next_anim_token: None,
+        }
+    }
+
+    pub fn animate(mut self, animate: bool) -> Self {
+        if !animate {
+            self.reset_animation();
+        }
+        self.animate = animate;
+        self
+    }
+
+    fn reset_animation(&mut self) {
+        self.anim_pixel_position = 0.;
+        self.anim_prev_interval = None;
+        self.next_anim_token = None;
+    }
+
+    // Sync the animation state with the new widget state, if necessary.
+    fn sync_animation(&mut self, bar_width: f64) {
+        if !self.animate {
+            // don't do anything if we're not animating (position should already be 0)
+            return;
+        }
+        self.anim_pixel_position = self
+            .anim_pixel_position
+            .clamp(0., self.bar_end_proportion() * bar_width);
     }
 
     fn value_accessibility(&self) -> Box<str> {
@@ -58,6 +97,14 @@ impl ProgressBar {
             "".into()
         }
     }
+
+    fn bar_end_proportion(&self) -> f64 {
+        self.progress.unwrap_or(1.)
+    }
+
+    fn bar_end(&self, width: f64) -> f64 {
+        self.bar_end_proportion() * width
+    }
 }
 
 // --- MARK: WIDGETMUT ---
@@ -67,6 +114,7 @@ impl ProgressBar {
         let progress_changed = this.widget.progress != progress;
         if progress_changed {
             this.widget.progress = progress;
+            this.widget.sync_animation(this.ctx.size().width);
             let mut label = this.ctx.get_mut(&mut this.widget.label);
             Label::set_text(&mut label, Self::value(progress));
         }
@@ -174,6 +222,33 @@ impl Widget for ProgressBar {
         smallvec![self.label.id()]
     }
 
+    fn on_anim_frame(&mut self, ctx: &mut UpdateCtx, interval: u64) {
+        // pixel per 1ms
+        const NS_PER_PIXEL: f64 = 1_000_000.;
+        const DURATION_BETWEEN_ANIMATIONS: Duration = Duration::from_millis(2_500);
+        let Some(prev_interval) = self.anim_prev_interval else {
+            // lost interval somehow - restart animation
+            self.anim_prev_interval = Some(interval);
+            self.anim_pixel_position = 0.;
+            ctx.request_anim_frame();
+            ctx.request_paint_only();
+            return;
+        };
+
+        let diff_interval = interval.saturating_sub(prev_interval);
+        let new_position = self.anim_pixel_position + diff_interval as f64 * NS_PER_PIXEL;
+        let bar_end = self.bar_end(ctx.size().width);
+        if new_position >= bar_end {
+            // animation finished;
+            self.anim_pixel_position = 0.;
+            self.anim_prev_interval = None;
+            ctx.request_timer(DURATION_BETWEEN_ANIMATIONS);
+        } else {
+            ctx.request_anim_frame();
+            ctx.request_paint_only();
+        }
+    }
+
     fn make_trace_span(&self, ctx: &QueryCtx<'_>) -> Span {
         trace_span!("ProgressBar", id = ctx.widget_id().trace())
     }

From 969392c09917c922d714e1d9b865bbb3c4a12801 Mon Sep 17 00:00:00 2001
From: Richard Dodd <richard.o.dodd@gmail.com>
Date: Sun, 15 Dec 2024 22:08:14 +0000
Subject: [PATCH 2/2] implement timers

---
 masonry/examples/animation.rs      | 49 +++++++++++++++++
 masonry/src/contexts.rs            | 16 +++---
 masonry/src/event.rs               |  8 +++
 masonry/src/event_loop_runner.rs   | 71 ++++++++++++++-----------
 masonry/src/lib.rs                 |  1 +
 masonry/src/passes/event.rs        | 22 ++++++++
 masonry/src/render_root.rs         | 13 ++++-
 masonry/src/testing/harness.rs     |  6 +++
 masonry/src/timers.rs              | 85 ++++++++++++++++++++++++++++++
 masonry/src/widget/progress_bar.rs | 22 ++++++--
 masonry/src/widget/widget.rs       |  8 ++-
 xilem/src/view/progress_bar.rs     |  4 +-
 12 files changed, 263 insertions(+), 42 deletions(-)
 create mode 100644 masonry/examples/animation.rs
 create mode 100644 masonry/src/timers.rs

diff --git a/masonry/examples/animation.rs b/masonry/examples/animation.rs
new file mode 100644
index 000000000..4042e440c
--- /dev/null
+++ b/masonry/examples/animation.rs
@@ -0,0 +1,49 @@
+// Copyright 2019 the Xilem Authors and the Druid Authors
+// SPDX-License-Identifier: Apache-2.0
+
+//! This is a very small example of how to setup a masonry application.
+//! It does the almost bare minimum while still being useful.
+
+// On Windows platform, don't show a console when opening the app.
+//#![windows_subsystem = "windows"]
+
+use masonry::dpi::LogicalSize;
+use masonry::text::StyleProperty;
+use masonry::widget::{Button, Flex, Label, ProgressBar, RootWidget};
+use masonry::{Action, AppDriver, DriverCtx, FontWeight, WidgetId};
+use winit::window::Window;
+
+const VERTICAL_WIDGET_SPACING: f64 = 20.0;
+
+struct Driver;
+
+impl AppDriver for Driver {
+    fn on_action(&mut self, _ctx: &mut DriverCtx<'_>, _widget_id: WidgetId, action: Action) {
+        match action {
+            Action::ButtonPressed(_) => {
+                println!("Hello");
+            }
+            action => {
+                eprintln!("Unexpected action {action:?}");
+            }
+        }
+    }
+}
+
+fn main() {
+    let progress_bar = ProgressBar::new(None).animate(true);
+
+    let window_size = LogicalSize::new(400.0, 400.0);
+    let window_attributes = Window::default_attributes()
+        .with_title("Hello World!")
+        .with_resizable(true)
+        .with_min_inner_size(window_size);
+
+    masonry::event_loop_runner::run(
+        masonry::event_loop_runner::EventLoop::with_user_event(),
+        window_attributes,
+        RootWidget::new(progress_bar),
+        Driver,
+    )
+    .unwrap();
+}
diff --git a/masonry/src/contexts.rs b/masonry/src/contexts.rs
index da78ce259..2ca4c9bf8 100644
--- a/masonry/src/contexts.rs
+++ b/masonry/src/contexts.rs
@@ -3,7 +3,7 @@
 
 //! The context types that are passed into various widget methods.
 
-use std::time::Duration;
+use std::time::{Duration, Instant};
 
 use accesskit::TreeUpdate;
 use dpi::LogicalPosition;
@@ -19,6 +19,8 @@ use crate::passes::layout::run_layout_on;
 use crate::render_root::{MutateCallback, RenderRootSignal, RenderRootState};
 use crate::text::BrushIndex;
 use crate::theme::get_debug_color;
+use crate::timers::Timer;
+pub use crate::timers::TimerId;
 use crate::widget::{WidgetMut, WidgetRef, WidgetState};
 use crate::{AllowRawMut, BoxConstraints, Insets, Point, Rect, Size, Widget, WidgetId, WidgetPod};
 
@@ -713,8 +715,13 @@ impl_context_method!(
         ///
         /// The return value is a token, which can be used to associate the
         /// request with the event.
-        pub fn request_timer(&mut self, _deadline: Duration) -> TimerToken {
-            todo!("request_timer");
+        pub fn request_timer(&mut self, deadline: Duration) -> TimerId {
+            let deadline = Instant::now() + deadline;
+            let timer = Timer::new(self.widget_id(), deadline);
+            let id = timer.id;
+            self.global_state
+                .emit_signal(RenderRootSignal::TimerRequested(timer));
+            id
         }
 
         /// Mark child widget as stashed.
@@ -737,9 +744,6 @@ impl_context_method!(
     }
 );
 
-// FIXME - Remove
-pub struct TimerToken;
-
 impl EventCtx<'_> {
     // TODO - clearly document all semantics of pointer capture when they've been decided on
     // TODO - Figure out cases where widget should be notified of pointer capture
diff --git a/masonry/src/event.rs b/masonry/src/event.rs
index 29294f62c..cd40640b8 100644
--- a/masonry/src/event.rs
+++ b/masonry/src/event.rs
@@ -4,12 +4,14 @@
 //! Events.
 
 use std::path::PathBuf;
+use std::time::Instant;
 
 use winit::event::{Force, Ime, KeyEvent, Modifiers};
 use winit::keyboard::ModifiersState;
 
 use crate::dpi::{LogicalPosition, PhysicalPosition, PhysicalSize};
 use crate::kurbo::Rect;
+use crate::timers::TimerId;
 
 // TODO - Occluded(bool) event
 // TODO - winit ActivationTokenDone thing
@@ -213,6 +215,12 @@ pub struct AccessEvent {
     pub data: Option<accesskit::ActionData>,
 }
 
+#[derive(Debug, Clone, Copy)]
+pub struct TimerEvent {
+    pub id: TimerId,
+    pub deadline: Instant,
+}
+
 #[derive(Debug, Clone)]
 pub struct PointerState {
     // TODO
diff --git a/masonry/src/event_loop_runner.rs b/masonry/src/event_loop_runner.rs
index c5d3a989a..ec052fb8f 100644
--- a/masonry/src/event_loop_runner.rs
+++ b/masonry/src/event_loop_runner.rs
@@ -1,8 +1,6 @@
 // Copyright 2024 the Xilem Authors
 // SPDX-License-Identifier: Apache-2.0
 
-use std::cmp::Reverse;
-use std::collections::BinaryHeap;
 use std::num::NonZeroUsize;
 use std::sync::Arc;
 use std::time::Instant;
@@ -20,13 +18,14 @@ use winit::event::{
     DeviceEvent as WinitDeviceEvent, DeviceId, MouseButton as WinitMouseButton,
     WindowEvent as WinitWindowEvent,
 };
-use winit::event_loop::ActiveEventLoop;
+use winit::event_loop::{ActiveEventLoop, ControlFlow};
 use winit::window::{Window, WindowAttributes, WindowId};
 
 use crate::app_driver::{AppDriver, DriverCtx};
 use crate::dpi::LogicalPosition;
 use crate::event::{PointerButton, PointerState, WindowEvent};
 use crate::render_root::{self, RenderRoot, WindowSizePolicy};
+use crate::timers::TimerQueue;
 use crate::{PointerEvent, TextEvent, Widget, WidgetId};
 
 #[derive(Debug)]
@@ -84,8 +83,7 @@ pub struct MasonryState<'a> {
     proxy: EventLoopProxy,
     #[cfg(feature = "tracy")]
     frame: Option<tracing_tracy::client::Frame>,
-    // timers as a min priority queue
-    timers: BinaryHeap<Reverse<Instant>>,
+    timers: TimerQueue,
 
     // Per-Window state
     // In future, this will support multiple windows
@@ -164,20 +162,12 @@ impl ApplicationHandler<MasonryUserEvent> for MainState<'_> {
         self.masonry_state.handle_suspended(event_loop);
     }
 
-    fn new_events(&mut self, event_loop: &ActiveEventLoop, cause: StartCause) {
-        // check if timers have elapsed and set event loop to wake at next timer deadline
-        let now = Instant::now();
-        loop {
-            let Some(next_timer) = self.masonry_state.timers.peek().cloned() else {
-                break;
-            };
-            let next_timer = next_timer.0;
-            if next_timer > now {
-                break;
-            }
-            // timer has elapsed - remove from heap and handle
-            self.masonry_state.timers.pop();
-        }
+    fn new_events(
+        &mut self,
+        event_loop: &winit::event_loop::ActiveEventLoop,
+        cause: winit::event::StartCause,
+    ) {
+        self.masonry_state.handle_new_events(event_loop, cause);
     }
 
     fn window_event(
@@ -221,14 +211,6 @@ impl ApplicationHandler<MasonryUserEvent> for MainState<'_> {
         self.masonry_state.handle_about_to_wait(event_loop);
     }
 
-    fn new_events(
-        &mut self,
-        event_loop: &winit::event_loop::ActiveEventLoop,
-        cause: winit::event::StartCause,
-    ) {
-        self.masonry_state.handle_new_events(event_loop, cause);
-    }
-
     fn exiting(&mut self, event_loop: &winit::event_loop::ActiveEventLoop) {
         self.masonry_state.handle_exiting(event_loop);
     }
@@ -265,6 +247,7 @@ impl MasonryState<'_> {
             frame: None,
             pointer_state: PointerState::empty(),
             proxy: event_loop.create_proxy(),
+            timers: TimerQueue::new(),
 
             window: WindowState::Uninitialized(window),
             background_color,
@@ -679,10 +662,35 @@ impl MasonryState<'_> {
         self.handle_signals(event_loop, app_driver);
     }
 
-    // --- MARK: EMPTY WINIT HANDLERS ---
-    pub fn handle_about_to_wait(&mut self, _: &ActiveEventLoop) {}
+    // --- MARK: TIMERS ---
+    pub fn handle_new_events(&mut self, _: &ActiveEventLoop, _: winit::event::StartCause) {
+        // check if timers have elapsed and set event loop to wake at next timer deadline
+        let now = Instant::now();
+        loop {
+            let Some(next_timer) = self.timers.peek() else {
+                break;
+            };
+            if next_timer.deadline > now {
+                break;
+            }
+            // timer has elapsed - remove from heap and handle
+            let Some(elapsed_timer) = self.timers.pop() else {
+                debug_panic!("should be unreachable: peek was Some");
+                break;
+            };
+            self.render_root.handle_elapsed_timer(elapsed_timer);
+        }
+    }
+
+    pub fn handle_about_to_wait(&mut self, event_loop: &ActiveEventLoop) {
+        if let Some(next_timer) = self.timers.peek() {
+            event_loop.set_control_flow(ControlFlow::WaitUntil(next_timer.deadline));
+        } else {
+            event_loop.set_control_flow(ControlFlow::Wait);
+        }
+    }
 
-    pub fn handle_new_events(&mut self, _: &ActiveEventLoop, _: winit::event::StartCause) {}
+    // --- MARK: EMPTY WINIT HANDLERS ---
 
     pub fn handle_exiting(&mut self, _: &ActiveEventLoop) {}
 
@@ -707,6 +715,9 @@ impl MasonryState<'_> {
                         app_driver.on_action(&mut driver_ctx, widget_id, action);
                     });
                 }
+                render_root::RenderRootSignal::TimerRequested(timer) => {
+                    self.timers.push(timer);
+                }
                 render_root::RenderRootSignal::StartIme => {
                     window.set_ime_allowed(true);
                 }
diff --git a/masonry/src/lib.rs b/masonry/src/lib.rs
index a948bb28d..601c7356e 100644
--- a/masonry/src/lib.rs
+++ b/masonry/src/lib.rs
@@ -161,6 +161,7 @@ mod event;
 mod paint_scene_helpers;
 mod passes;
 mod render_root;
+mod timers;
 mod tracing_backend;
 
 pub mod event_loop_runner;
diff --git a/masonry/src/passes/event.rs b/masonry/src/passes/event.rs
index 3a9e3c23a..95902f9a7 100644
--- a/masonry/src/passes/event.rs
+++ b/masonry/src/passes/event.rs
@@ -6,8 +6,10 @@ use tracing::{debug, info_span, trace};
 use winit::event::ElementState;
 use winit::keyboard::{KeyCode, PhysicalKey};
 
+use crate::event::TimerEvent;
 use crate::passes::{enter_span, merge_state_up};
 use crate::render_root::RenderRoot;
+use crate::timers::Timer;
 use crate::{AccessEvent, EventCtx, Handled, PointerEvent, TextEvent, Widget, WidgetId};
 
 // --- MARK: HELPERS ---
@@ -135,6 +137,26 @@ pub(crate) fn run_on_pointer_event_pass(root: &mut RenderRoot, event: &PointerEv
     handled
 }
 
+pub(crate) fn run_on_elapsed_timer_pass(root: &mut RenderRoot, timer: &Timer) -> Handled {
+    let event = TimerEvent {
+        deadline: timer.deadline,
+        id: timer.id,
+    };
+    let handled = run_event_pass(
+        root,
+        Some(timer.widget_id),
+        &event,
+        false,
+        |widget, ctx, event| {
+            widget.on_timer_expired(ctx, event);
+            // don't traverse for this event
+            ctx.set_handled();
+        },
+        true,
+    );
+    handled
+}
+
 // TODO https://github.com/linebender/xilem/issues/376 - Some implicit invariants:
 // - If a Widget gets a keyboard event or an ImeStateChange, then
 // focus is on it, its child or its parent.
diff --git a/masonry/src/render_root.rs b/masonry/src/render_root.rs
index d52df7c76..4df8f6d85 100644
--- a/masonry/src/render_root.rs
+++ b/masonry/src/render_root.rs
@@ -24,7 +24,8 @@ use crate::passes::accessibility::run_accessibility_pass;
 use crate::passes::anim::run_update_anim_pass;
 use crate::passes::compose::run_compose_pass;
 use crate::passes::event::{
-    run_on_access_event_pass, run_on_pointer_event_pass, run_on_text_event_pass,
+    run_on_access_event_pass, run_on_elapsed_timer_pass, run_on_pointer_event_pass,
+    run_on_text_event_pass,
 };
 use crate::passes::layout::run_layout_pass;
 use crate::passes::mutate::{mutate_widget, run_mutate_pass};
@@ -36,6 +37,7 @@ use crate::passes::update::{
 };
 use crate::passes::{recurse_on_children, PassTracing};
 use crate::text::BrushIndex;
+use crate::timers::Timer;
 use crate::widget::{WidgetArena, WidgetMut, WidgetRef, WidgetState};
 use crate::{AccessEvent, Action, CursorIcon, Handled, QueryCtx, Widget, WidgetId, WidgetPod};
 
@@ -123,6 +125,7 @@ pub struct RenderRootOptions {
 
 pub enum RenderRootSignal {
     Action(Action, WidgetId),
+    TimerRequested(Timer),
     StartIme,
     EndIme,
     ImeMoved(LogicalPosition<f64>, LogicalSize<f64>),
@@ -259,6 +262,14 @@ impl RenderRoot {
     }
 
     // --- MARK: PUB FUNCTIONS ---
+    pub fn handle_elapsed_timer(&mut self, timer: Timer) -> Handled {
+        let _span = info_span!("elapsed_timer");
+        let handled = run_on_elapsed_timer_pass(self, &timer);
+        self.run_rewrite_passes();
+
+        handled
+    }
+
     pub fn handle_pointer_event(&mut self, event: PointerEvent) -> Handled {
         let _span = info_span!("pointer_event");
         let handled = run_on_pointer_event_pass(self, &event);
diff --git a/masonry/src/testing/harness.rs b/masonry/src/testing/harness.rs
index 938df768e..44c6622fe 100644
--- a/masonry/src/testing/harness.rs
+++ b/masonry/src/testing/harness.rs
@@ -25,6 +25,7 @@ use crate::passes::anim::run_update_anim_pass;
 use crate::render_root::{RenderRoot, RenderRootOptions, RenderRootSignal, WindowSizePolicy};
 use crate::testing::screenshots::get_image_diff;
 use crate::testing::snapshot_utils::get_cargo_workspace;
+use crate::timers::TimerQueue;
 use crate::tracing_backend::try_init_test_tracing;
 use crate::widget::{WidgetMut, WidgetRef};
 use crate::{Color, Handled, Point, Size, Vec2, Widget, WidgetId};
@@ -116,6 +117,7 @@ pub struct TestHarness {
     has_ime_session: bool,
     ime_rect: (LogicalPosition<f64>, LogicalSize<f64>),
     title: String,
+    timers: TimerQueue,
 }
 
 /// Assert a snapshot of a rendered frame of your app.
@@ -199,6 +201,7 @@ impl TestHarness {
             has_ime_session: false,
             ime_rect: Default::default(),
             title: String::new(),
+            timers: TimerQueue::new(),
         };
         harness.process_window_event(WindowEvent::Resize(window_size));
 
@@ -244,6 +247,9 @@ impl TestHarness {
                 RenderRootSignal::Action(action, widget_id) => {
                     self.action_queue.push_back((action, widget_id));
                 }
+                RenderRootSignal::TimerRequested(timer) => {
+                    self.timers.push(timer);
+                }
                 RenderRootSignal::StartIme => {
                     self.has_ime_session = true;
                 }
diff --git a/masonry/src/timers.rs b/masonry/src/timers.rs
new file mode 100644
index 000000000..e75e38c4c
--- /dev/null
+++ b/masonry/src/timers.rs
@@ -0,0 +1,85 @@
+use std::{
+    collections::BinaryHeap,
+    num::NonZeroU64,
+    sync::atomic::{AtomicU64, Ordering},
+    time::Instant,
+};
+
+use crate::WidgetId;
+
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
+pub struct TimerId(NonZeroU64);
+
+impl TimerId {
+    pub fn next() -> TimerId {
+        static TIMER_ID_COUNTER: AtomicU64 = AtomicU64::new(1);
+        let id = TIMER_ID_COUNTER.fetch_add(1, Ordering::Relaxed);
+        TimerId(id.try_into().unwrap())
+    }
+}
+/// An ordered list of timers set by masonry
+///
+/// Implemented as a min priority queue
+pub struct TimerQueue {
+    queue: BinaryHeap<Timer>,
+}
+
+impl TimerQueue {
+    pub fn new() -> Self {
+        Self {
+            queue: BinaryHeap::new(),
+        }
+    }
+
+    pub fn push(&mut self, timer: Timer) {
+        self.queue.push(timer);
+    }
+
+    /// Copy and return the `Instant` at the head of the queue
+    pub fn peek(&self) -> Option<Timer> {
+        self.queue.peek().map(|v| *v)
+    }
+
+    /// Remove the `Instant` at the head of the queue and return it
+    pub fn pop(&mut self) -> Option<Timer> {
+        self.queue.pop()
+    }
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub struct Timer {
+    pub id: TimerId,
+    pub widget_id: WidgetId,
+    pub deadline: Instant,
+}
+
+impl Timer {
+    pub fn new(widget_id: WidgetId, deadline: Instant) -> Self {
+        Self {
+            id: TimerId::next(),
+            widget_id,
+            deadline,
+        }
+    }
+}
+
+// We implement `Ord` first by comparing `deadline`, and then
+// `id`. This way, we ensure that timers with the same expiry
+// time will trigger in the order they were created.
+//
+// Because Rust std's `BinaryHeap` is max-first, we need to reverse
+// both comparisons.
+impl Ord for Timer {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.deadline
+            .cmp(&other.deadline)
+            .reverse()
+            .then(self.id.cmp(&other.id).reverse())
+    }
+}
+
+impl PartialOrd for Timer {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
diff --git a/masonry/src/widget/progress_bar.rs b/masonry/src/widget/progress_bar.rs
index d98b07845..0d6001ef4 100644
--- a/masonry/src/widget/progress_bar.rs
+++ b/masonry/src/widget/progress_bar.rs
@@ -10,7 +10,8 @@ use smallvec::{smallvec, SmallVec};
 use tracing::{trace_span, Span};
 use vello::Scene;
 
-use crate::contexts::TimerToken;
+use crate::contexts::TimerId;
+use crate::event::TimerEvent;
 use crate::kurbo::Size;
 use crate::paint_scene_helpers::{fill_lin_gradient, stroke, UnitPoint};
 use crate::text::ArcStr;
@@ -33,7 +34,7 @@ pub struct ProgressBar {
     animate: bool,
     anim_pixel_position: f64,
     anim_prev_interval: Option<u64>,
-    next_anim_token: Option<TimerToken>,
+    next_anim_token: Option<TimerId>,
 }
 
 impl ProgressBar {
@@ -57,6 +58,7 @@ impl ProgressBar {
         }
     }
 
+    /// Note - if calling this in a lifecycle method, you must also request an anim frame.
     pub fn animate(mut self, animate: bool) -> Self {
         if !animate {
             self.reset_animation();
@@ -148,7 +150,13 @@ impl Widget for ProgressBar {
         ctx.register_child(&mut self.label);
     }
 
-    fn update(&mut self, _ctx: &mut UpdateCtx, _event: &Update) {}
+    fn update(&mut self, ctx: &mut UpdateCtx, event: &Update) {
+        if matches!(event, Update::WidgetAdded) {
+            if self.animate {
+                ctx.request_anim_frame();
+            }
+        }
+    }
 
     fn layout(&mut self, ctx: &mut LayoutCtx, bc: &BoxConstraints) -> Size {
         const DEFAULT_WIDTH: f64 = 400.;
@@ -222,7 +230,15 @@ impl Widget for ProgressBar {
         smallvec![self.label.id()]
     }
 
+    fn on_timer_expired(&mut self, ctx: &mut EventCtx, _event: &TimerEvent) {
+        println!("on_timer_expired");
+        self.reset_animation();
+        ctx.request_anim_frame();
+        ctx.request_paint_only();
+    }
+
     fn on_anim_frame(&mut self, ctx: &mut UpdateCtx, interval: u64) {
+        println!("on_anim_frame");
         // pixel per 1ms
         const NS_PER_PIXEL: f64 = 1_000_000.;
         const DURATION_BETWEEN_ANIMATIONS: Duration = Duration::from_millis(2_500);
diff --git a/masonry/src/widget/widget.rs b/masonry/src/widget/widget.rs
index 3134b86ae..0515732ce 100644
--- a/masonry/src/widget/widget.rs
+++ b/masonry/src/widget/widget.rs
@@ -15,7 +15,7 @@ use tracing::{trace_span, Span};
 use vello::Scene;
 
 use crate::contexts::ComposeCtx;
-use crate::event::{AccessEvent, PointerEvent, TextEvent};
+use crate::event::{AccessEvent, PointerEvent, TextEvent, TimerEvent};
 use crate::widget::WidgetRef;
 use crate::{
     AccessCtx, AsAny, BoxConstraints, EventCtx, LayoutCtx, PaintCtx, Point, QueryCtx, RegisterCtx,
@@ -86,6 +86,12 @@ pub trait Widget: AsAny {
     /// Handle an event from the platform's accessibility API.
     fn on_access_event(&mut self, ctx: &mut EventCtx, event: &AccessEvent) {}
 
+    /// Called when a timer set by this widget expires
+    ///
+    /// When you create a timer, you can stash the ID returned and compare it against
+    /// `event.id`.
+    fn on_timer_expired(&mut self, ctx: &mut EventCtx, event: &TimerEvent) {}
+
     /// Called at the beginning of a new animation frame.
     ///
     /// An animation frame does not implicitly request a repaint of this widget.
diff --git a/xilem/src/view/progress_bar.rs b/xilem/src/view/progress_bar.rs
index 7917788b8..17b56483e 100644
--- a/xilem/src/view/progress_bar.rs
+++ b/xilem/src/view/progress_bar.rs
@@ -20,7 +20,9 @@ impl<State, Action> View<State, Action, ViewCtx> for ProgressBar {
     type ViewState = ();
 
     fn build(&self, ctx: &mut ViewCtx) -> (Self::Element, Self::ViewState) {
-        ctx.with_leaf_action_widget(|ctx| ctx.new_pod(widget::ProgressBar::new(self.progress)))
+        ctx.with_leaf_action_widget(|ctx| {
+            ctx.new_pod(widget::ProgressBar::new(self.progress).animate(true))
+        })
     }
 
     fn rebuild(