implement timers

Author: richard-uk1

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();
+}

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;
@@ -18,6 +18,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, Color, Insets, Point, Rect, Size, Widget, WidgetId, WidgetPod,
@@ -714,8 +716,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.
@@ -738,9 +745,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

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

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;
@@ -19,13 +17,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::{Color, PointerEvent, TextEvent, Widget, WidgetId};
 
 #[derive(Debug)]
@@ -83,8 +82,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
@@ -163,20 +161,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(
@@ -220,14 +210,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);
     }
@@ -264,6 +246,7 @@ impl MasonryState<'_> {
             frame: None,
             pointer_state: PointerState::empty(),
             proxy: event_loop.create_proxy(),
+            timers: TimerQueue::new(),
 
             window: WindowState::Uninitialized(window),
             background_color,
@@ -678,10 +661,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) {}
 
@@ -706,6 +714,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);
                 }

masonry/src/lib.rs

@@ -160,6 +160,7 @@ mod event;
 mod paint_scene_helpers;
 mod passes;
 mod render_root;
+mod timers;
 mod tracing_backend;
 
 pub mod event_loop_runner;

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.

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);

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};
@@ -110,6 +111,7 @@ pub struct TestHarness {
     has_ime_session: bool,
     ime_rect: (LogicalPosition<f64>, LogicalSize<f64>),
     title: String,
+    timers: TimerQueue,
 }
 
 pub struct TestHarnessParams {
@@ -215,6 +217,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));
 
@@ -260,6 +263,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;
                 }